decanter 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 20aabb357aad0ae6ac3571bdc051640eee091e0a
-  data.tar.gz: 7e1015a86d9e56d0f647bd2c561b40795b471a2d
+  metadata.gz: a1cea76ec8e01a183736aeb145f1b58cb8f00298
+  data.tar.gz: 370986b00b379fc188bc327a76e4411038f0c4b9
 SHA512:
-  metadata.gz: ee971b831f97166213985551f11c36f22f6b4eddb89acb8e1559ab0344172ac08a7ddb88cc10ead3a744add6d950d0d127e79ee3129e2e0e4984b62529f53cdb
-  data.tar.gz: 394c5b2fe99e781fc393b1b27580269a202189261044d57b30a370e1ef2cc2d06c298238726d0a09f2988ca39d29b8649403a4dec3658f811e3e15890a8c7d1e
+  metadata.gz: 0e17c3aba3e202f20638f80993d73f9a7773b6890eb46006c470a972a8f7cf7a0ce87fd07713097a40fa48482430dfc3b897a9126e14f0c49297ca1e49fa941a
+  data.tar.gz: af705b120764f79bff09350351830f8908b2fcb73cd74463bde2bd66dc898c63673c30fd361ff71fbbe528d512bace6d2eef4d08d6ee954f60780807ce381507

data/.codeclimate.yml

@@ -25,7 +25,7 @@ engines:
   csslint:
     enabled: true
   brakeman:
-    enabled: true
+    enabled: false
   bundler-audit:
     enabled: true
 ratings:

data/Gemfile.lock

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

data/README.md

@@ -1,7 +1,7 @@
 Decanter
 ===
 
