decanter 1.1.10 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90171d776162cd88c420fa49fe3110e6abfb2526814f797758eba3657d09264a
-  data.tar.gz: 57fa05b9c2d917b8082d70085c873f91619fa4a9b6142a88d0d715dd5fbbef61
+  metadata.gz: 881a76a5958f93883b6fe71571d149e0cd477a449484bc4d61df9fa7d49b7be0
+  data.tar.gz: d3cb5f4ac6eb4a1d576904112ba85721164ed987ef7285d9ab7258c0a85062cc
 SHA512:
-  metadata.gz: 5a6f20987ae62f6a580ede57dc29e7bc70d96e352e796f065a394cbcb754683fdf472a80ef2e529606278935f4ee5162d91d9009034202d098384fcea0ad8342
-  data.tar.gz: 3db467af7278eef616121b81b66dc09fa3d0780b62a53ed383cedca78fe5be9d83283b097fc63ace2ac7715459dd0c406ae81d2370151c82fa14e325e05bffab
+  metadata.gz: 430b80997c899726116d97b067d8c42f30efffb44c160b7e91238ad714b6bbc6b15527ee372637be5eb41c77c44ef87fec943b460bb80a61cfc88eecf38899c1
+  data.tar.gz: 5ce3bea3ce908809a6a233fa1d903128e37e039f7022969590cc9f6868f6ce6d3218aaa00618a8bd9b67acd53b722c679d5b0e665d6da593e8c3652f750737dc

data/bin/console

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require "bundler/setup"
-require "decanter"
+require 'bundler/setup'
+require 'decanter'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
@@ -10,5 +11,5 @@ require "decanter"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start

data/lib/decanter.rb

@@ -1,9 +1,9 @@
+# frozen_string_literal: true
+
 require 'active_support/all'
 
 module Decanter
-
   class << self
-
     def decanter_for(klass_or_sym)
       decanter_name =
         case klass_or_sym
@@ -12,13 +12,9 @@ module Decanter
         when Symbol
           klass_or_sym.to_s.singularize.camelize
         else
-          raise ArgumentError.new("cannot lookup decanter for #{klass_or_sym} with class #{klass_or_sym.class}")
-        end.concat('Decanter')
-      begin
-        decanter_name.constantize
-      rescue
-        raise NameError.new("uninitialized constant #{decanter_name}")
-      end
+          raise ArgumentError, "cannot lookup decanter for #{klass_or_sym} with class #{klass_or_sym.class}"
+        end + 'Decanter'
+      decanter_name.constantize
     end
 
     def decanter_from(klass_or_string)
@@ -27,24 +23,20 @@ module Decanter
         when Class
           klass_or_string
         when String
-          begin
-            klass_or_string.constantize
-          rescue
-            raise NameError.new("uninitialized constant #{klass_or_string}")
-          end
+          klass_or_string.constantize
         else
-          raise ArgumentError.new("cannot find decanter from #{klass_or_string} with class #{klass_or_string.class}")
+          raise ArgumentError, "cannot find decanter from #{klass_or_string} with class #{klass_or_string.class}"
         end
 
       unless constant.ancestors.include? Decanter::Base
-        raise ArgumentError.new("#{constant.name} is not a decanter")
+        raise ArgumentError, "#{constant.name} is not a decanter"
       end
 
       constant
     end
 
     def configuration
-      @config ||= Decanter::Configuration.new
+      @configuration ||= Decanter::Configuration.new
     end
 
     def config
@@ -62,4 +54,4 @@ require 'decanter/base'
 require 'decanter/extensions'
 require 'decanter/exceptions'
 require 'decanter/parser'
-require 'decanter/railtie' if defined?(::Rails)
+require 'decanter/railtie' if defined?(::Rails)

data/lib/decanter/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'decanter/core'
 
 module Decanter

data/lib/decanter/configuration.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module Decanter
   class Configuration
-
     attr_accessor :strict
 
     def initialize

data/lib/decanter/core.rb

@@ -1,212 +1,193 @@
+# frozen_string_literal: true
+
 module Decanter
   module Core
-    
     def self.included(base)
       base.extend(ClassMethods)
     end
 
     module ClassMethods
-      
-      def input(name, parsers=nil, **options)
-
-        _name = [name].flatten
+      # Declare an ordinary parameter transformation.
+      def input(name, parsers = nil, **options)
+        options[:type] = :input
+        options[:parsers] = parsers
+        handler(name, options)
+      end
 
-        if _name.length > 1 && parsers.blank?
-          raise ArgumentError.new("#{self.name} no parser specified for input with multiple values.")
-        end
+      # rubocop:disable Naming/PredicateName
 
