ixtlan-babel 0.3.5 → 0.4.0

data/spec/model_filter_with_methods_spec.rb

@@ -11,7 +11,7 @@ class Area2
   include Virtus
 
   attribute :code, String
-  attribute :iso, String  
+  attribute :iso, String
 end
 class PhoneNumber2
   include Virtus
@@ -30,12 +30,12 @@ class Person2
   attr_accessor :phone_numbers, :age, :children_names
 
   def phone_numbers
-    @phone_numbers ||= [PhoneNumber2.new( 
-        :prefix => 12, 
+    @phone_numbers ||= [PhoneNumber2.new(
+        :prefix => 12,
         :number => '123',
         :area => Area2.new( :code => '001', :iso => 'us' ) )]
   end
-  
+
   def age
     @age ||= 123
   end
@@ -53,132 +53,99 @@ describe Ixtlan::Babel::ModelFilter.to_s + ':with_methods' do
   let( :person ) do
    Person2.new( :id => 987,
                          :name => 'me and the corner',
-                         :address => Address2.new( :street => 'Foo 12', :zipcode => '12345' ) )
+                         :address => Address2.new( :street => 'Foo 12',
+                                                   :zipcode => '12345' ) )
   end
 
   let(:serializer) { Ixtlan::Babel::Serializer.new( person ) }
-  let(:deserializer) { Ixtlan::Babel::Deserializer.new( Person2 ) }
 
   it 'should serialize and deserialize with methods' do
-    json = serializer.to_json(:include => [:age, :children_names, :children_ages])
-    data = MultiJson.load(json)
-    data['age'].must_equal 123
-    data['children_names'].must_equal ['anna', 'jack', 'rama', 'mia']
-    data['children_ages'].must_equal [12, 3, 6, 9]
-    result = deserializer.from_json(json)
-    attributes = result.attributes.delete_if { |k,v| v.nil? }
-    attributes.must_equal Hash[:id => person['id'], :name => person['name']]
+    json = serializer.to_json( :include =>
+                               [:age, :children_names, :children_ages])
+    result = MultiJson.load(json)
+    result.must_equal Hash[ "id"=>"987",
+                            "name"=>"me and the corner",
+                            "age"=>123,
+                            "children_names"=> [ "anna",
+                                                 "jack",
+                                                 "rama",
+                                                 "mia" ],
+                            "children_ages"=>[ 12, 3, 6, 9 ] ]
   end
 
   it 'should serialize and deserialize without root' do
     json = serializer.to_json
-    result = deserializer.from_json(json)
-    attributes = result.attributes.delete_if { |k,v| v.nil? }
-    attributes.must_equal Hash[:id => person['id'], :name => person['name']]
+    result = MultiJson.load(json)
+    result.must_equal Hash[ "id"=>"987", "name"=>"me and the corner" ]
   end
 
   it 'should serialize and deserialize with root' do
     json = serializer.to_json :root => 'my'
-    result = deserializer.from_json(json, :root => 'my')
-    attributes = result.attributes.delete_if { |k,v| v.nil? }
-    attributes.must_equal Hash[:id => person['id'], :name => person['name']]
-  end  
+    result = MultiJson.load(json)[ 'my' ]
+    result.must_equal Hash[ "id"=>"987", "name"=>"me and the corner" ]
+  end
 
   it 'should serialize and deserialize a hash with include list' do
-    json = serializer.to_json(:include => ['address', 'phone_numbers'])   
-    data = MultiJson.load(json)
-    data['phone_numbers'][0]['prefix'].must_equal 12
-    data['phone_numbers'][0]['number'].must_equal '123'
-    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].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'])
+    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 'shouldserialize and deserialize with except' do
-    json = serializer.to_json(:except => ['id'])  
-    result = deserializer.from_json(json, :except => ['id'])  
-    result.attributes.must_equal Hash[:name => person['name'], :address=>nil, :id => nil]
-    result = deserializer.from_json(json)  
-    result.attributes.must_equal Hash[:name => person['name'], :address=>nil, :id => nil]
+    json = serializer.to_json(:except => ['id'])
+    result = MultiJson.load(json)
+    result.must_equal Hash[ "name"=>"me and the corner" ]
   end
 
   it 'should serialize and deserialize with only' do
-    json = serializer.to_json(:only => ['name']) 
-    result = deserializer.from_json(json, :only => ['name'])
-    result.attributes.must_equal Hash[:name => person['name'], :address=>nil, :id => nil]
-    result = deserializer.from_json(json)
-    result.attributes.must_equal Hash[:name => person['name'], :address=>nil, :id => nil]
+    json = serializer.to_json(:only => ['name'])
+    result = MultiJson.load(json)
+    result.must_equal Hash[ "name"=>"me and the corner" ]
   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
-
-    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
-
-    result.address.zipcode.must_be_nil
-
-    result.name.must_equal person.name
-    result.id.must_equal person.id
+    json = serializer.to_json(:include => { 'address' => {
+                                  :only => ['street'] } } )
+    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
-
-    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
-
-    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.code.must_equal person.phone_numbers[0].area.code
-    result.phone_numbers[0].area.iso.must_equal person.phone_numbers[0].area.iso
-    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
 end

data/spec/params_filter_spec.rb

@@ -21,8 +21,8 @@ describe Ixtlan::Babel::ParamsFilter 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'}
       }
@@ -34,74 +34,80 @@ describe Ixtlan::Babel::ParamsFilter do
   let(:deserializer) { Ixtlan::Babel::Deserializer.new(Hash) }
 
   it 'should filter a hash' do
-    json = filter.filter_it( data )
-    json[0].must_equal Hash[ 'id' => data['id'], 'name' => data['name'] ]
-    json[1].must_equal Hash[]
+    result = filter.filter_it( data )
+    result.params.must_equal Hash[ 'id' => data['id'], 'name' => data['name'] ]
+    result.size.must_equal 1
   end
 
   it 'should filter a hash with keep' do
-    json = filter.use( :keep => ['id'] ).filter_it( data )
-    json[0].must_equal Hash[ 'name' => data['name'] ]
-    json[1].must_equal Hash[ 'id' => data['id'] ]
+    result = filter.use( :keep => ['id'] ).filter_it( data )
+    result.params.must_equal Hash[ 'name' => data['name'] ]
+    result[ 'id' ].must_equal data['id']
+    result.size.must_equal 2
   end
 
   it 'should filter a hash with root' do
-    json = filter.use( :root => 'my' ).filter_it( 'my' => data )
-    json[0].must_equal Hash[ 'id' => data['id'], 'name' => data['name'] ]
-    json[1].must_equal Hash[]
-  end  
+    result = filter.use( :root => 'my' ).filter_it( 'my' => data )
+    result.params.must_equal Hash[ 'id' => data['id'], 'name' => data['name'] ]
+    result.size.must_equal 1
+  end
 
   it 'should filter a hash with include list' do
-    json = filter.use( :include => ['address', 'phone_numbers'] ).filter_it( data )
+    result = filter.use( :include => ['address',
+                                    'phone_numbers'] ).filter_it( data )
 
     data['phone_numbers'].delete('area')
-    json[0].must_equal Hash[data]
-    json[1].must_equal Hash[]
+    result.params.must_equal Hash[data]
+    result.size.must_equal 1
   end
 
   it 'should filter a hash with except' do
-    json = filter.use( :except => ['id'] ).filter_it( data )
-    json[0].must_equal Hash['name' => data['name']]
-    json[1].must_equal Hash[]
+    result = filter.use( :except => ['id'] ).filter_it( data )
+    result.params.must_equal Hash['name' => data['name']]
+    result.size.must_equal 1
   end
 
   it 'should filter a hash with except and keep' do
-    json = filter.use( :except => ['id'], :keep => ['id'] ).filter_it( data )
-    json[0].must_equal Hash['name' => data['name']]
-    json[1].must_equal Hash['id' => data['id']]
+    result = filter.use( :except => ['id'], :keep => ['id'] ).filter_it( data )
+    result.params.must_equal Hash['name' => data['name']]
+    result['id'].must_equal data['id']
   end
 
   it 'should filter a hash with only' do
-    json = filter.use( :only => ['name'] ).filter_it( data )
-    json[0].must_equal Hash['name' => data['name']]
-    json[1].must_equal Hash[]
+    result = filter.use( :only => ['name'] ).filter_it( data )
+    result.params.must_equal Hash['name' => data['name']]
+    result.size.must_equal 1
   end
 
   it 'should filter a hash with only and keep' do
-    json = filter.use( :only => ['name'], :keep => ['id'] ).filter_it( data )
-    json[0].must_equal Hash['name' => data['name']]
-    json[1].must_equal Hash['id' => data['id']]
+    result = filter.use( :only => ['name'], :keep => ['id'] ).filter_it( data )
+    result.params.must_equal Hash['name' => data['name']]
+    result[ 'id' ].must_equal data['id']
+    result.size.must_equal 2
   end
 
   it 'should filter a hash with nested only' do
-    json = filter.use( :include => { 'address' => {:only => ['street']}} ).filter_it( data )
+    result = filter.use( :include => { 'address' =>
+                         {:only => ['street']}} ).filter_it( data )
     data.delete('phone_numbers')
     data['address'].delete('zipcode')
-    json[0].must_equal Hash[data]
-    json[1].must_equal Hash[]
+    result.params.must_equal Hash[data]
+    result.size.must_equal 1
   end
 
   it 'should filter a hash with nested except' do
-    json = filter.use( :include => { 'address' => {:except => ['zipcode']}} ).filter_it( data ) 
+    result = filter.use( :include => { 'address' =>
+                         {:except => ['zipcode']}} ).filter_it( data )
     data.delete('phone_numbers')
     data['address'].delete('zipcode')
