deserializer 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3e444e500d391065ce2aed5b2b41cb605fa443df
-  data.tar.gz: ba9db864ddb2d65dce89ddcb494939eda0d05428
+  metadata.gz: 8e98ac2dd5ac22cf71de5fe17aec446999b93dec
+  data.tar.gz: 423a1b3fcc3b5a8497c9aa14de5d570c969085ef
 SHA512:
-  metadata.gz: c84a34731a8b4e26b93b8ac96116bf39116a9617676330b32465e1ff8ab743491a33c54d8eb321cad436d5ab8a1fc6954be981405066e9b48d62459cb6d47911
-  data.tar.gz: 302c940e2185dfc3eaf5471cf9ea34ca276a5b8a5327f7d94a216d55dc27e4a527ec39a2b35a832885ea6c7d826d286d7725d4e06f0957ebe1bae08e20c5932c
+  metadata.gz: a617f0e4c52e8397fd287f0d776db9ffbf57f094ab029747eb499a2062a8ebbbc92288fc4a01aba316d2fb86eb477af298afc4d361cf49f055641f7dd666208f
+  data.tar.gz: b24342df65559de3e0fa3b8f7dc9d48974e3403d560e6da805d18d88873e2b9ead8aeb17c8ffe34d44490960ce7ac9a3249a58889e0f619886b233d197b904c6

data/Gemfile.lock

@@ -1,13 +1,13 @@
 PATH
   remote: .
   specs:
-    deserializer (0.3.0)
+    deserializer (0.5.0)
       activesupport
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (4.2.5)
+    activesupport (4.2.4)
       i18n (~> 0.7)
       json (~> 1.7, >= 1.7.7)
       minitest (~> 5.1)
@@ -16,6 +16,10 @@ GEM
     docile (1.1.5)
     i18n (0.7.0)
     json (1.8.3)
+    m (1.3.4)
+      method_source (>= 0.6.7)
+      rake (>= 0.9.2.2)
+    method_source (0.8.2)
     minitest (5.7.0)
     multi_json (1.11.1)
     rake (10.4.2)
@@ -34,6 +38,10 @@ PLATFORMS
 DEPENDENCIES
   bundler (~> 1.6)
   deserializer!
+  m (~> 1.3.1)
   minitest
   rake
   simplecov
+
+BUNDLED WITH
+   1.11.2

data/README.md

@@ -29,8 +29,7 @@ But this goes into a flat DishReview model:
 ```ruby
 t.belongs_to  :restaurant
 t.belongs_to  :user
-# field name different from API
-t.string      :name
+t.string      :name # field name different from API (dish_name)
 t.string      :description
 t.string      :taste
 t.string      :color
@@ -46,7 +45,7 @@ class DishReviewController < BaseController
 
   def create
     review_params = get_review_params(params)
-    @review = ProfessionalReview.new(review_params)
+    @review = DishReview.new(review_params)
     if @review.save
       # return review
     else
@@ -85,10 +84,7 @@ class DishReviewController < BaseController
   end
 
   def valid_rating?(rating)
-    @@ratings ||= ["overall", "trusthworthy", "responsive", "knowledgeable", "communication"]
-
-    @@ratings.include? rating
-
+    ["taste", "color", "texture", "smell"].include? rating
   end
 end
 ```