-        handlers[_name] = {
-          key:     options.fetch(:key, _name.first),
-          name:    _name,
-          options: options,
-          parsers:  parsers,
-          type:    :input
-        }
+      # Declare a _has many_ association for a parameter.
+      def has_many(name, **options)
+        options[:type] = :has_many
+        options[:assoc] = name
+        handler(name, options)
       end
 
-      def has_many(assoc, **options)
-        handlers[assoc] = {
-          assoc:   assoc,
-          key:     options.fetch(:key, assoc),
-          name:    assoc,
-          options: options,
-          type:    :has_many
-        }
+      # Declare a _has one_ association for a parameter.
+      def has_one(name, **options)
+        options[:type] = :has_one
+        options[:assoc] = name
+        handler(name, options)
       end
+      # rubocop:enable Naming/PredicateName
+
+      # Add a parameter handler to the class.  Takes a name, and a set of
+      # options.  This is a generic method for any sort of handler, e.g.
+      #
+      # handle :foo, type: :input, parsers: [:string], as: :bar
+      def handler(name, options)
+        name = options.fetch(:as, name)
+        parsers = options.delete(:parsers)
+
+        if Array(name).length > 1 && parsers.blank?
+          raise ArgumentError,
+                "#{name} no parser specified for input with multiple values."
+        end
 
