decanter 0.7.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fcecd146883e6b44658dcee94a7271f552c695cf
-  data.tar.gz: 1362e8a5b04500354b60f7530916c487fed7f6c6
+  metadata.gz: 284c077381d45c71768a4e7523843a6970ad386c
+  data.tar.gz: 09fc5570e94021864b353ae4f928aea669e1507c
 SHA512:
-  metadata.gz: f95eee6b059ac8f0ec596fe74889dfeae1e30392a86d76a9159c07f895b5016300068f945d5e49d30bd9feace6257b28d3ab9f6ff29ec105fc923ff14a147ccf
-  data.tar.gz: bcc79760fca3ebfb1fc1d4ce4aa4ae04993d0acff6422be01e0a40a7de4c7556d7269d636fff739a8e90f022d0873c0a83cad0b3fd51ec4931adbda8ec4fe843
+  metadata.gz: a058f4fc3a206341742af0e39d62abc663d7a8665b244f2ab29bc8f9df73cd810955fa19502bc8943b32f8662e1dcf254c4ceeac6ce20eed997a9b51a48e9317
+  data.tar.gz: 19442b1a6b19562768fa4a87a125f661199660bac14eebf4c19ef78bfbc64d4fbab11d6f181d4e97ddb8e9db16fb08bcb3de3f28cd95db9ca3386aad99f247ea

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    decanter (0.7.1)
+    decanter (0.7.2)
       activesupport
 
 GEM

data/README.md

@@ -378,6 +378,45 @@ class SquashDateParser < Decanter::Parser::ValueParser
 end
 ```
 
+Chaining Parsers
+---
+
+Parsers are composable! Suppose you want a parser that takes an incoming percentage like "50.3%" and converts it into a float for your database like .503. You could implement this with:
+
+```ruby
+class PercentParser < ValueParser
+  REGEX = /(\d|[.])/
+
+  parser do |val, options|
+    my_float = val.scan(REGEX).join.try(:to_f)
+    my_float / 100 if my_float
+  end
+end
+```
+
+This works, but it duplicates logic that already exists in `FloatParser`. Instead, you can specify a parser that should always run before your parsing logic, then you can assume that your parser receives a float:
+
+```ruby
+class SmartPercentParser < ValueParser
+
+  pre :float
+
+  parser do |val, options|
+    val / 100
+  end
+end
+```
+
+If a preparser returns nil or an empty string, subsequent parsers will not be called, just like normal!
+
+This can also be achieved by providing multiple parsers in your decanter:
+
+```ruby
+class SomeDecanter < Decanter::Base
+  input :some_percent, [:float, :percent]
+end
+```
+
 No Need for Strong Params
 ---
 
@@ -403,6 +442,8 @@ class TripDecanter <  Decanter::Base
 end
 ```
 
+In addition, if you provide the option `:required` for an input in your decanter, an exception will be thrown if the parameters is nil or an empty string.
+
 Configuration
 ---
 

data/lib/decanter/core.rb

@@ -7,11 +7,11 @@ module Decanter
 
     module ClassMethods
 
-      def input(name, parser=nil, **options)
+      def input(name, parsers=nil, **options)
 
         _name = [name].flatten
 
-        if _name.length > 1 && parser.blank?
+        if _name.length > 1 && parsers.blank?
           raise ArgumentError.new("#{self.name} no parser specified for input with multiple values.")
         end
 
@@ -19,7 +19,7 @@ module Decanter
           key:     options.fetch(:key, _name.first),
           name:    _name,
           options: options,
-          parser:  parser,
+          parsers:  parsers,
           type:    :input
         }
       end
@@ -102,7 +102,7 @@ module Decanter
       def handle_input(handler, args)
          values = args.values_at(*handler[:name])
          values = values.length == 1 ? values.first : values
-         parse(handler[:key], handler[:parser], values, handler[:options])
+         parse(handler[:key], handler[:parsers], values, handler[:options])
       end
 
       def handle_association(handler, args)
@@ -154,12 +154,18 @@ module Decanter
         end
       end
 
