ixtlan-babel 0.5.0 → 0.7.0

data/lib/ixtlan/babel/model_serializer.rb~

@@ -0,0 +1,104 @@
+module Ixtlan
+  module Babel
+    
+    module ModelSerializer
+
+      attr_reader :model
+
+      def self.included( model )
+        model.extend( ClassMethods )
+      end
+
+      def respond_to? name
+        @model.respond_to? name
+      end
+
+      def method_missing( name, *args, &block )
+        @model.send( name, *args, &block )
+      end
+
+      def to_json
+        to_data.to_json
+      end
+      
+      def to_yaml
+        to_data.to_yaml
+      end
+
+      def to_data
+        if @model.respond_to?( :collect ) and not @model.is_a?( Hash )
+          @model.collect do |m|
+            replace( m ).to_hash
+          end
+        else
+          to_hash
+        end
+      end
+
+      def serializers=( map )
+        @map = map
+      end
+
+      def serialize( data )
+        if @map && ser = @map[ data.class.to_s ]
+p ser
+          ser.call(data)
+        else
+          data
+        end
+      end
+
+      def to_hash
+        result = {}
+        self.class.attributes.each do |k,v|
+          if v
+            filter = v.is_a?( Array ) ? v[ 0 ] : v
+            filter.serializers = @map
+            model = @model.send( k )
+            result[ k ] = filter.replace( model ).to_data if model
+          else
+            result[ k ] = serialize( @model.send( k ) )
+          end
+        end
+        result
+      end
+      
+      def initialize( model = nil, map = nil )
+        super()
+        @map = map
+        replace( model )
+      end
+
+      def replace( model )
+        @model = model
+        self
+      end
+
+      module ClassMethods
+
+        def attribute( name, type = nil )
+          attributes[ name.to_sym ] = new_instance( type )
+        end
+
+        def attributes( *args )
+          if args.size == 0
+            @attributes ||= (superclass.attributes.dup rescue nil) || {}
+          else
+            args.each { |a| attribute( a ) }
+          end
+        end
+        
+        def new_instance( type )
+          case type
+          when Array
+            [ type[ 0 ].new ]
+          when NilClass
+            nil
+          else
+            type.new
+          end
+        end
+      end
+    end
+  end
+end

data/spec/hash_filter_spec.rb

@@ -1,133 +1,102 @@
-require 'spec_helper'
+require_relative 'spec_helper'
+require 'ixtlan/babel/hash_filter'
+require 'yaml'
+class A; end
+class AFilter 
+  include Ixtlan::Babel::HashFilter
+
+  attributes :id, :name
+end
+class HiddenFilter < AFilter
+  attributes.delete( :id )
+  hidden :id
+end
+class AddressFilter
+  include Ixtlan::Babel::HashFilter
+  attributes :street
+end
+class PhoneFilter
+  include Ixtlan::Babel::HashFilter
+  attributes :prefix, :number
+end
+class AreaFilter
+  include Ixtlan::Babel::HashFilter
+  attributes :code, :iso
+end
+class Phone2Filter < PhoneFilter
+  attribute :area, AreaFilter
+end
+class NestedFilter < AFilter
+  attribute :address, AddressFilter
+end
+class NestedArrayFilter < AFilter
+  attribute :phone_numbers, Array[PhoneFilter]
+end
+class DeepNestedFilter < NestedArrayFilter
+  attribute :phone_numbers, Array[Phone2Filter]
+end
 
 class Hash
   def attributes
     self
   end
-  def method_missing(method, *args)
+  def method_missing(method)
     self[method.to_s]
   end
 end
 
 describe Ixtlan::Babel::HashFilter do
   let(:data) do
