decanter 2.1.2 → 3.0.0

data/decanter.gemspec

@@ -0,0 +1,39 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'decanter/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'decanter'
+  spec.version       = Decanter::VERSION
+  spec.authors       = ['Ryan Francis', 'David Corwin']
+  spec.email         = ['ryan@launchpadlab.com']
+
+  spec.summary       = %q{Form Parser for Rails}
+  spec.description   = %q{Decanter aims to reduce complexity in Rails controllers by creating a place for transforming data before it hits the model and database.}
+  spec.homepage      = 'https://github.com/launchpadlab/decanter'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.'
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'actionpack', '>= 4.2.10'
+  spec.add_dependency 'activesupport'
+  spec.add_dependency 'rails-html-sanitizer', '>= 1.0.4'
+
+  spec.add_development_dependency 'bundler', '~> 1.9'
+  spec.add_development_dependency 'dotenv'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec-rails'
+  spec.add_development_dependency 'simplecov', '~> 0.15.1'
+end

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,9 +12,13 @@ module Decanter
         when Symbol
           klass_or_sym.to_s.singularize.camelize
         else
-          raise ArgumentError, "cannot lookup decanter for #{klass_or_sym} with class #{klass_or_sym.class}"
-        end + 'Decanter'
-      decanter_name.constantize
+          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
     end
 
     def decanter_from(klass_or_string)
@@ -23,20 +27,24 @@ module Decanter
         when Class
           klass_or_string
         when String
-          klass_or_string.constantize
+          begin
+            klass_or_string.constantize
+          rescue
+            raise NameError.new("uninitialized constant #{klass_or_string}")
+          end
         else
-          raise ArgumentError, "cannot find decanter from #{klass_or_string} with class #{klass_or_string.class}"
+          raise ArgumentError.new("cannot find decanter from #{klass_or_string} with class #{klass_or_string.class}")
         end
 
       unless constant.ancestors.include? Decanter::Base
-        raise ArgumentError, "#{constant.name} is not a decanter"
+        raise ArgumentError.new("#{constant.name} is not a decanter")
       end
 
       constant
     end
 
     def configuration
-      @configuration ||= Decanter::Configuration.new
+      @config ||= Decanter::Configuration.new
     end
 
     def config
@@ -54,4 +62,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,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'decanter/core'
 
 module Decanter

data/lib/decanter/configuration.rb

@@ -1,11 +1,10 @@
-# frozen_string_literal: true
-
 module Decanter
   class Configuration
+
     attr_accessor :strict
 
     def initialize
-      @strict = :with_exception
+      @strict = true
     end
   end
 end

data/lib/decanter/core.rb

@@ -1,196 +1,197 @@
-# frozen_string_literal: true
-
 module Decanter
   module Core
+    
     def self.included(base)
       base.extend(ClassMethods)
     end
 
     module ClassMethods
-      # Declare an ordinary parameter transformation.
-      def input(name, parsers = nil, **options)
-        options[:type] = :input
-        options[:parsers] = parsers
-        handler(name, options)
-      end
+      
+      def input(name, parsers=nil, **options)
 
-      # rubocop:disable Naming/PredicateName
+        _name = [name].flatten
 
-      # Declare a _has many_ association for a parameter.
-      def has_many(name, **options)
-        options[:type] = :has_many
-        options[:assoc] = name
-        handler(name, options)
-      end
+        if _name.length > 1 && parsers.blank?
+          raise ArgumentError.new("#{self.name} no parser specified for input with multiple values.")
+        end
 
-      # Declare a _has one_ association for a parameter.
-      def has_one(name, **options)
-        options[:type] = :has_one
-        options[:assoc] = name
-        handler(name, options)
+        handlers[_name] = {
+          key:     options.fetch(:key, _name.first),
+          name:    _name,
+          options: options,
+          parsers:  parsers,
+          type:    :input
+        }
       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
-
-        if handlers.key?(name)
-          raise ArgumentError, "Handler for #{name} already defined"
-        end
+      def has_many(assoc, **options)
+        handlers[assoc] = {
+          assoc:   assoc,
+          key:     options.fetch(:key, assoc),
+          name:    assoc,
+          options: options,
+          type:    :has_many
+        }
+      end
 
-        handlers[name] = {
-          key:     options.fetch(:key, Array(name).first),
-          assoc:   options.delete(:assoc),
-          type:    options.delete(:type),
+      def has_one(assoc, **options)
+        handlers[assoc] = {
+          assoc:   assoc,
+          key:     options.fetch(:key, assoc),
+          name:    assoc,
           options: options,
-          parsers: Array(parsers)
+          type:    :has_one
         }
       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, "#{name}: Unknown strict value #{mode}") unless [:with_exception, true, false].include? mode