-      def parse(key, parser, values, options)
-        parser ?
-          Parser.parser_for(parser)
-                     .parse(key, values, options)
-          :
+      def parse(key, parsers, values, options)
+        case
+        when !parsers
           { key => values }
+        when options[:required] == true && Array.wrap(values).all? { |value| value.nil? || value == "" }
+          raise ArgumentError.new("No value for required argument: #{key}")
+        else
+          Parser.parsers_for(parsers)
+                .reduce({key => values}) do |vals_hash, parser|
+                  vals_hash.keys.reduce({}) { |acc, k| acc.merge(parser.parse(k, vals_hash[k], options)) }
+                end
+        end
       end
 
       def handlers

data/lib/decanter/parser.rb

@@ -2,8 +2,17 @@ module Decanter
   module Parser
 
     class << self
-      def parser_for(klass_or_sym)
-        parser_str = case klass_or_sym
+      def parsers_for(klass_or_syms)
+        Array.wrap(klass_or_syms)
+             .map { |klass_or_sym| klass_or_sym_to_str(klass_or_sym) }
+             .map { |parser_str|   parser_constantize(parser_str) }
+             .map { |parser|       expand(parser) }
+             .flatten
+      end
+
+      # convert from a class or symbol to a string and concat 'Parser'
+      def klass_or_sym_to_str(klass_or_sym)
+        case klass_or_sym
         when Class
           klass_or_sym.name
         when Symbol
@@ -11,10 +20,18 @@ module Decanter
         else
           raise ArgumentError.new("cannot lookup parser for #{klass_or_sym} with class #{klass_or_sym.class}")
         end.concat('Parser')
+      end
+
+      # convert from a string to a constant
+      def parser_constantize(parser_str)
+        parser_str.safe_constantize ||
+        "Decanter::Parser::".concat(parser_str).safe_constantize ||
+        raise(NameError.new("cannot find parser #{parser_str}"))
+      end
 
-        parser = parser_str.safe_constantize || "Decanter::Parser::".concat(parser_str).safe_constantize
-        raise NameError.new("cannot find parser #{parser_str}") unless parser
-        parser
+      # expand to include preparsers
+      def expand(parser)
+        Parser.parsers_for(parser.preparsers).push(parser)
       end
     end
   end

data/lib/decanter/parser/core.rb

@@ -8,38 +8,42 @@ module Decanter
 
       module ClassMethods
 
-        # Meant to be overriden and called by child parser
+        # Check if allowed, parse if not
         def parse(name, values, options={})
-
-          value_ary = values.is_a?(Array) ? values : [values]
-
-          # want to treat 'false' as an actual value
-          if value_ary.all? { |value| value.nil? || value == "" }
-            if options[:required]
-              raise ArgumentError.new("No value for required argument: #{name}")
-            else
-              return { name => nil }
-            end
-          end
-
-          if @allowed && value_ary.all? { |value| @allowed.any? { |allowed| value.is_a? allowed } }
-            return { name => values }
+          case
+          when allowed?(values)
+            { name => values }
+          else
+            _parse(name, values, options)
           end
-
-          unless @parser
-            raise ArgumentError.new("No parser for argument: #{name} with types: #{value_ary.map(&:class).join(', ')}")
-          end
-
-          _parse(name, values, options)
         end
 
+        # Define parser
         def parser(&block)
           @parser = block
         end
 
+        # Set allowed classes
         def allow(*args)
           @allowed = args
         end
+
+        # Set preparsers
+        def pre(*parsers)
+          @pre = parsers
+        end
+
+        # Get prepareer
+        def preparsers
+          @pre || []
+        end
+
+        # Check for allowed classes
+        def allowed?(values)
+          @allowed && Array.wrap(values).all? do |value|
+            @allowed.any? { |allowed| value.is_a? allowed }
+          end
+        end
       end
     end
   end

data/lib/decanter/version.rb

@@ -1,3 +1,3 @@
 module Decanter
-  VERSION = '0.7.2'
+  VERSION = '0.8.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: decanter
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.8.0
 platform: ruby
 authors:
 - Ryan Francis
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-04-26 00:00:00.000000000 Z
+date: 2016-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport