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,22 @@ class BooleanParser < ValueParser
       allow TrueClass, FalseClass
 
       parser do |val, options|
-        raise Decanter::ParseError.new 'Expects a single value' if val.is_a? Array
-        next if (val.nil? || val === '')
-        [1, '1'].include?(val) || !!/true/i.match(val.to_s)
+        normalized_val = normalize(val)
+        next if normalized_val.nil?
+
+        true_values = ['1', 'true']
+
+        option_val = options.fetch(:true_value, nil)
+        normalized_option = normalize(option_val)
+
+        true_values << normalized_option if normalized_option
+        true_values.find {|tv| !!/#{tv}/i.match(normalized_val)}.present?
+      end
+
+      def self.normalize(value)
+        return if (value.nil? || value === '')
+        raise Decanter::ParseError.new 'Expects a single value' if value.is_a? Array
+        value.to_s.downcase
       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],
+      ['string', 'false', 'string', 'false'],
+      ['string', 'false', 'string', 'False'],
+    ]
+
+    falses_with_options = [
+      ['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