-[![Code Climate](https://codeclimate.com/github/LaunchPadLab/decanter/badges/gpa.svg)](https://codeclimate.com/github/LaunchPadLab/decanter) [![Test Coverage](https://codeclimate.com/github/LaunchPadLab/decanter/badges/coverage.svg)](https://codeclimate.com/github/LaunchPadLab/decanter/coverage)
+[![Code Climate](https://codeclimate.com/github/LaunchPadLab/decanter/badges/gpa.svg?ignore=me)](https://codeclimate.com/github/LaunchPadLab/decanter) [![Test Coverage](https://codeclimate.com/github/LaunchPadLab/decanter/badges/coverage.svg?ignore=me)](https://codeclimate.com/github/LaunchPadLab/decanter/coverage)
 ---
 
 

data/lib/decanter.rb

@@ -2,18 +2,36 @@ require 'active_support/all'
 
 module Decanter
 
-  @@decanters = {}
+  class << self
 
-  def self.register(decanter)
-    @@decanters[decanter.name.demodulize] = decanter
-  end
+    def decanter_for(klass_or_sym)
+      case klass_or_sym
+      when Class
+        klass_or_sym.name
+      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').constantize
+    end
+
+    def decanter_from(klass_or_string)
+      constant =
+        case klass_or_string
+        when Class
+          klass_or_string
+        when String
+          klass_or_string.constantize
+        else
+          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.new("#{constant.name} is not a decanter")
+      end
 
-  def self.decanter_for(klass_or_sym)
-    name = klass_or_sym.is_a?(Class) ?
-            klass_or_sym.name :
-            klass_or_sym.to_s.singularize.camelize
-    full_name = name.include?('Decanter') ? name : "#{name}Decanter"
-    @@decanters[full_name] || (raise NameError.new("unknown decanter #{name}Decanter"))
+      constant
+    end
   end
 
   ActiveSupport.run_load_hooks(:decanter, self)

data/lib/decanter/base.rb

@@ -3,8 +3,5 @@ require 'decanter/core'
 module Decanter
   class Base
     include Core
-    def self.inherited(subclass)
-      Decanter.register(subclass)
-    end
   end
 end

data/lib/decanter/core.rb

@@ -25,22 +25,20 @@ module Decanter
       end
 
       def has_many(assoc, **options)
-        name = ["#{assoc}_attributes".to_sym]
-        handlers[name] = {
+        handlers[assoc] = {
           assoc:   assoc,
-          key:     options.fetch(:key, name.first),
-          name:    name,
+          key:     options.fetch(:key, assoc),
+          name:    assoc,
           options: options,
           type:    :has_many
         }
       end
 
       def has_one(assoc, **options)
-        name = ["#{assoc}_attributes".to_sym]
-        handlers[name] = {
+        handlers[assoc] = {
           assoc:   assoc,
-          key:     options.fetch(:key, name.first),
-          name:    name,
+          key:     options.fetch(:key, assoc),
+          name:    assoc,
           options: options,
           type:    :has_one
         }
@@ -59,80 +57,118 @@ module Decanter
 
       # protected
 
-        def unhandled_keys(args)
-          unhandled_keys = args.keys.map(&:to_sym) - handlers.keys.flatten.uniq
-
-          if unhandled_keys.any?
-            case strict_mode
-            when true
-              p "#{self.name} ignoring unhandled keys: #{unhandled_keys.join(', ')}."
-              {}
-            when :with_exception
-              raise ArgumentError.new("#{self.name} received unhandled keys: #{unhandled_keys.join(', ')}.")
-            else
-              args.select { |key| unhandled_keys.include? key }
-            end
-          else
+      def unhandled_keys(args)
+        unhandled_keys = args.keys.map(&:to_sym) -
+          handlers.keys.flatten.uniq -
+          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 ArgumentError.new("#{self.name} received unhandled keys: #{unhandled_keys.join(', ')}.")
+          else
+            args.select { |key| unhandled_keys.include? key }
           end
+        else
+          {}
         end
+      end
 
-        def handled_keys(args)
-          handlers.values
-                  .select     { |handler| (args.keys.map(&:to_sym) & handler[:name]).any? }
-                  .reduce({}) { |memo, handler| memo.merge handle(handler, args) }
-        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
 
-        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
+      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
+
+      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])
+      end
 
-        def handle_input(handler, values)
-           parse(handler[:key], handler[:parser], values, handler[:options])
+      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
+          raise ArgumentError.new("Handler #{handler[:name]} matches multiple keys: #{assoc_handler_names}.")
         end
+      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 }
-          else
-            {
-              handler[:key] => values.compact.map { |value| decanter.decant(value) }
-            }
+      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 handle_has_one(handler, values)
-            {
-              handler[:key] => decanter_for_handler(handler).decant(values)
-            }
-        end
+      def handle_has_one(handler, values)
+        { handler[:key] => decanter_for_handler(handler).decant(values) }
+      end
 
-        def decanter_for_handler(handler)
-          Decanter::decanter_for(handler[:options][:decanter] || handler[:assoc])
+      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(key, parser, values, options)
-          parser ?
-            ValueParser.value_parser_for(parser)
-                       .parse(key, values, options)
-            :
-            { key => values }
-        end
+      def parse(key, parser, values, options)
+        parser ?
+          ValueParser.value_parser_for(parser)
+                     .parse(key, values, options)
+          :
+          { key => values }
+      end
 
-        def handlers
-          @handlers ||= {}
-        end
+      def handlers
+        @handlers ||= {}
+      end
 
-        def strict_mode
-          @strict_mode ||= {}
-        end
+      def strict_mode
+        @strict_mode ||= {}
+      end
     end
   end
 end

data/lib/decanter/extensions.rb

@@ -36,8 +36,11 @@ module Decanter
       end
 
       def decant(args, options={})
-        options.fetch(:decanter, Decanter.decanter_for(self))
-          .decant(args)
+        if specified_decanter = options[:decanter]
+          Decanter.decanter_from(specified_decanter)
+        else
+          Decanter.decanter_for(self)
+        end.decant(args)
       end
     end
 

data/lib/decanter/railtie.rb

@@ -11,7 +11,6 @@ class Decanter::Railtie < Rails::Railtie
 
   config.to_prepare do
     Dir[
-      File.expand_path(Rails.root.join("app/decanters/*")),
       File.expand_path(Rails.root.join("lib/decanter/parsers/*"))
     ].each { |file| require file }
   end

data/lib/decanter/version.rb

@@ -1,3 +1,3 @@
 module Decanter
-  VERSION = '0.7.0'
+  VERSION = '0.7.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: decanter
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Ryan Francis
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-02-26 00:00:00.000000000 Z
+date: 2016-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport