ixtlan-babel 0.3.5 → 0.4.0

data/Gemfile

@@ -1,3 +1,6 @@
-source :rubygems
+source 'https://rubygems.org'
 
 gemspec
+
+gem  'copyright-header', '~> 1.0', :platform => :mri
+

data/lib/ixtlan/babel/abstract_filter.rb

@@ -28,7 +28,7 @@ module Ixtlan
       def options
         @options || {}
       end
-        
+
       def add_custom_serializers( map )
         @map = map
       end
@@ -40,7 +40,7 @@ module Ixtlan
           data
         end
       end
-      
+
     end
   end
-end
+end

data/lib/ixtlan/babel/dm_validation_errors_serializer.rb

@@ -4,5 +4,5 @@ class DataMapper::Validations::ValidationErrorsSerializer < Ixtlan::Babel::Seria
   def to_hash( o = nil)
     @model_or_models.to_hash
   end
-  
+
 end

data/lib/ixtlan/babel/factory.rb

@@ -32,7 +32,7 @@ module Ixtlan
       DATE_TIME_TO_S = Proc.new do |dt|
         dt.strftime('%Y-%m-%dT%H:%M:%S.') + ("%06d" % (dt.sec_fraction * NANOSECONDS_IN_DAY ) )[0..6] + dt.strftime('%z')
       end
