iso-deserializer 0.8.0

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.dup
+          attrs.each do |attr|
+            attribute( attr, {} )
+          end
+        end
+
+        def attribute( name, opts = {} )
+          attribute = Attribute::Attribute.new( Attribute::ValueAttribute, name, opts )
+          self.__attrs = __attrs.merge attribute.key => attribute
+        end
+
+        def has_one( name, opts = {} )
+          unless opts[:deserializer]
+            raise DeserializerError, class: self, message: "has_one associations need a deserilaizer" 
+          end
+          
+          attribute = Attribute::Attribute.new( Attribute::HasOneAssociation, name, opts )
+          self.__attrs = __attrs.merge attribute.key => attribute
+        end
+
+        def has_many( name, opts = {} )
+          unless opts[:deserializer]
+            raise DeserializerError, class: self, message: "has_many associations need a deserilaizer" 
+          end
+
+          attribute = Attribute::Attribute.new( Attribute::HasManyAssociation, name, opts )
+          self.__attrs = __attrs.merge attribute.key => attribute
+        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
+
+          attribute = Attribute::Attribute.new( Attribute::NestedAssociation, name, opts )
+          self.__attrs = __attrs.merge attribute.key => attribute
+        end
+      end
+    end
+  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,35 @@
+module Deserializer
+  module Attribute
+    class HasOneAssociation < Association
+
+      def to_hash( params )
+        return {} unless params.has_key? key
+        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: GnihtDeserializer
+          #
+          # def thing
+          #   :some_other_key
+          # end
+          else
+            return { target => value }
+          end
+        else
+          return { name => 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,24 @@
+module Deserializer
+  module Attribute
+    class ValueAttribute < Base
+
+      def value( params )
+        value = params[key]
+
+        if opts[:ignore_empty] && value.blank?
+          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
+    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/base.rb

@@ -0,0 +1,56 @@
+module Deserializer
+  class Base
+
+    ## atribute, has_one, nested, etc associations
+    include Deserializer::Attributable
+
+    class_attribute :__attrs
+    self.__attrs = {}
+    class << self
+      
+      # deserializer usage functions
+
+      def from_params( params = {} )
+        new( params ).deserialize
+      end
+
+      def permitted_params
+        __attrs.keys
+      end
+    end
+
+    attr_reader     :object
+
+    def deserialize
+
+      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
+      object
+    end
+
+    protected
+
+    attr_accessor   :params
+    attr_writer     :object
+
+    def initialize( params = {})
+      unless params
+        raise DeserializerError, class: self.class, message: "params cannot be nil"
+      end
+
+      self.params = params
+      self.object = {}
+    end
+  end
+end

data/lib/deserializer/deserializer_error.rb

@@ -0,0 +1,12 @@
+module Deserializer
+  class DeserializerError < StandardError
+    def initialize(opts = {})
+      @klass    = opts.fetch :class, Deserializer::Base
+      @message  = opts.fetch :message, ""
+    end
+
+    def message
+      "#{@klass}: #{@message}"
+    end
+  end
+end

data/lib/deserializer/version.rb

@@ -0,0 +1,3 @@
+module Deserializer
+  VERSION = "0.8.0"
+end

data/lib/deserializer.rb

@@ -0,0 +1,12 @@
+require "deserializer/version"
+require 'active_support'
+require 'active_support/concern'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/class/attribute'
+
+module Deserializer
+  autoload :Attribute,          'deserializer/attribute'
+  autoload :Attributable,       'deserializer/attributable'
+  autoload :Base,               'deserializer/base'
+  autoload :DeserializerError,  'deserializer/deserializer_error'
+end

data/test/lib/deserializers.rb

@@ -0,0 +1,148 @@
+class BasicDeserializer < Deserializer::Base
+  attributes  :user_id,
+              :text
+end
+
+class AttributeDeserializer < Deserializer::Base
+  attribute :user_id, key: :user
+  attribute :text
+end
+
+class VanillaHasOneDeserializer < Deserializer::Base
+  attribute   :internal, key: :external
+
+  has_one :params, deserializer: BasicDeserializer
+  
+end
+
+class EmptiableAttributeDeserializer < Deserializer::Base
+  attribute :emptiable, ignore_empty: true
+  attribute :nonemptiable, ignore_empty: false
+  
+  attribute :emptiable_with_key,  ignore_empty: true, key: :empty
+  attribute :nonemptiable_with_key,  ignore_empty: false, key: :non_empty
+end
+
+class HasOneWithTargetDeserializer < Deserializer::Base
+  attribute   :internal, key: :external
+
+  has_one :thing, deserializer: ::BasicDeserializer
+  
+  def thing
+    :user_info
+  end
+end
+
+class OtherThingDeserializer < Deserializer::Base
+  attributes  :attr1,
+              :attr2
+end
+
+class TricksyDeserializer < Deserializer::Base
+  attribute   :internal, key: :external
+
+  has_one :thing, deserializer: ::BasicDeserializer
+  
+  has_one :other_thing, deserializer: ::OtherThingDeserializer
+
+  def thing
+    :user_info
+  end
+
+  def other_thing
+    :user_info
+  end
+end
+
+class ExtraTricksyDeserializer < Deserializer::Base
+  attribute   :internal, key: :external
+
+  has_one :thing, deserializer: ::BasicDeserializer
+  
+  has_one :other_thing, deserializer: ::OtherThingDeserializer
+
+  def other_thing
+    :thing
+  end
+end
+
+class HasOneWithObjectTargetDeserializer < Deserializer::Base
+  attribute   :internal, key: :external
+
+  has_one :thing, deserializer: ::BasicDeserializer
+
+  has_one :other_thing, deserializer: ::OtherThingDeserializer
+  
+  def thing
+    object
+  end
+
+  def other_thing
+    object
+  end
+end
+
+class ConversionDeserializer < Deserializer::Base
+  attribute :real_range, convert_with: :to_range
+  attribute :bad_range,  convert_with: :to_range
+
+  def to_range(value)
+    range_array = Array(value)
+    (range_array[0]..range_array[-1])
+  end
+end
+
+class KeyedConversionDeserializer < Deserializer::Base
+  attribute :real_range, convert_with: :to_range, key: :real
+  attribute :bad_range,  convert_with: :to_range, key: :bad
+
+  def to_range(value)
+    range_array = Array(value)
+    (range_array[0]..range_array[-1])
+  end
+end
+
+class NillableConversionDeserializer < Deserializer::Base
+  attribute :real_range, convert_with: :to_range, key: :real, ignore_empty: true
+  attribute :bad_range,  convert_with: :to_range, key: :bad,  ignore_empty: true
+
+  def to_range(value)
+    range_array = Array(value)
+    (range_array[0]..range_array[-1])
+  end
+end
+
+class NestedDeserializer < Deserializer::Base
+  attribute :name, key: :attr_1
+  attribute :attr_2
+end
+
+class NestableDeserializer < Deserializer::Base
+  attributes  :id,
+              :attr_1
+
+  nests :nested_object, deserializer: ::NestedDeserializer
+end
+
+class HasManyDeserializer < Deserializer::Base
+  attribute   :id
+  has_many :attributes, deserializer: AttributeDeserializer
+end
+
+class InheritedDeserializer < HasOneWithTargetDeserializer
+  attributes  :this,
+              :that
+
+  attribute   :created_by
+end
+
+class KeyedHasManyDeserializer < Deserializer::Base
+  attribute   :id
+  has_many :special_attributes, deserializer: AttributeDeserializer, key: :attributes
+end
+
+class KeyedHasOneDeserializer < Deserializer::Base
+  attribute   :internal, key: :external
+
+  has_one :user_info, deserializer: ::BasicDeserializer, key: :thing
+end

data/test/minitest_helper.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'simplecov'
+SimpleCov.start
+
+require 'deserializer'
+
+test_libs_path = File.expand_path("../lib", __FILE__)
+Dir[File.join(test_libs_path, "/**/*.rb")].each do |file|
+  puts file
+  require file
+end
+
+require 'minitest/autorun'

data/test/unit/deserializer_error_test.rb

@@ -0,0 +1,12 @@
+require 'minitest_helper'
+
+class DeserializerErrorTest < Minitest::Test
+
+  def test_error_contains_message
+    begin 
+      BasicDeserializer.has_one :lolnope
+    rescue => e
+      assert_equal "BasicDeserializer: has_one associations need a deserilaizer", e.message
+    end
+  end
+end