-    data = {
+    {
       'id' => 987,
       'name' => 'me and the corner',
       'address' => { 'street' => 'Foo 12', 'zipcode' => '12345' },
-      'phone_numbers' => {
+      'phone_numbers' => [ {
         'prefix' => 12,
         'number' => '123',
         'area' => { 'code' => '001', 'iso' => 'us'}
-      }
+      } ]
     }
-    class Hash
-      def self.new(hash = nil, &block)
-        if hash
-          self[hash]
-        else
-          super &block
-        end
-      end
-    end
-    data
-  end
-
-  let(:serializer) { Ixtlan::Babel::Serializer.new(data) }
-  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
-    result = deserializer.from_json(json)
-    result.must_equal Hash['id' => data['id'], 'name' => data['name']]
+  it 'should filter a hash' do
+    result = AFilter.new.replace( data )
+    result.params.must_equal Hash[ 'id' => data['id'], 'name' => data['name'] ]
+    result.id.must_equal data['id']
+    result.name.must_equal data['name']
   end
 
-  it 'should serialize and deserialize a hash with root' do
-    json = serializer.to_json :root => 'my'
-    result = deserializer.from_json(json, :root => 'my')
-    result.must_equal Hash['id' => data['id'], 'name' => data['name']]
+  it 'should filter a hash with hidden' do
+    result = HiddenFilter.new.replace( data )
+    result.params.must_equal Hash[ 'name' => data['name'] ]
+    result.id.must_equal data['id']
+    result.name.must_equal data['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'])
-    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'])
-    result.must_equal Hash['name' => data['name']]
-    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'])
-    result = deserializer.from_json(json, :only => ['name'])
-    result.must_equal Hash['name' => data['name']]
-    result = deserializer.from_json(json)
-    result.must_equal Hash['name' => data['name']]
-  end
-
-  it 'should serialize and deserialize a hash with nested only' do
-    json = serializer.to_json(:include => { 'address' => {:only => ['street']}})
-    data.delete('phone_numbers')
+  it 'should filter a hash with nested' do
+    result = NestedFilter.new.replace( data )
+    data.delete( 'phone_numbers' )
     data['address'].delete('zipcode')
-    result = deserializer.from_json(json, :include =>
-                                    { 'address' => {:only => ['street']}})
-    result.must_equal data
-    result = deserializer.from_json(json, :include => ['address'])
-    result.must_equal data
+    result.params.to_yaml.must_equal data.to_yaml
+    result.address.street.must_equal data['address']['street']
   end
 
-  it 'should serialize and deserialize a hash with nested except' do
-    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.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']}})
-    result.must_equal data
+  it 'should filter a hash with nested array' do
+    result = NestedArrayFilter.new.replace( data )
+    data.delete( 'address' )
+    data['phone_numbers'].delete('area')
+    result.params.to_yaml.must_equal data.to_yaml
+    result.phone_numbers[0].prefix.must_equal data['phone_numbers'][0]['prefix']
+    result.phone_numbers[0].number.must_equal data['phone_numbers'][0]['number']
   end
 
-  it 'should convert elements from arrays wth custom serializer' do
-    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"] )
+  it 'should filter a hash with deep nested' do
+    result = DeepNestedFilter.new.replace( data )
+    data.delete( 'address' )
+    result.params.to_yaml.must_equal data.to_yaml
+    result.phone_numbers[0].prefix.must_equal data['phone_numbers'][0]['prefix']
+    result.phone_numbers[0].number.must_equal data['phone_numbers'][0]['number']
+    result.phone_numbers[0].area.code.must_equal data['phone_numbers'][0]['area']['code']
+    result.phone_numbers[0].area.iso.must_equal  data['phone_numbers'][0]['area']['iso']
   end
 end

data/spec/model_serializer_spec.rb

