add logic to BooleanParser to allow for optional truthy arguments

README.md

@@ -143,6 +143,12 @@ Parsers can receive options that modify their behavior. These options are passed
 input :start_date, :date, parse_format: '%Y-%m-%d'
 ```
 
+`:boolean` will parse values of `true` and `1` as truthy. If another value is expected to be truthy, use the option `truth_value` to assign a custom truthy case.
+
+```ruby
+input :checkbox, :boolean, truth_value: 'yes'
+```
+
 ### Exceptions
 
 By default, `Decanter#decant` will raise an exception when unexpected parameters are passed. To override this behavior, you can change the strict mode option to one of:

lib/decanter/parser/boolean_parser.rb

@@ -5,9 +5,27 @@ class BooleanParser < ValueParser
       allow TrueClass, FalseClass
 
       parser do |val, options|
-        raise Decanter::ParseError.new 'Expects a single value' if val.is_a? Array
+        single_value_check(val)
         next if (val.nil? || val === '')
-        [1, '1'].include?(val) || !!/true/i.match(val.to_s)
+        [1, '1'].include?(val) || !!/true/i.match(val.to_s) || parse_options(val, options)
+      end
+
+      def self.parse_options(val, options)
+        raw_true_value = options.fetch(:true_value, nil)
+        return false if raw_true_value.nil?
+
+        single_value_check(raw_true_value)
+        true_value = raw_true_value.to_s.downcase
+
+        # want to avoid using values that are already implemented
+        accounted_for_values = ['false', 'true', '1', '0', '']
+        return false if accounted_for_values.include?(true_value)
+
+        !!/#{true_value}/i.match(val.to_s)
+      end
+
+      def self.single_value_check(v)
+        raise Decanter::ParseError.new 'Expects a single value' if v.is_a? Array
       end
     end
   end

spec/decanter/parser/boolean_parser_spec.rb

@@ -12,15 +12,29 @@
       ['boolean', true],
       ['string', 'true'],
       ['string', 'True'],
-      ['string', 'truE']
     ]
 
     falses = [
       ['number', 0],
       ['number', 2],
       ['string', '2'],
       ['boolean', false],
-      ['string', 'tru']
+    ]
+
+    trues_with_options = [
+      ['string', 'yes', 'string', 'yes'],
+      ['string', 'Yes', 'string', 'yes'],
+      ['string', 'is true', 'string', 'is true'],
+      ['string', 'is truE', 'string', 'is True'],
+      ['number', 3, 'number', 3],
+      ['number', 3, 'string', '3'],
+      ['string', '3', 'number', 3],
+    ]
+
+    falses_with_options = [
+      ['string', 'false', 'string', 'false'],
+      ['string', 'false', 'string', 'False'],
+      ['string', 'yes', 'string', ''],
     ]
 
     let(:name) { :foo }
@@ -61,5 +75,33 @@
           .to raise_error(Decanter::ParseError)
       end
     end
+
+    context 'returns true with options for' do
+      trues_with_options.each do |cond|
+        it "#{cond[0]}: #{cond[1]}, option: {#{cond[2]}: #{cond[3]}}" do
+          expect(parser.parse(name, cond[1], true_value: cond[3])).to match({name => true})
+        end
+      end
+    end
+
+    context 'returns false with options for' do
+      falses_with_options.each do |cond|
+        it "#{cond[0]}: #{cond[1]}, option: {#{cond[2]}: #{cond[3]}}" do
+          expect(parser.parse(name, cond[1], true_value: cond[3])).to match({name => false})
+        end
+      end
+    end
+
+    context 'with empty string and empty options' do
+      it 'returns nil' do
+        expect(parser.parse(name, '', true_value: '')).to match({name => nil})
+      end
+    end
+
+    context 'with nil and nil options' do
+      it 'returns nil' do
+        expect(parser.parse(name, nil, true_value: nil)).to match({name => nil})
+      end
+    end
   end
 end