@@ -397,7 +393,107 @@ Given params:
 ```
 
 ### has_many
-Not supported as it's an odd thing for a write endpoint to support, but can easily be added.
+`has_many` association expects a param and its deserializer:
+
+```ruby
+class DishDeserializer < Deserializer::Base
+  # probably other stuff
+  has_many :ratings, deserializer: RatingsDeserializer
+end
+
+class RatingsDeserializer < Deserializer::Base
+  attributes  :user_id,
+              :rating,
+              :comment
+end
+```
+
+```ruby
+# Example params
+{
+  "ratings" => [
+    { "user_id" => 6,
+      "rating" => 3,
+      "comment" => "not bad"
+    },
+    { "user_id" => 25,
+      "rating" => 2,
+      "comment" => "gross"
+    }
+  ]
+}
+# Resulting hash
+  {
+    ratings: [
+      { user_id: 6,
+        rating: 3,
+        comment: "not bad"
+      },
+      { user_id: 25,
+        rating: 2,
+        comment: "gross"
+      }
+    ]
+  }
+```
+
+#### key
+
+You can deserialize a `has_many` association into a different key from what the json gives you. For example:
+```json
+{
+  id: 6,
+  name: "mac & cheese",
+  aliases: [
+    {
+      id: 83,
+      name: "macaroni and cheese"
+    },
+    {
+      id: 86,
+      name: "cheesy pasta"
+    }
+  ]
+}
+```
+
+but your model is
+
+```ruby
+class Dish
+  has_many :aliases
+  accepted_nested_attributes_for :aliases
+end
+```
+instead of renaming the hash in the controller, you can do
+
+```ruby
+class DishDeserializer < Deserializer::Base
+  attributes  :id,
+              :name
+
+  has_many :aliases_attributes, deserializer: AliasDeserializer, key: :aliases
+end
+```
+
+which would output
+
+```ruby
+{
+  id: 6,
+  name: "mac & cheese",
+  aliases_attributes: [
+    {
+      id: 83,
+      name: "macaroni and cheese"
+    },
+    {
+      id: 86,
+      name: "cheesy pasta"
+    }
+  ]
+}
+```
 
 ### nests
 Sometimes you get a flat param list, but want it to be nested for `updated_nested_attributes`

data/deserializer.gemspec

@@ -22,4 +22,5 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency "bundler", "~> 1.6"
   s.add_development_dependency "rake"
+  s.add_development_dependency "m", "~> 1.3.1"
 end

data/lib/deserializer.rb

@@ -3,7 +3,8 @@ require 'active_support'
 require 'active_support/concern'
 
 module Deserializer
-  autoload :Associatable, 		'deserializer/associatable'
+  autoload :Attribute,          'deserializer/attribute'
+  autoload :Attributable,       'deserializer/attributable'
   autoload :Base,               'deserializer/base'
   autoload :DeserializerError,  'deserializer/deserializer_error'
 end

data/lib/deserializer/attributable.rb

@@ -0,0 +1,54 @@
+module Deserializer
+  module Attributable
+    extend ActiveSupport::Concern
+
+    included do
+      class << self
+        # deserializer interface functions
+
+        def attributes( *attrs )
+          self.__attrs ||= []
+          attrs.each do |attr|
+            __attrs << Attribute::Attribute.new( Attribute::ValueAttribute, attr, {} )
+          end
+        end
+
+        def attribute( name, opts = {} )
+          self.__attrs ||= []
+          __attrs << Attribute::Attribute.new( Attribute::ValueAttribute, name, opts )
+        end
+
+        def has_one( name, opts = {} )
+          unless opts[:deserializer]
+            raise DeserializerError, class: self, message: "has_one associations need a deserilaizer" 
+          end
+
+          self.__attrs ||= []
+          __attrs << Attribute::Attribute.new( Attribute::HasOneAssociation, name, opts )
+        end
+
+        def has_many( name, opts = {} )
+          unless opts[:deserializer]
+            raise DeserializerError, class: self, message: "has_many associations need a deserilaizer" 
+          end
+
+          self.__attrs ||= []
+          __attrs << Attribute::Attribute.new( Attribute::HasManyAssociation, name, opts )
+        end
+
+        def belongs_to( *args )
+          raise DeserializerError, class: self, message: "belongs_to is unsupported."
+        end
+
+        def nests( name, opts = {} )
+          unless opts[:deserializer]
+            raise DeserializerError, class: self, message: "nested associations need a deserilaizer" 
+          end
+
+          self.__attrs ||= []
+          __attrs << Attribute::Attribute.new( Attribute::NestedAssociation, name, opts )
+        end
+      end
+    end
+  end
+end

data/lib/deserializer/attribute.rb

@@ -0,0 +1,11 @@
+module Deserializer
+  module Attribute
+    autoload :Base,               "deserializer/attribute/base"
+    autoload :Association,        "deserializer/attribute/association"
+    autoload :Attribute,          "deserializer/attribute/attribute"
+    autoload :HasManyAssociation, "deserializer/attribute/has_many_association"
+    autoload :HasOneAssociation,  "deserializer/attribute/has_one_association"
+    autoload :NestedAssociation,  "deserializer/attribute/nested_association"
+    autoload :ValueAttribute,     "deserializer/attribute/value_attribute"
+  end
+end

data/lib/deserializer/attribute/association.rb

@@ -0,0 +1,12 @@
+module Deserializer
+  module Attribute
+    class Association < Base
+    
+      private
+
+      def deserializer
+        opts[:deserializer]
+      end
+    end
+  end
+end

data/lib/deserializer/attribute/attribute.rb

@@ -0,0 +1,20 @@
+module Deserializer
+  module Attribute
+    class Attribute
+      def initialize( type, name, opts )
+        @type = type
+        @name = name
+        @opts = opts
+      end
+
+      def key
+        @opts.fetch :key, @name
+      end
+
+      def to_hash( params, object )
+        attribute = @type.new( @name, @opts, object )
+        attribute.to_hash( params )
+      end
+    end
+  end
+end

data/lib/deserializer/attribute/base.rb

@@ -0,0 +1,49 @@
+module Deserializer
+  module Attribute
+    class Base
+
+      attr_reader :name
+
+      def initialize( name, opts = {}, object )
+        self.name   = name
+        self.opts   = opts
+        self.object = object
+      end
+
+      # simple object
+      # { key => value }
+
+      # has_* object
+      # { key => { deserialized obejct }}
+
+      # has_one :whatever; where def wahtever{ object }
+      # { object } 
+      def to_hash( params )
+        return {} unless params.has_key? key
+        tuple( params )
+      end
+
+      private
+
+      attr_accessor :opts, :value, :object
+      attr_writer :name
+
+      def key
+        @key ||= opts.fetch :key, name
+      end
+
+      def tuple( params = {} )
+        value = value( params )
+        if value == :ignore
+          {}
+        else
+          { name => value }
+        end
+      end
+
+      def value( params = {} )
+        return "not implemented"
+      end
+    end
+  end
+end

data/lib/deserializer/attribute/has_many_association.rb

@@ -0,0 +1,14 @@
+module Deserializer
+  module Attribute
+    class HasManyAssociation < Association
+
+      def value( params )
+        target = []
+        params[key].each do |association_datum|
+          target << deserializer.from_params( association_datum )
+        end
+        target
+      end
+    end
+  end
+end

data/lib/deserializer/attribute/has_one_association.rb

@@ -0,0 +1,44 @@
+module Deserializer
+  module Attribute
+    class HasOneAssociation < Association
+
+      def to_hash( params )
+        return {} unless params[name]
+        value = deserializer.from_params( params[key] )
+   
+        if object.respond_to? name
+          
+          target = object.send( name )
+          
+          # has_one :thing, deserializer: ThingDeserializer
+          #
+          # def thing
+          #   object
+          # end
+          if target == object.object
+            return value
+
+          # has_one :thing, deserializer: ThingDeserializer
+          # has_one :gniht, deserializer: GnihtDeserializer
+          #
+          # def thing
+          #   object[:gniht]
+          # end
+          elsif target.is_a? Hash
+            return target.merge value
+
+          # has_one :thing, deserializer: GnihtDeserializer
+          #
+          # def thing
+          #   :some_other_key
+          # end
+          else
+            return { target => value }
+          end
+        else
+          return { key => value }
+        end
+      end
+    end
+  end
+end

data/lib/deserializer/attribute/nested_association.rb

@@ -0,0 +1,10 @@
+module Deserializer
+  module Attribute
+    class NestedAssociation < Association
+
+      def to_hash( params )
+        { name => deserializer.from_params( params ) }
+      end
+    end
+  end
+end

data/lib/deserializer/attribute/value_attribute.rb

@@ -0,0 +1,33 @@
+module Deserializer
+  module Attribute
+    class ValueAttribute < Base
+
+      def value( params )
+        value = params[key]
+
+        if opts[:ignore_empty] && empty?(value)
+          return :ignore
+        end
+        
+        if opts[:convert_with]
+          method = opts[:convert_with]
+          if object.respond_to? method
+            return object.send method, value
+          end
+        end
+        # other options go here
+        
+        value
+      end
+
+      private
+
+      def empty?(value)
+        !value ||
+        value == "" ||
+        value == {} ||
+        value == []
+      end
+    end
+  end
+end

data/lib/deserializer/base.rb

@@ -1,61 +1,40 @@
 module Deserializer
   class Base
 
-    ## has_one, nested, etc associations
-    include Deserializer::Associatable
+    ## atribute, has_one, nested, etc associations
+    include Deserializer::Attributable
 
     class << self
-      attr_accessor :attrs, :nested_attrs
-    
-      # deserializer interface functions
-
-      def attributes(*attrs)
-        self.attrs ||= {}
-        attrs.each do |attr|
-          self.attrs[attr] = {attr: attr, options: {}}
-        end
-      end
-
-      def attribute(attr, options = {})
-        self.attrs ||= {}
-        key = options.fetch(:key, attr)
-        self.attrs[key] = {attr: attr, options: options}
-      end
+      attr_accessor :__attrs
 
       # deserializer usage functions
 
       def from_params( params = {} )
-        self.new({}, params).deserialize
+        self.new( params ).deserialize
       end
 
       def permitted_params
-        self.attrs.keys
+        self.__attrs.map(&:key)
       end
-
     end
 
     attr_reader     :object
 
     def deserialize
-      self.class.attrs.each do |param_key, object_key|
-        # don't bother with keys that aren't in params
-        next unless params.has_key? param_key
 
-        # this checks if the object_key is a class that inherits from Deserializer
-        if object_key[:deserializer]
-          deseralize_association(param_key, object_key[:deserializer])
-        else
-          attribute = object_key[:attr]
-          options   = object_key[:options]
-
-          assign_value attribute, params[param_key], options
+      object ||= {}
+
+      # deserialize
+      self.class.__attrs.each do |attr|
+        object.merge!( attr.to_hash( params, self ) ) do |key, old_value, new_value|
+          # in the case that 2 has_ones merge into the same key. Not sure i want to support this
+          if old_value.is_a?( Hash ) && new_value.is_a?( Hash )
+            old_value.merge new_value
+          else
+            new_value
+          end
         end
       end
-
-      self.class.nested_attrs ||= {}
-      self.class.nested_attrs.each do |target, options|
-        deserialize_nested target, options[:deserializer]
-      end
       object
     end
 
@@ -64,67 +43,13 @@ module Deserializer
     attr_accessor   :params
     attr_writer     :object
 
-    def initialize( object = {}, params = {})
+    def initialize( params = {})
       unless params
         raise DeserializerError, class: self.class, message: "params cannot be nil"
       end
 
       self.params = params
-      self.object = object
-    end
-
-    def deseralize_association(association, deserializer)
-      # check for method defining the target object (something, in the example below)
-      #
-      # class ExampleDeserializer < Deserializer::Base
-      #   has_one :something, deserializer: SomethingDeserializer
-      #   
-      #   def something
-      #     object
-      #   end
-      # end
-
-      if self.respond_to? association
-        
-        target = self.send( association )
-        
-        unless target.is_a? Hash
-          target = object[target] ||= {}
-        end
-      else
-        target = object[association] ||= {}
-      end
-
-      deserializer.new( target, params[association] ).deserialize
-    end
-
-    def deserialize_nested( target, deserializer )
-      target = object[target] ||= {}
-      deserializer.new( target, params ).deserialize
-    end
-
-    def assign_value( attribute, value, options = {} )
-      if options[:ignore_empty] && empty?(value)
-        return
-      end
-      if options[:convert_with]
-        method = options[:convert_with]
-        if self.respond_to? method
-          self.object[attribute] = self.send method, value
-          return
-        end
-      end
-      # other options go here
-      
-      self.object[attribute] = value
-      
-    end
-
-    def empty?(value)
-      !value ||
-      value == "" ||
-      value == {} ||
-      value == []
+      self.object = {}
     end
   end
-end
+end

data/lib/deserializer/version.rb

@@ -1,3 +1,3 @@
 module Deserializer
-  VERSION = "0.4.0"
+  VERSION = "0.6.0"
 end

data/test/lib/deserializers.rb

@@ -122,4 +122,9 @@ class NestableDeserializer < Deserializer::Base
               :attr_1
 
   nests :nested_object, deserializer: ::NestedDeserializer
+end
+
+class HasManyDeserializer < Deserializer::Base
+  attribute   :id
+  has_many :attributes, deserializer: AttributeDeserializer
 end

data/test/unit/deserializer_test.rb

@@ -20,10 +20,6 @@ class DeserializerTest < Minitest::Test
     assert_equal ({user_id: 6, text: "text"}) , BasicDeserializer.from_params( @params )
   end
 
-  def test_permitted_params
-    assert_equal [:user_id, :text] , BasicDeserializer.permitted_params
-  end
-
   def test_does_not_eat_false_or_nil_values
     params = {  user_id: nil,
                 text: false,
@@ -32,6 +28,10 @@ class DeserializerTest < Minitest::Test
     assert_equal ({user_id: nil, text: false}) , BasicDeserializer.from_params( params )
   end
 
+  def test_permitted_params
+    assert_equal [:user_id, :text] , BasicDeserializer.permitted_params
+  end
+
   def test_permitted_params_with_attr_key
     assert_equal [:user, :text] , AttributeDeserializer.permitted_params
   end
@@ -72,6 +72,27 @@ class DeserializerTest < Minitest::Test
     assert_equal nil, AttributeDeserializer.from_params( @params )[:i_shouldnt_be_here]
   end
 
+  def test_supports_conversions
+    expected = { real_range: (1..4), bad_range: (1..1)}
+    params   = { real_range: [1, 12, 4], bad_range: 1}
+
+    assert_equal expected, ConversionDeserializer.from_params( params )
+  end
+
+  def test_supports_conversions_with_key
+    expected = { real_range: (1..4), bad_range: (1..1)}
+    params   = { real: [1, 4], bad: 1}
+
+    assert_equal expected, KeyedConversionDeserializer.from_params( params )
+  end
+
+  def test_supports_conversions_with_ignore_empty
+    expected = { real_range: (1..4)}
+    params   = { real: [1, 4], bad: nil}
+
+    assert_equal expected, NillableConversionDeserializer.from_params( params )
+  end
+
   def test_has_one
     expected = { internal: :thing, params: { user_id: 6, text: "text" }}
     params   = { external: :thing, params: @params }
@@ -110,49 +131,47 @@ class DeserializerTest < Minitest::Test
     assert_equal expected, HasOneWithObjectTargetDeserializer.from_params( params )
   end
 
-  def test_has_many_unpermitted
+  def test_belongs_to_unpermitted
     assert_raises Deserializer::DeserializerError do
-      BasicDeserializer.has_many :explodies
+      BasicDeserializer.belongs_to :explody
     end
   end
 
-  def test_belongs_to_unpermitted
+  def test_tests_requires_deserializer
     assert_raises Deserializer::DeserializerError do
-      BasicDeserializer.belongs_to :explody
+      BasicDeserializer.nests :splosion
     end
   end
 
-  def test_supports_conversions
-    expected = { real_range: (1..4), bad_range: (1..1)}
-    params   = { real_range: [1, 12, 4], bad_range: 1}
+  def test_supports_nested
+    params   = { id: 1, attr_1: "blah", attr_2: "something" }
+    expected = { id: 1, attr_1: "blah", nested_object: { name: "blah", attr_2: "something" } }
 
-    assert_equal expected, ConversionDeserializer.from_params( params )
+    assert_equal expected, NestableDeserializer.from_params( params )
   end
 
-  def test_supports_conversions_with_key
-    expected = { real_range: (1..4), bad_range: (1..1)}
-    params   = { real: [1, 4], bad: 1}
-
-    assert_equal expected, KeyedConversionDeserializer.from_params( params )
+  def test_has_many_requires_deserializer
+    assert_raises Deserializer::DeserializerError do
+      BasicDeserializer.has_many :splosions
+    end
   end
 
-  def test_supports_conversions_with_ignore_empty
-    expected = { real_range: (1..4)}
-    params   = { real: [1, 4], bad: nil}
+  def test_supports_has_many
+    params   = { id: 1, attributes: [{user: 6, text: "lol"}, {user: 6, text: "something"}] }
+    expected = { id: 1, attributes: [{user_id: 6, text: "lol"}, {user_id: 6, text: "something"}] }
 
-    assert_equal expected, NillableConversionDeserializer.from_params( params )
+    assert_equal expected, HasManyDeserializer.from_params( params )
   end
 
-  def test_using_requires_deserializer
-     assert_raises Deserializer::DeserializerError do
-      BasicDeserializer.nests :splosion
-    end
+  def test_has_many_handles_no_input
+    assert_equal ({}), HasManyDeserializer.from_params( {} )
   end
 
-  def test_supports_using
-    params   = { id: 1, attr_1: "blah", attr_2: "something" }
-    expected = { id: 1, attr_1: "blah", nested_object: { name: "blah", attr_2: "something" } }
+  def test_has_one_handles_no_input
+    assert_equal ({}), VanillaHasOneDeserializer.from_params( {} )
+  end
 
-    assert_equal expected, NestableDeserializer.from_params( params )
+  def test_nested_handles_no_input
+    assert_equal ({nested_object: {}}), NestableDeserializer.from_params( {} )
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deserializer
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Greg Orlov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-03 00:00:00.000000000 Z
+date: 2016-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.1
 description: conversion from complexy write params to a json blob that an AR model
   can consume
 email:
@@ -68,7 +82,15 @@ files:
 - Rakefile
 - deserializer.gemspec
 - lib/deserializer.rb
-- lib/deserializer/associatable.rb
+- lib/deserializer/attributable.rb
+- lib/deserializer/attribute.rb
+- lib/deserializer/attribute/association.rb
+- lib/deserializer/attribute/attribute.rb
+- lib/deserializer/attribute/base.rb
+- lib/deserializer/attribute/has_many_association.rb
+- lib/deserializer/attribute/has_one_association.rb
+- lib/deserializer/attribute/nested_association.rb
+- lib/deserializer/attribute/value_attribute.rb
 - lib/deserializer/base.rb
 - lib/deserializer/deserializer_error.rb
 - lib/deserializer/version.rb

data/lib/deserializer/associatable.rb

@@ -1,38 +0,0 @@
-module Deserializer
-  module Associatable
-    extend ActiveSupport::Concern
-
-    included do
-      class << self
-        def has_one( target, opts = {})
-          deserializer = opts[:deserializer]
-
-          unless deserializer
-            raise DeserializerError, class: self, message: "has_one associations need a deserilaizer" 
-          end
-
-          self.attrs[target] = { attr: nil, deserializer: deserializer }
-        end
-
-        def has_many(*args)
-          raise DeserializerError, class: self, message: "has_many is intentionally unsupported."
-        end
-
-        def belongs_to(*args)
-          raise DeserializerError, class: self, message: "belongs_to is unsupported."
-        end
-
-        def nests(target, opts = {})
-          deserializer = opts[:deserializer]
-
-          unless deserializer
-            raise DeserializerError, class: self, message: "nested associations need a deserilaizer" 
-          end
-
-          self.nested_attrs ||= {}
-          self.nested_attrs[target] = { deserializer: deserializer }
-        end
-      end
-    end
-  end
-end