ixtlan-babel 0.1.2 → 0.2.0

data/lib/ixtlan/babel/no_timestamp_serializer.rb

@@ -4,13 +4,9 @@ module Ixtlan
     class NoTimestampSerializer < Serializer
       
       def self.add_defaults(root = nil)
-        if root
-          add_context(:default, :root => root)
-          add_no_timestamp_context(:collection, :root => root)
-        else
-          add_context(:default)
-          add_no_timestamp_context(:collection)
-        end
+        self.root root
+        add_context(:default)
+        add_no_timestamp_context(:collection)
       end
 
       def self.add_no_timestamp_context(key, options = {})

data/lib/ixtlan/babel/serializer.rb

@@ -1,4 +1,6 @@
 require 'ixtlan/babel/hash_filter'
+require 'ixtlan/babel/model_filter'
+require 'ixtlan/babel/filter_config'
 module Ixtlan
   module Babel
     class Serializer
@@ -29,12 +31,12 @@ module Ixtlan
 
       private
 
-      def self.filter
-        @filter ||= HashFilter.new
+      def self.config
+        @config ||= FilterConfig.new
       end
 
       def filter
-        @filter ||= self.class.filter.dup
+        @filter ||= @model_or_models.is_a?( Hash ) ? HashFilter.new :  ModelFilter.new
       end
 
       protected
@@ -50,29 +52,33 @@ module Ixtlan
         model.model_name
       end
 
-      def self.default_context_key(default)
-        filter.default_context_key(default)
+      def self.default_context_key(single = :single, collection = :collection)
+        config.default_context_key(single, collection)
       end
 
       def self.add_context(key, options = {})
-        filter[key] = options
+        config[key] = options
+      end
+
+      def self.root( root )
+        config.root = root
       end
 
       public
 
-      def use(context_or_options)
-        filter.use(context_or_options)
+      def use( context_or_options )
+        @context_or_options = context_or_options
         self
       end
 
       def to_hash(options = nil)
-        filter.use(filter.options.dup.merge!(options)) if options
-        if @model_or_models.respond_to?(:collect) && ! @model_or_models.is_a?(Hash)
+        setup_filter( options )
+        if collection?
           @model_or_models.collect do |m|
-            filter_model(attr(m), m)
+            filter_model( m )
           end
         else
-          filter_model(attr(@model_or_models), @model_or_models)
+          filter_model( @model_or_models )
         end
       end
 
@@ -80,13 +86,31 @@ module Ixtlan
         to_hash(options).to_json
       end
 
-      def to_xml(options = {})
-        opts = filter.options.dup.merge!(options)
-        root = opts.delete :root
-        fitler.use(opts)
+      def setup_filter(options)
+        o = if collection?
+              self.class.config.collection_options( @context_or_options )
+            else
+              self.class.config.single_options( @context_or_options )
+            end
+        filter.options = o.merge!( options || {} )
+        filter.options[:root] ||= self.class.config.root
+      end
+      private :setup_filter
+
+      def collection?
+        @is_collection ||= @model_or_models.respond_to?(:collect) && ! @model_or_models.is_a?(Hash)
+      end
+      private :collection?
+
+      def to_xml(options = nil)
+        setup_filter
+
         result = to_hash
+
+        root = config.root
+
         if root && result.is_a?(Array) && root.respond_to?(:pluralize)
-          root = root.to_s.pluralize
+          root = root.pluralize
         end
         result.to_xml :root => root
       end
@@ -103,11 +127,11 @@ module Ixtlan
 
       private
 
-      def filter_model(model, data)
+      def filter_model( model )
         if root = filter.options[:root]
-          {root.to_s => filter.filter(model, data){ |model| attr(model) } }
+          { root.to_s => filter.filter( model ){ |model| attr(model) } }
         else
-          filter.filter(model, data){ |model| attr(model) }
+          filter.filter( model ){ |model| attr(model) }
         end
       end 
     end

data/spec/hash_filter_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+class Hash
+  def attributes
+    self
+  end
+  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' => { 
+        '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) { Ixtlan::Babel::Deserializer.new(Hash) }
+
+  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']]
+  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']]
+  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')
+    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
+  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
+  end
+end

data/spec/model_filter_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+require 'virtus'
+
+class Address
+  include Virtus
+
+  attribute :street, String
+  attribute :zipcode, String
+end
+class Area
+  include Virtus
+
+  attribute :code, String
+  attribute :iso, String  
+end
+class PhoneNumber
+  include Virtus
+
+  attribute :prefix, Integer
+  attribute :number, String
+  attribute :area, Area
+end
+class Person
+  include Virtus
+
+  attribute :id, String
+  attribute :name, String
+  attribute :address, Address
+  attribute :phone_numbers, Array[PhoneNumber]
+end
+
+describe Ixtlan::Babel::ModelFilter do
+  let( :person ) do
+    Person.new(
+      :id => 987,
+      :name => 'me and the corner',
+      :address => Address.new( :street => 'Foo 12', :zipcode => '12345' ),
+      :phone_numbers => [PhoneNumber.new( 
+        :prefix => 12, 
+        :number => '123',
+        :area => Area.new( :code => '001', :iso => 'us' )
+      )]
+    )
+  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)
+    attributes = result.attributes.delete_if { |k,v| v.nil? }
+    attributes.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')
+    attributes = result.attributes.delete_if { |k,v| v.nil? }
+    attributes.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
+  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, :phone_numbers=>nil, :id => nil]
+    result = deserializer.from_json(json)  
+    result.attributes.must_equal Hash[:name => person['name'], :address=>nil, :phone_numbers=>nil, :id => nil]
+  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, :phone_numbers=>nil, :id => nil]
+    result = deserializer.from_json(json)
+    result.attributes.must_equal Hash[:name => person['name'], :address=>nil, :phone_numbers=>nil, :id => nil]
+  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.phone_numbers.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.phone_numbers.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' 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.phone_numbers.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.phone_numbers.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 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
+  end
+end

data/spec/model_filter_spec.rb~

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+class Hash
+  def attributes
+    self
+  end
+  def method_missing(method)
+    self[method.to_s]
+  end
+end
+
+describe Ixtlan::Babel do
+  let(:data) do
+    data = {
+      'id' => 987,
+      'name' => 'me and the corner',
+      'address' => { 'street' => 'Foo 12', 'zipcode' => '12345' },
+      '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) { Ixtlan::Babel::Deserializer.new(Hash) }
+
+  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']]
+  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']]
+  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')
+    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
+  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
+  end
+end