@@ -0,0 +1,159 @@
+require_relative 'spec_helper'
+require 'ixtlan/babel/model_serializer'
+require 'virtus'
+require 'multi_json'
+require 'json'
+
+Model = Virtus.model
+class Address
+  include Model
+
+  attribute :street, String
+  attribute :zipcode, String
+end
+class Area
+  include Model
+
+  attribute :code, String
+  attribute :iso, String
+end
+class PhoneNumber
+  include Model
+
+  attribute :prefix, Integer
+  attribute :number, String
+  attribute :area, Area
+end
+class Person
+  include Model
+
+  attribute :id, String
+  attribute :name, String
+  attribute :address, Address
+
+  attr_accessor :phone_numbers, :age, :children_names
+
+  def phone_numbers
+    @phone_numbers ||= [PhoneNumber.new(
+        :prefix => 12,
+        :number => '123',
+        :area => Area.new( :code => '001', :iso => 'us' ) )]
+  end
+
+  def age
+    @age ||= 123
+  end
+
+  def children_names
+    @children_names ||= ['anna', 'jack', 'rama', 'mia']
+  end
+
+  def children_ages
+    @children_ages ||= [12, 3, 6, 9]
+  end
+end
+
+class ASerializer
+  include Ixtlan::Babel::ModelSerializer
+  attributes :id, :name
+end
+
+class MethodsSerializer < ASerializer
+  attributes :age, :children_names, :children_ages
+end
+
+class PhoneSerializer
+  include Ixtlan::Babel::ModelSerializer
+  attributes :prefix, :number
+end
+
+class AddressSerializer
+  include Ixtlan::Babel::ModelSerializer
+  attributes :street, :zipcode
+end
+
+class NestedListSerializer < ASerializer
+  attribute :address, AddressSerializer
+  attribute :phone_numbers, Array[PhoneSerializer]
+end
+class AreaSerializer
+  include Ixtlan::Babel::ModelSerializer
+  attributes :code, :iso
+end
+
+class Phone2Serializer < PhoneSerializer
+  attribute :area, AreaSerializer
+end
+class DeepNestedSerializer < NestedListSerializer
+  attribute :phone_numbers, Array[Phone2Serializer]
+end
+
+describe Ixtlan::Babel::ModelSerializer do
+  let( :person ) do
+    Person.new( :id => 987,
+                :name => 'me and the corner',
+                :address => Address.new( :street => 'Foo 12',
+                                          :zipcode => '12345' ) )
+  end
+
+  it 'should serialize with methods' do
+    data = MethodsSerializer.new( person )
+    result = MultiJson.load(data.to_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 ] ]
+    data.id.must_equal person.id
+    data.name.must_equal person.name
+    data.age.must_equal person.age
+    data.children_ages.must_equal person.children_ages
+  end
+
+  it 'should serialize' do
+    data = ASerializer.new( person )
+    result = MultiJson.load(data.to_json)
+    result.must_equal Hash[ "id"=>"987", "name"=>"me and the corner" ]
+    data.id.must_equal person.id
+    data.name.must_equal person.name
+    data.age.must_equal person.age
+  end
+
+  it 'should serialize with nested list' do
+    data = NestedListSerializer.new( person )
+    result = MultiJson.load( data.to_json )
+    result.must_equal Hash[ "id"=>"987", "name"=>"me and the corner" ,
+                            "address"=> {
+                              "street"=>"Foo 12",
+                              "zipcode"=>"12345"
+                            },
+                            "phone_numbers"=> [ { "prefix"=>12,
+                                                  "number"=>"123" } ] ]
+    data.phone_numbers[0].prefix.must_equal result['phone_numbers'][0]['prefix']
+    data.phone_numbers[0].number.must_equal result['phone_numbers'][0]['number']
+  end
+
+  it 'should serialize and deserialize with nested include' do
+    data = DeepNestedSerializer.new( person )
+    result = MultiJson.load( data.to_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"
+                                                  }
+                                                } ] ]
+    data.phone_numbers[0].prefix.must_equal result['phone_numbers'][0]['prefix']
+    data.phone_numbers[0].number.must_equal result['phone_numbers'][0]['number']
+    data.phone_numbers[0].area.code.must_equal result['phone_numbers'][0]['area']['code']
+    data.phone_numbers[0].area.iso.must_equal result['phone_numbers'][0]['area']['iso']
+  end
+end