+        raise(ArgumentError, "#{self.name}: Unknown strict value #{mode}") unless [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
 
-        if args.is_a?(ActionController::Parameters)
-          args.permit!
-          args = args.to_h
-        end
+      def handle_empty_args    
+        any_inputs_required? ? empty_args_error : {}
+      end
 
-        args = args.deep_symbolize_keys
-        handled_keys(args).merge(unhandled_keys(args))
+      def any_inputs_required?
+        required_inputs.any?
       end
 
       def required_inputs
-        handlers.map do |name, handler|
-          name if handler[:options][:required]
-        end
+        handlers.map do |h|
+          options = h.last[:options]
+          h.first.first if options && options[:required]
+        end  
       end
 
-      def required_input_keys_present?(args = {})
-        return true unless required_inputs.any?
+      def required_input_keys_present?(args={})
+        return true unless any_inputs_required?
         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(name = nil)
-        raise MissingRequiredInputValue, "No value found for required argument #{name}"
+      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')
       end
 
       # protected
 
       def unhandled_keys(args)
-        unhandled = args.keys
-        unhandled -= keys_to_ignore
-        unhandled -= handlers.keys.flatten
-
-        return {} unless unhandled.any?
+        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 }            
 
-        case strict_mode
-        when true
-          {}
-        when :with_exception
-          raise(UnhandledKeysError, "#{name} received unhandled keys: #{unhandled.join(', ')}.")
-        else
-          args.select { |key| unhandled.include? key }
-        end
+        return {} unless unhandled_keys.any?
+        raise(UnhandledKeysError, "#{self.name} received unhandled keys: #{unhandled_keys.join(', ')}.") if strict_mode
+        args.select { |key| unhandled_keys.include? key }
       end
 
       def handled_keys(args)
-        handlers.reduce({}) do |acc, curr|
-          name, handler = *curr
-          values = args.values_at(*name)
-          values = values.length == 1 ? values.first : values
-
-          is_empty_input = Array(values).all?(&:blank?)
-          if is_empty_input
-            empty_required_input_error(name) if handler[:options][:required]
-            # Skip handling empty inputs
-            next acc
-          end
+        arg_keys = args.keys.map(&:to_sym)
+        inputs, assocs = handlers.values.partition { |handler| handler[:type] == :input }
 
-          acc.merge handle(handler, values)
-        end
+        {}.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
 
-      def handle(handler, values)
-        decanter =  decanter_for_handler(handler) unless handler[:type] == :input
-
-        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
+      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
 
-        { handler[:key] => val }
+      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])
       end
 
-      def decanter_for_handler(handler)
-        if (specified_decanter = handler[:options][:decanter])
-          Decanter.decanter_from(specified_decanter)
+      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
+          })
+        ]
+
+        assoc_handler_names = assoc_handlers.map { |_handler| _handler[:name] }
+
+        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
-          Decanter.decanter_for(handler[:assoc])
+          raise ArgumentError.new("Handler #{handler[:name]} matches multiple keys: #{assoc_handler_names}.")
         end
       end
 
-      def handle_empty_args
-        required_inputs.any? ? empty_required_input_error : {}
+      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 }
+        else
+          {
+            handler[:key] => values.compact.map { |value| decanter.decant(value) }
+          }
+        end
       end
 
-      def parse(parsers, values, options)
-        return values if parsers.nil?
-
-        Parser.parsers_for(parsers).each do |parser|
-          unless values.is_a?(Hash)
-            values = parser.parse(values, options)
-            next
-          end
+      def handle_has_one(handler, values)
+        { handler[:key] => decanter_for_handler(handler).decant(values) }
+      end
 
-          # For hashes, we operate the parser on each member
-          values.each do |k, v|
-            values[k] = parser.parse(v, options)
-          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
 
-        values
+      def parse(key, parsers, value, options)
+        return { key => value } unless parsers
+        if options[:required] && value_missing?(value)
+          raise ArgumentError.new("No value for required argument: #{key}") 
+        end
+        parser_classes = Parser.parsers_for(parsers)
+        Parser.compose_parsers(parser_classes).parse(key, value, options)
       end
 
-      def handlers
+      def handlers        
         @handlers ||= {}
       end
 
@@ -201,6 +202,15 @@ module Decanter
       def strict_mode
         @strict_mode.nil? ? Decanter.configuration.strict : @strict_mode
       end
+
+      # Helpers
+
+      private
+
+      def value_missing?(value)
+        value.nil? || value == ""
+      end
+
     end
   end
 end