-      
+
       DEFAULT_MAP = {
         'DateTime' => DATE_TIME_TO_S,
         'ActiveSupport::TimeWithZone' => TIME_TO_S,
@@ -57,7 +57,8 @@ module Ixtlan
       def new_serializer( resource )
         if resource.respond_to?(:model)
           model = resource.model
-        elsif resource.respond_to?( :collect) && !resource.respond_to?( :to_hash)
+        elsif resource.respond_to?( :collect) &&
+            !resource.respond_to?( :to_hash)
           if resource.empty?
             return EmptyArraySerializer.new
           else

data/lib/ixtlan/babel/filter_config.rb

@@ -22,7 +22,7 @@ require 'ixtlan/babel/context'
 module Ixtlan
   module Babel
     class FilterConfig
-      
+
       private
 
       def context
@@ -32,7 +32,7 @@ module Ixtlan
       def context_options( context_or_options )
         if context_or_options
           case context_or_options
-          when Symbol  
+          when Symbol
             if opts = context[ context_or_options ]
               opts.dup
             end
@@ -44,7 +44,7 @@ module Ixtlan
 
       public
 
-      def default_context_key( single = :single, 
+      def default_context_key( single = :single,
                                collection = :collection )
         @single, @collection = single, collection
       end
@@ -58,15 +58,17 @@ module Ixtlan
       end
 
       def single_options( context_or_options )
-        context_options( context_or_options ) || context[ default_context_key[ 0 ] ] || {}
+        context_options( context_or_options ) ||
+          context[ default_context_key[ 0 ] ] || {}
       end
 
       def collection_options( context_or_options )
-        context_options( context_or_options ) || context[ default_context_key[ 1 ] ] || {}
+        context_options( context_or_options ) ||
+          context[ default_context_key[ 1 ] ] || {}
       end
 
       attr_accessor :root
 
     end
   end
-end
+end

data/lib/ixtlan/babel/hash_filter.rb

@@ -25,7 +25,7 @@ module Ixtlan
 
       def filter( data )
         if data
-          filter_data( data, 
+          filter_data( data,
                        Context.new( options ) )
         end
       end
@@ -33,7 +33,7 @@ module Ixtlan
       private
 
       def filter_array( array, options )
-        array.collect do |item| 
+        array.collect do |item|
           if item.is_a?( Array ) || item.is_a?( Hash )
             filter_data( item, options )
           else
@@ -48,9 +48,11 @@ module Ixtlan
           k = k.to_s
           case v
           when Hash
-            result[ k ] = filter_data( v, context[ k ] ) if context.include?( k )
+            result[ k ] = filter_data( v,
+                                       context[ k ] ) if context.include?( k )
           when Array
-            result[ k ] = filter_array( v, context[ k ] ) if context.include?( k )
+            result[ k ] = filter_array( v,
+                                        context[ k ] ) if context.include?( k )
           else
             result[ k ] = serialize( v ) if context.allowed?( k )
           end

data/lib/ixtlan/babel/model_filter.rb

@@ -28,7 +28,7 @@ module Ixtlan
           data = block.call( model )
           filter_data( model, data,
                        Context.new( options ),
-                       &block ) 
+                       &block )
         end
       end
 
@@ -54,16 +54,22 @@ module Ixtlan
 
       def filter_data(model, data, context, &block)
         setup_data(model, data, context)
-        
+
         result = {}
         data.each do |k,v|
           k = k.to_s
           if v.respond_to? :attributes
-            result[ k ] = filter_data( v, block.call(v), context[ k ], &block ) if context.include?( k )
+            result[ k ] = filter_data( v,
+                                       block.call(v),
+                                       context[ k ],
+                                       &block ) if context.include?( k )
           elsif v.is_a? Array
-            result[ k ] = filter_array( v, context[ k ], &block ) if context.include?( k )
+            result[ k ] = filter_array( v,
+                                        context[ k ],
+                                        &block ) if context.include?( k )
           else
-            result[ k ] = serialize( v ) if context.allowed?( k ) && ! v.respond_to?( :attributes )
+            result[ k ] = serialize( v ) if context.allowed?( k ) &&
+              ! v.respond_to?( :attributes )
           end
         end
         result

data/lib/ixtlan/babel/params_filter.rb

@@ -60,6 +60,37 @@ module Ixtlan
         self
       end
 
+      class FilterResult
+
+        def initialize( model, params, keeps )
+          @model = model
+          @data = keeps
+          @data[ :params ] = params
+        end
+
+        def new_model
+          @model.send( :new, params )
+        end
+
+        def params
+          @data[ :params ]
+        end
+
+        def method_missing( method, *args )
+          if respond_to?( method )
+            @data[ method ] || @data[ method.to_s ]
+          elsif @data.respond_to?( method )
+            @data.send( method, *args )
+          else
+            super
+          end
+        end
+
+        def respond_to?( method )
+          @data.key?( method ) || @data.key?( method.to_s )
+        end
+      end
+
       def filter_it( data )
         filter.options = self.class.config.single_options( @context_or_options )
         data = data.dup
@@ -67,17 +98,15 @@ module Ixtlan
         keeps = {}
         ( filter.options[ :keep ] || [] ).each do |k|
           keep = data[ k.to_s ] || data[ k.to_sym ]
-          keeps[ k.to_s ] = data.delete( k.to_s ) || data.delete( k.to_sym ) unless keep.is_a? Hash
+          keeps[ k.to_s ] = data.delete( k.to_s ) ||
+            data.delete( k.to_sym ) unless keep.is_a? Hash
         end
         filtered_data = filter.filter( data )
         ( filter.options[ :keep ] || [] ).each do |k|
-          keeps[ k.to_s ] = filtered_data.delete( k.to_s ) || filtered_data.delete( k.to_sym ) unless keeps.member?( k.to_s )
+          keeps[ k.to_s ] = filtered_data.delete( k.to_s ) ||
+            filtered_data.delete( k.to_sym ) unless keeps.member?( k.to_s )
         end
-        [ filtered_data, keeps ]
-      end
-
-      def new( data )
-        @model_class.new( filter( data ) )
+        FilterResult.new( @model_class, filtered_data, keeps )
       end
     end
   end

data/lib/ixtlan/babel/serializer.rb

@@ -37,7 +37,7 @@ module Ixtlan
       def initialize(model_or_models)
         @model_or_models = model_or_models
       end
-      
+
       def respond_to?(method)
         @model_or_models.respond_to?(method)
       end
@@ -45,7 +45,7 @@ module Ixtlan
       def method_missing(method, *args, &block)
         @model_or_models.send(method, *args, &block)
       end
-      
+
       def add_custom_serializers(map)
         filter.add_custom_serializers(map)
       end
@@ -57,7 +57,7 @@ module Ixtlan
       end
 
       def filter
-        @filter ||= @model_or_models.is_a?( Hash ) ? HashFilter.new :  ModelFilter.new
+        @filter ||= ModelFilter.new
       end
 
       protected
@@ -119,7 +119,8 @@ module Ixtlan
       private :setup_filter
 
       def collection?
-        @is_collection ||= @model_or_models.respond_to?(:collect) && ! @model_or_models.is_a?(Hash)
+        @is_collection ||= @model_or_models.respond_to?(:collect) &&
+          ! @model_or_models.is_a?(Hash)
       end
       private :collection?
 
@@ -139,7 +140,7 @@ module Ixtlan
       def to_yaml(options = nil)
         to_hash(options).to_yaml
       end
-      
+
       protected
 
       def attr(model)
@@ -154,7 +155,7 @@ module Ixtlan
         else
           filter.filter( model ){ |model| attr(model) }
         end
-      end 
+      end
     end
   end
 end

data/spec/hash_filter_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'ixtlan/babel/deserializer'
 
 class Hash
   def attributes
@@ -16,17 +15,17 @@ describe Ixtlan::Babel::HashFilter do
       'id' => 987,
       'name' => 'me and the corner',
       'address' => { 'street' => 'Foo 12', 'zipcode' => '12345' },
-      'phone_numbers' => { 
-        'prefix' => 12, 
+      'phone_numbers' => {
+        'prefix' => 12,
         'number' => '123',
         'area' => { 'code' => '001', 'iso' => 'us'}
       }
     }
     class Hash
-      def self.new(hash = nil, &block) 
+      def self.new(hash = nil, &block)
         if hash
           self[hash]
-        else 
+        else
           super &block
         end
       end
@@ -35,7 +34,26 @@ describe Ixtlan::Babel::HashFilter do
   end
 
   let(:serializer) { Ixtlan::Babel::Serializer.new(data) }
-  let(:deserializer) { Ixtlan::Babel::Deserializer.new(Hash) }
+  let(:deserializer) do
+    f = Ixtlan::Babel::HashFilter.new
+    def f.from_json( json, options = nil )
+      data = MultiJson.load(json)
+      self.options = options || {}
+      if data.is_a? Array
+        if filter.options[:root]
+          data.collect do |d|
+            Hash.new( self.filter( d[ self.options[:root] ] ) )
+          end
+        else
+          data.collect{ |d| Hash.new( self.filter( d ) ) }
+        end
+      else
+        data = data[ self.options[:root] ] if self.options[:root]
+        Hash.new( self.filter( data ) )
+      end
+    end
+    f
+  end
 
   it 'should serialize and deserialize a hash' do
     json = serializer.to_json
@@ -47,25 +65,26 @@ describe Ixtlan::Babel::HashFilter do
     json = serializer.to_json :root => 'my'
     result = deserializer.from_json(json, :root => 'my')
     result.must_equal Hash['id' => data['id'], 'name' => data['name']]
-  end  
+  end
 
   it 'should serialize and deserialize a hash with include list' do
-    json = serializer.to_json(:include => ['address', 'phone_numbers']) 
-    result = deserializer.from_json(json, :include => ['address', 'phone_numbers'])
+    json = serializer.to_json(:include => ['address', 'phone_numbers'])
+    result = deserializer.from_json(json, :include =>
+                                    ['address', 'phone_numbers'])
     data['phone_numbers'].delete('area')
     result.must_equal Hash[data]
   end
 
   it 'should serialize and deserialize a hash with except' do
-    json = serializer.to_json(:except => ['id'])  
-    result = deserializer.from_json(json, :except => ['id'])  
+    json = serializer.to_json(:except => ['id'])
+    result = deserializer.from_json(json, :except => ['id'])
     result.must_equal Hash['name' => data['name']]
-    result = deserializer.from_json(json)  
+    result = deserializer.from_json(json)
     result.must_equal Hash['name' => data['name']]
   end
 
   it 'should serialize and deserialize a hash with only' do
-    json = serializer.to_json(:only => ['name']) 
+    json = serializer.to_json(:only => ['name'])
     result = deserializer.from_json(json, :only => ['name'])
     result.must_equal Hash['name' => data['name']]
     result = deserializer.from_json(json)
@@ -76,30 +95,37 @@ describe Ixtlan::Babel::HashFilter do
     json = serializer.to_json(:include => { 'address' => {:only => ['street']}})
     data.delete('phone_numbers')
     data['address'].delete('zipcode')
-    result = deserializer.from_json(json, :include => { 'address' => {:only => ['street']}})
+    result = deserializer.from_json(json, :include =>
+                                    { 'address' => {:only => ['street']}})
     result.must_equal data
     result = deserializer.from_json(json, :include => ['address'])
     result.must_equal data
   end
 
   it 'should serialize and deserialize a hash with nested except' do
-    json = serializer.to_json(:include => { 'address' => {:except => ['zipcode']}}) 
+    json = serializer.to_json(:include => { 'address' =>
+                                {:except => ['zipcode']}})
     data.delete('phone_numbers')
     data['address'].delete('zipcode')
-    result = deserializer.from_json(json, :include => { 'address' => {:except => ['zipcode']}})
+    result = deserializer.from_json(json, :include => { 'address' =>
+                                      {:except => ['zipcode']}})
     result.must_equal data
     result = deserializer.from_json(json, :include => ['address'])
     result.must_equal data
   end
 
   it 'should serialize and deserialize a hash with nested include' do
-    json = serializer.to_json(:include => { 'address' => {}, 'phone_numbers' => { :include => ['area']}}) 
-    result = deserializer.from_json(json, :include => { 'address' => {}, 'phone_numbers' => { :include => ['area']}})
+    json = serializer.to_json(:include => { 'address' => {},
+                                'phone_numbers' => { :include => ['area']}})
+    result = deserializer.from_json(json, :include => { 'address' => {},
+                                      'phone_numbers' => {
+                                        :include => ['area']}})
     result.must_equal data
   end
 
   it 'should convert elements from arrays wth custom serializer' do
-    serializer.add_custom_serializers( "Symbol" => Proc.new {|v| v.to_s.capitalize } )
+    serializer.add_custom_serializers( "Symbol" =>
+                                       Proc.new {|v| v.to_s.capitalize } )
     data['children_names'] = [:adi, :aromal, :shreedev]
     d = serializer.to_hash(:include => [ :children_names ])
     d[ "children_names"].must_equal( ["Adi", "Aromal", "Shreedev"] )

data/spec/model_filter_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 require 'virtus'
-require 'ixtlan/babel/deserializer'
+require 'ixtlan/babel/serializer'
 
 class Address
   include Virtus
@@ -12,7 +12,7 @@ class Area
   include Virtus
 
   attribute :code, String
-  attribute :iso, String  
+  attribute :iso, String
 end
 class PhoneNumber
   include Virtus
@@ -37,8 +37,8 @@ describe Ixtlan::Babel::ModelFilter do
       :id => 987,
       :name => 'me and the corner',
       :address => Address.new( :street => 'Foo 12', :zipcode => '12345' ),
-      :phone_numbers => [PhoneNumber.new( 
-        :prefix => 12, 
+      :phone_numbers => [PhoneNumber.new(
+        :prefix => 12,
         :number => '123',
         :area => Area.new( :code => '001', :iso => 'us' )
       )],
@@ -47,168 +47,84 @@ describe Ixtlan::Babel::ModelFilter do
   end
 
   let(:serializer) { Ixtlan::Babel::Serializer.new( person ) }
-  let(:deserializer) { Ixtlan::Babel::Deserializer.new( Person ) }
 
   it 'should serialize and deserialize without root' do
     json = serializer.to_json
-    result = deserializer.from_json(json)
-
-    # travis produces [] and locally there is a nil - filter empty as well :(
-    attributes = result.attributes.delete_if { |k,v| v.nil? || v.empty? }
-
-    attributes.must_equal Hash[:id => person['id'], :name => person['name']]
+    result = MultiJson.load(json)
+    result.must_equal Hash['id' => person['id'], 'name' => person['name']]
   end
 
   it 'should serialize and deserialize with root' do
     json = serializer.to_json :root => 'my'
-    result = deserializer.from_json(json, :root => 'my')
-
-    # travis produces [] and locally there is a nil - filter empty as well :(
-    attributes = result.attributes.delete_if { |k,v| v.nil? || v.empty? }
-
-    attributes.must_equal Hash[:id => person['id'], :name => person['name']]
-  end  
+    result = MultiJson.load(json)[ 'my' ]
+    result.must_equal Hash['id' => person['id'], 'name' => person['name']]
+  end
 
   it 'should serialize and deserialize a hash with include list' do
-    json = serializer.to_json(:include => ['address', 'phone_numbers']) 
-    result = deserializer.from_json(json, :include => ['address', 'phone_numbers'])
-    result.object_id.wont_equal person.object_id
-    result.address.attributes.must_equal person.address.attributes
-    result.phone_numbers[0].area.must_be_nil
-    person.phone_numbers[0].area = nil
-    result.phone_numbers[0].attributes.must_equal person.phone_numbers[0].attributes
-    result.name.must_equal person.name
-    result.id.must_equal person.id
+    json = serializer.to_json(:include => ['address', 'phone_numbers'])
+    result = MultiJson.load(json)
+    result.must_equal Hash[ "id"=>"987",
+                            "name"=>"me and the corner",
+                            "address"=>{
+                              "street"=>"Foo 12",
+                              "zipcode"=>"12345"
+                            },
+                            "phone_numbers"=> [ {"prefix"=>12,
+                                                  "number"=>"123" } ] ]
   end
 
   it 'should serialize and deserialize with except' do
-    json = serializer.to_json(:except => ['id'])  
-    result = deserializer.from_json(json, :except => ['id'])  
-    
-    expected = Hash[:name => person['name'], :address=>nil, :phone_numbers=>[], :id => nil, :children_names => []]
-
-    # travis sees empty array and locally it is nil :(
-    result.phone_numbers ||= []
-    result.children_names ||= []
-
-    result.attributes.keys.dup.each do |k|
-      result.attributes[ k ].must_equal expected[ k ]
-    end
-
-    result = deserializer.from_json(json)
-
-    # travis sees empty array and locally it is nil :(
-    result.phone_numbers ||= []
-    result.children_names ||= []
-
-    result.attributes.keys.dup.each do |k|
-      result.attributes[ k ].must_equal expected[ k ]
-    end
+    json = serializer.to_json(:except => ['id'])
+    result = MultiJson.load(json)
+    result.must_equal Hash['name' => person['name']]
   end
 
   it 'should serialize and deserialize with only' do
-    json = serializer.to_json(:only => ['name']) 
-    result = deserializer.from_json(json, :only => ['name'])
-
-    # travis sees empty array and locally it is nil :(
-    result.phone_numbers ||= []
-    result.children_names ||= []
-
-    expected = Hash[:name => person['name'], :address=>nil, :phone_numbers=>[], :id => nil, :children_names => []]
-    result.attributes.keys.dup.each do |k|
-      result.attributes[ k ].must_equal expected[ k ]
-    end
-
-    result = deserializer.from_json(json)
-
-    # travis sees empty array and locally it is nil :(
-    result.phone_numbers ||= []
-    result.children_names ||= []
+    json = serializer.to_json(:only => ['name'])
+    result = MultiJson.load(json)
 
-    result.attributes.keys.dup.each do |k|
-      result.attributes[ k ].must_equal expected[ k ]
-    end
+    result.must_equal Hash['name' => person['name']]
   end
 
   it 'should serialize and deserialize with nested only' do
     json = serializer.to_json(:include => { 'address' => {:only => ['street']}})
-    result = deserializer.from_json(json, :include => { 'address' => {:only => ['street']}})
-
-    json['phone_numbers'].must_be_nil
-    json['address']['zipcode'].must_be_nil
-
-    # travis produces [] and locally there is a nil :(
-    (result.phone_numbers || []).must_equal []
-
-    result.address.zipcode.must_be_nil
-
-    result.name.must_equal person.name
-    result.id.must_equal person.id
-  end
-
-  it 'should serialize and deserialize with nested only (array includes)' do
-    json = serializer.to_json(:include => { 'address' => {:only => ['street']}})
-    result = deserializer.from_json(json, :include => ['address'])
-
-    json['phone_numbers'].must_be_nil
-    json['address']['zipcode'].must_be_nil
-
-    # travis produces [] and locally there is a nil :(
-    (result.phone_numbers || []).must_equal []
-
-    result.address.zipcode.must_be_nil
-
-    result.name.must_equal person.name
-    result.id.must_equal person.id
+    result = MultiJson.load(json)
+    result.must_equal Hash[ "id"=>"987",
+                             "name"=>"me and the corner",
+                             "address"=>{ "street"=>"Foo 12" } ]
   end
 
   it 'should serialize and deserialize with nested except' do
-    json = serializer.to_json(:include => { 'address' => {:except => ['zipcode']}})
-    result = deserializer.from_json(json, :include => { 'address' => {:except => ['zipcode']}})
-
-    json['phone_numbers'].must_be_nil
-    json['address']['zipcode'].must_be_nil
-
-    # travis produces [] and locally there is a nil :(
-    (result.phone_numbers || []).must_equal []
-
-    result.address.zipcode.must_be_nil
-
-    result.name.must_equal person.name
-    result.id.must_equal person.id
-  end
-
-  it 'should serialize and deserialize with nested except (array includes)' do
-    json = serializer.to_json(:include => { 'address' => {:except => ['zipcode']}})
-    result = deserializer.from_json(json, :include => ['address'])
-
-    json['phone_numbers'].must_be_nil
-    json['address']['zipcode'].must_be_nil
-
-    # travis produces [] and locally there is a nil :(
-    (result.phone_numbers || []).must_equal []
-
-    result.address.zipcode.must_be_nil
-
-    result.name.must_equal person.name
-    result.id.must_equal person.id
+    json = serializer.to_json(:include =>
+                              { 'address' => {:except => ['zipcode']}})
+    result = MultiJson.load(json)
+    result.must_equal Hash[ "id"=>"987",
+                            "name"=>"me and the corner",
+                            "address"=>{ "street"=>"Foo 12" } ]
   end
 
   it 'should serialize and deserialize with nested include' do
-    json = serializer.to_json(:include => { 'address' => {}, 'phone_numbers' => { :include => ['area']}}) 
-    result = deserializer.from_json(json, :include => { 'address' => {}, 'phone_numbers' => { :include => ['area']}})
-
-    result.object_id.wont_equal person.object_id
-    result.address.attributes.must_equal person.address.attributes
-    result.phone_numbers[0].area.attributes.must_equal person.phone_numbers[0].area.attributes
-    result.phone_numbers[0].prefix.must_equal person.phone_numbers[0].prefix
-    result.phone_numbers[0].number.must_equal person.phone_numbers[0].number
-    result.name.must_equal person.name
-    result.id.must_equal person.id
+    json = serializer.to_json( :include => {
+                                 'address' => {},
+                                 'phone_numbers' => { :include => ['area'] }
+                               } )
+    result = MultiJson.load(json)
+    result.must_equal Hash[ "id"=>"987",
+                            "name"=>"me and the corner",
+                            "address"=>{ "street"=>"Foo 12",
+                              "zipcode"=>"12345" },
+                            "phone_numbers"=>[ { "prefix"=>12,
+                                                 "number"=>"123",
+                                                 "area"=>{
+                                                   "code"=>"001",
+                                                   "iso"=>"us"
+                                                 }
+                                               } ] ]
   end
 
   it 'should convert elements from arrays wth custom serializer' do
-    serializer.add_custom_serializers( "Symbol" => Proc.new {|v| v.to_s.capitalize } )
+    serializer.add_custom_serializers( "Symbol" =>
+                                       Proc.new {|v| v.to_s.capitalize } )
     data = serializer.to_hash(:include => [ :children_names ])
     data[ "children_names"].must_equal( ["Adi", "Aromal", "Shreedev"] )
   end