-    json[0].must_equal Hash[data]
-    json[1].must_equal Hash[]
+    result.params.must_equal Hash[data]
+    result.size.must_equal 1
   end
 
   it 'should filter a hash with nested include' do
-    json = filter.use( :include => { 'address' => {}, 'phone_numbers' => { :include => ['area']}} ).filter_it( data ) 
-    json[0].must_equal Hash[data]
-    json[1].must_equal Hash[]
+    result = filter.use( :include => { 'address' => {}, 'phone_numbers' =>
+                         { :include => ['area']}} ).filter_it( data )
+    result.params.must_equal Hash[data]
+    result.size.must_equal 1
   end
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: ixtlan-babel
 version: !ruby/object:Gem::Version
+  version: 0.4.0
   prerelease:
-  version: 0.3.5
 platform: ruby
 authors:
 - Christian Meier
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-04-24 00:00:00.000000000 Z
+date: 2013-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -17,29 +17,13 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 10.0.0
+        version: '10.0'
     none: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 10.0.0
-    none: false
-  prerelease: false
-  type: :development
-- !ruby/object:Gem::Dependency
-  name: copyright-header
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.0.7
-    none: false
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.0.7
+        version: '10.0'
     none: false
   prerelease: false
   type: :development
@@ -49,13 +33,13 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.3'
+        version: '4.0'
     none: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.3'
+        version: '4.0'
     none: false
   prerelease: false
   type: :development
@@ -65,13 +49,13 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: '0.5'
     none: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: '0.5'
     none: false
   prerelease: false
   type: :development
@@ -115,39 +99,36 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/ixtlan-babel.rb
-- lib/ixtlan/babel/deserializer.rb
+- lib/ixtlan/babel/dm_validation_errors_serializer.rb~
+- lib/ixtlan/babel/context.rb~
+- lib/ixtlan/babel/filter_config.rb~
+- lib/ixtlan/babel/context.rb
+- lib/ixtlan/babel/hash_only_filter.rb~
 - lib/ixtlan/babel/hash_filter.rb
+- lib/ixtlan/babel/abstract_filter.rb~
 - lib/ixtlan/babel/serializer.rb~
+- lib/ixtlan/babel/serializer.rb
+- lib/ixtlan/babel/factory.rb~
+- lib/ixtlan/babel/config.rb~
 - lib/ixtlan/babel/params_filter.rb
-- lib/ixtlan/babel/abstract_filter.rb
-- lib/ixtlan/babel/no_timestamp_serializer.rb
-- lib/ixtlan/babel/filter_config.rb
-- lib/ixtlan/babel/params_filter.rb~
-- lib/ixtlan/babel/context.rb
 - lib/ixtlan/babel/factory.rb
 - lib/ixtlan/babel/model_filter.rb~
+- lib/ixtlan/babel/model_filter.rb
+- lib/ixtlan/babel/params_filter.rb~
+- lib/ixtlan/babel/filter_config.rb
+- lib/ixtlan/babel/abstract_filter.rb
 - lib/ixtlan/babel/dm_validation_errors_serializer.rb
 - lib/ixtlan/babel/hash_filter.rb~
-- lib/ixtlan/babel/filter_config.rb~
-- lib/ixtlan/babel/hash_only_filter.rb~
-- lib/ixtlan/babel/factory.rb~
-- lib/ixtlan/babel/dm_validation_errors_serializer.rb~
-- lib/ixtlan/babel/context.rb~
-- lib/ixtlan/babel/model_filter.rb
-- lib/ixtlan/babel/hash_filter.rb-
-- lib/ixtlan/babel/abstract_filter.rb~
-- lib/ixtlan/babel/config.rb~
-- lib/ixtlan/babel/serializer.rb
-- spec/model_filter_with_methods.spec.rb~
-- spec/model_filter_spec.rb~
 - spec/model_filter_spec.rb
-- spec/model_filter_with_methods_spec.rb~
 - spec/params_filter_spec.rb
-- spec/hash_filter_spec.rb
+- spec/model_filter_with_methods_spec.rb
 - spec/hash_filter_spec.rb~
 - spec/spec_helper.rb
-- spec/model_filter_with_methods_spec.rb
+- spec/model_filter_with_methods.spec.rb~
 - spec/params_filter_spec.rb~
+- spec/hash_filter_spec.rb
+- spec/model_filter_with_methods_spec.rb~
+- spec/model_filter_spec.rb~
 - MIT-LICENSE
 - README.md
 - Gemfile
@@ -181,5 +162,5 @@ summary: babel offers a filter for hashes and with that comes json/yaml/xml de/s
 test_files:
 - spec/model_filter_spec.rb
 - spec/params_filter_spec.rb
-- spec/hash_filter_spec.rb
 - spec/model_filter_with_methods_spec.rb
+- spec/hash_filter_spec.rb