-      def has_one(assoc, **options)
-        handlers[assoc] = {
-          assoc:   assoc,
-          key:     options.fetch(:key, assoc),
-          name:    assoc,
+        if handlers.key?(name)
+          raise ArgumentError, "Handler for #{name} already defined"
+        end
+
+        handlers[name] = {
+          key:     options.fetch(:key, Array(name).first),
+          assoc:   options.delete(:assoc),
+          type:    options.delete(:type),
           options: options,
-          type:    :has_one
+          parsers: Array(parsers)
         }
       end
 
+      # List of parameters to ignore.
       def ignore(*args)
         keys_to_ignore.push(*args)
       end
 
+      # Set a level of strictness when dealing with parameters that are present
+      # but not expected.
+      #
+      # with_exception:  Raise an exception
+      # true:            Delete the parameter
+      # false:           Allow the parameter through
+      #
       def strict(mode)
-        raise(ArgumentError, "#{self.name}: Unknown strict value #{mode}") unless [:with_exception, true, false].include? mode
+        raise(ArgumentError, "#{name}: Unknown strict value #{mode}") unless [:with_exception, true, false].include? mode
         @strict_mode = mode
       end
 
+      # Take a parameter hash, and handle it with the various decanters
+      # defined.
       def decant(args)
         return handle_empty_args if args.blank?
         return empty_required_input_error unless required_input_keys_present?(args)
-        args = args.to_unsafe_h.with_indifferent_access if args.class.name == 'ActionController::Parameters'
-        {}.merge( unhandled_keys(args) )
-          .merge( handled_keys(args) )
-      end
 
-      def handle_empty_args    
-        any_inputs_required? ? empty_args_error : {}
-      end
+        if args.is_a?(ActionController::Parameters)
+          args.permit!
+          args = args.to_h
+        end
 
-      def any_inputs_required?
-        required_inputs.any?
+        args = args.deep_symbolize_keys
+        handled_keys(args).merge(unhandled_keys(args))
       end
 
       def required_inputs
-        handlers.map do |h|
-          options = h.last[:options]
-          h.first.first if options && options[:required]
-        end  
+        handlers.map do |name, handler|
+          name if handler[:options][:required]
+        end
       end
 
-      def required_input_keys_present?(args={})
-        return true unless any_inputs_required?
+      def required_input_keys_present?(args = {})
+        return true unless required_inputs.any?
         compact_inputs = required_inputs.compact
         compact_inputs.all? do |input|
           args.keys.map(&:to_sym).include?(input) && !args[input].nil?
         end
       end
 
-      def empty_required_input_error
-        raise(MissingRequiredInputValue, 'Required inputs have been declared, but no values for those inputs were passed.')
-      end
-
-      def empty_args_error
-        raise(ArgumentError, 'Decanter has required inputs but no values were passed')
+      def empty_required_input_error(name = nil)
+        raise MissingRequiredInputValue, "No value found for required argument #{name}"
       end
 
       # protected
 
       def unhandled_keys(args)
-        unhandled_keys = args.keys.map(&:to_sym) -
-          handlers.keys.flatten.uniq -
-          keys_to_ignore -
-          handlers.values
-            .select { |handler| handler[:type] != :input }
-            .map { |handler| "#{handler[:name]}_attributes".to_sym }            
-
-        if unhandled_keys.any?
-          case strict_mode
-          when true
-            p "#{self.name} ignoring unhandled keys: #{unhandled_keys.join(', ')}."
-            {}
-          when :with_exception            
-            raise(UnhandledKeysError, "#{self.name} received unhandled keys: #{unhandled_keys.join(', ')}.")
-          else
-            args.select { |key| unhandled_keys.include? key }
-          end
-        else
+        unhandled = args.keys
+        unhandled -= keys_to_ignore
+        unhandled -= handlers.keys.flatten
+
+        return {} unless unhandled.any?
+
+        case strict_mode
+        when true
           {}
+        when :with_exception
+          raise(UnhandledKeysError, "#{name} received unhandled keys: #{unhandled.join(', ')}.")
+        else
+          args.select { |key| unhandled.include? key }
         end
       end
 
       def handled_keys(args)
-        arg_keys = args.keys.map(&:to_sym)
-        inputs, assocs = handlers.values.partition { |handler| handler[:type] == :input }
-
-        {}.merge(
-          # Inputs
-          inputs.select     { |handler| (arg_keys & handler[:name]).any? }
-                .reduce({}) { |memo, handler| memo.merge handle_input(handler, args) }
-        ).merge(
-          # Associations
-          assocs.reduce({}) { |memo, handler| memo.merge handle_association(handler, args) }
-        )
-      end
+        handlers.reduce({}) do |m, h|
+          name, handler = *h
+          values = args.values_at(*name)
+          values = values.length == 1 ? values.first : values
 
-      def handle(handler, args)
-        values = args.values_at(*handler[:name])
-        values = values.length == 1 ? values.first : values
-        self.send("handle_#{handler[:type]}", handler, values)
-      end
+          if handler[:options][:required] && Array(values).all?(&:blank?)
+            empty_required_input_error(name)
+          end
 
-      def handle_input(handler, args)
-         values = args.values_at(*handler[:name])
-         values = values.length == 1 ? values.first : values
-         parse(handler[:key], handler[:parsers], values, handler[:options])
+          m.merge handle(handler, values)
+        end
       end
 
-      def handle_association(handler, args)
-        assoc_handlers = [
-          handler,
-          handler.merge({
-            key:   handler[:options].fetch(:key, "#{handler[:name]}_attributes").to_sym,
-            name:  "#{handler[:name]}_attributes".to_sym
-          })
-        ]
+      def handle(handler, values)
+        decanter =  decanter_for_handler(handler) unless handler[:type] == :input
 
-        assoc_handler_names = assoc_handlers.map { |_handler| _handler[:name] }
+        val = case handler[:type]
+              when :input
+                parse(handler[:parsers], values, handler[:options])
+              when :has_one
+                decanter.decant(values)
+              when :has_many
+                # should sort here, really.
+                values = values.values if values.is_a?(Hash)
+                values.compact.map { |v| decanter.decant(v) }
+              end
 
-        case args.values_at(*assoc_handler_names).compact.length
-        when 0
-          {}
-        when 1
-          _handler = assoc_handlers.detect { |_handler| args.has_key?(_handler[:name]) }
-          self.send("handle_#{_handler[:type]}", _handler, args[_handler[:name]])
-        else
-          raise ArgumentError.new("Handler #{handler[:name]} matches multiple keys: #{assoc_handler_names}.")
-        end
+        { handler[:key] => val }
       end
 
-      def handle_has_many(handler, values)
-        decanter = decanter_for_handler(handler)
-        if values.is_a?(Hash)
-          parsed_values = values.map do |index, input_values|
-            next if input_values.nil?
-            decanter.decant(input_values)
-          end
-          return { handler[:key] => parsed_values }
+      def decanter_for_handler(handler)
+        if (specified_decanter = handler[:options][:decanter])
+          Decanter.decanter_from(specified_decanter)
         else
-          {
-            handler[:key] => values.compact.map { |value| decanter.decant(value) }
-          }
+          Decanter.decanter_for(handler[:assoc])
         end
       end
 
-      def handle_has_one(handler, values)
-        { handler[:key] => decanter_for_handler(handler).decant(values) }
+      def handle_empty_args
+        required_inputs.any? ? empty_required_input_error : {}
       end
 
-      def decanter_for_handler(handler)
-        if specified_decanter = handler[:options][:decanter]
-          Decanter::decanter_from(specified_decanter)
-        else
-          Decanter::decanter_for(handler[:assoc])
-        end
-      end
+      def parse(parsers, values, options)
+        return values if parsers.nil?
 
-      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
+        Parser.parsers_for(parsers).each do |parser|
+          unless values.is_a?(Hash)
+            values = parser.parse(values, options)
+            next
+          end
+
+          # For hashes, we operate the parser on each member
+          values.each do |k, v|
+            values[k] = parser.parse(v, options)
+          end
         end
+
+        values
       end
 
-      def handlers        
+      def handlers
         @handlers ||= {}
       end
 

data/lib/decanter/decant.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Decanter
+  module Decant
+    extend ActiveSupport::Concern
+
+    def decant(decanter, params)
+      Decanter.decanter_for(decanter).decant(params)
+    end
+  end
+end