ixtlan-babel 0.5.0 → 0.7.0

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

@@ -1,62 +1,171 @@
-#
-# Copyright (C) 2013 Christian Meier
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of
-# this software and associated documentation files (the "Software"), to deal in
-# the Software without restriction, including without limitation the rights to
-# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-# the Software, and to permit persons to whom the Software is furnished to do so,
-# subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-require 'ixtlan/babel/abstract_filter'
 module Ixtlan
   module Babel
-    class HashFilter < AbstractFilter
+    
+    module HashFilter
+
+      def self.included( model )
+        model.extend( ClassMethods )
+      end
 
       def filter( data )
-        if data
-          filter_data( data, 
-                       Context.new( options ) )
+        @attributes = do_filter( data, self.class.attributes )
+      end
+
+      def hidden( data )
+        @hidden = do_filter( data, self.class.hiddens )
+      end
+
+      def attributes
+        @attributes
+      end
+      alias :params :attributes
+
+      def new_model
+        if @class
+          @class.new( @attributes )
         end
       end
 
-      private
+      def respond_to? name
+        key = name.to_sym
+        self.class.hiddens.key?( key ) || self.class.attributes.key?( key ) || super
+      end
 
-      def filter_array( array, options )
-        array.collect do |item| 
-          if item.is_a?( Array ) || item.is_a?( Hash )
-            filter_data( item, options )
+      def method_missing( name, *args )
+        key = name.to_sym
+        if self.class.hiddens.key?( key )
+          to_attribute( key, 
+                        @hidden[ key ] || @hidden[ key.to_s ], 
+                        self.class.hiddens )
+        elsif self.class.attributes.key?( key )
+          to_attribute( key,
+                        @attributes[ key ] || @attributes[ key.to_s ],
+                        self.class.attributes )      
+        else
+          super
+        end
+      end
+
+      def to_attribute( key, v, ref )
+        case v
+        when Hash
+          ref[ key ].replace( v )
+        else
+          v
+        end
+      end
+
+      def do_filter( data, ref )
+        data.reject do |k,v|
+          case v
+          when Hash
+            if babel = ref[ k.to_sym ]
+              v.replace babel.replace( v ).attributes
+              false
+            else
+              true
+            end
+          when ::Array
+            if babel = ref[ k.to_sym ]
+              v.each do |vv|
+                vv.replace babel.replace( vv ).attributes
+              end
+              false
+            else
+              true
+            end        
           else
-            serialize( item )
+            not ref.member?( k.to_sym ) 
           end
         end
       end
+      
+      def initialize( clazz = nil )
+        super()
+        replace( {} )
+        @class = clazz
+      end
+
+      def replace( data )
+        data = deep_dup( data )
+        filter( data )
+        hidden( data )
+        self
+      end
+
+      private
 
-      def filter_data( data, context )
-        result = {}
+      def deep_dup( data )
+        data = data.dup
         data.each do |k,v|
-          k = k.to_s
-          case v
-          when Hash
-            result[ k ] = filter_data( v, context[ k ] ) if context.include?( k )
+          if v.is_a? Hash
+            data[ k ] = deep_dup( v )
+          end
+        end
+      end
+
+      module ClassMethods
+
+        def attribute( name, type = nil )
+          attributes[ name.to_sym ] = new_instance( type )
+        end
+
+        def hidden( name, type = nil )
+          hiddens[ 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 hiddens( *args )
+          if args.size == 0
+            @hiddens ||= (superclass.hiddens.dup rescue nil) || {}
+          else
+            args.each { |a| hidden( a ) }
+          end
+        end
+        
+        def new_instance( type )
+          case type
           when Array
-            result[ k ] = filter_array( v, context[ k ] ) if context.include?( k )
+            type[ 0 ].new
+          when NilClass
+            nil
           else
-            result[ k ] = serialize( v ) if context.allowed?( k )
+            type.new
           end
         end
-        result
       end
     end
   end
 end
+# class ModifiedBy
+#   include Babel::HashFilter
+
+#   attribute :id
+# end
+# User = ModifiedBy
+
+# class A
+#   include Babel::HashFilter
+
+#   attribute :id
+#   attribute :created_at, Array[User]
+#   hidden :updated_at
+#   attribute :modified_by, ModifiedBy
+
+# end
+
+# data =  {:a=>123, :id => 432, :created_at => [ {:id => 12, :name => 'asd' } ], :updated_at => 'asd', :modified_by => { :id => 342 } }
+# a = A.new.replace(data )
+# p a.attributes
+# p a
+# p a.updated_at
+# p a.id
+# p a.modified_by
+# p a.modified_by.id

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

@@ -1,73 +1,135 @@
-#
-# Copyright (C) 2013 Christian Meier
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of
-# this software and associated documentation files (the "Software"), to deal in
-# the Software without restriction, including without limitation the rights to
-# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-# the Software, and to permit persons to whom the Software is furnished to do so,
-# subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-require 'ixtlan/babel/abstract_filter'
 module Ixtlan
   module Babel
-    class ModelFilter < AbstractFilter
-
-      def filter( model, &block )
-        if model
-          data = block.call( model )
-          filter_data( model, data,
-                       Context.new( options ),
-                       &block ) 
-        end
+    
+    module ModelFilter
+
+      def self.included( model )
+        model.extend( ClassMethods )
       end
 
-      private
+      def respond_to? name
+        @model.respond_to? name
+      end
 
-      def filter_array( models, options, &block )
-        models.collect do |i|
-          if i.respond_to? :attributes
-            filter_data(i, block.call(i), options, &block)
-          else
-            serialize( i )
+      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
+        case @model
+        when Array
+          @model.collect do |m|
+            replace( m ).to_hash
           end
+        else
+          to_hash
         end
       end
 
-      def setup_data(model, data, context)
-        context.methods.each do |m|
-          unless data.include?(m)
-            data[ m ] = model.send( m.to_sym )
-          end
+      def serializers=( map )
+        @map = map
+      end
+
+      def serialize( data )
+        if @map && ser = @map[ data.class.to_s ]
+          ser.call( data )
+        else
+          data
         end
       end
 
-      def filter_data(model, data, context, &block)
-        setup_data(model, data, context)
-        
+      def to_hash
         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 )
-          elsif v.is_a? Array
-            result[ k ] = filter_array( v, context[ k ], &block ) if context.include?( k )
+        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( v ) if context.allowed?( k ) && ! v.respond_to?( :attributes )
+            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
+          @attributes ||= (superclass.attributes.dup rescue nil) || {}
+        end
+        
+        def new_instance( type )
+          case type
+          when Array
+            [ type[ 0 ].new ]
+          when NilClass
+            nil
+          else
+            type.new
+          end
+        end
+      end
     end
   end
 end
+
+# class User
+#   include Babel::ModelFilter
+
+#   attribute :id
+# end
+# class A
+#   include Babel::ModelFilter
+
+#   attribute :id
+#   attribute :created_at, Array[User]
+#   attribute :updated_at
+#   attribute :modified_by, User
+
+# end
+
+# class B
+#   attr_accessor :id, :created_at, :updated_at, :name, :modified_by
+# end
+
+# b = B.new
+# b.id = 123
+# require 'date'
+# b.updated_at = DateTime.now
+# b.name ='bla'
+# b.modified_by = B.new
+# b.modified_by.id = 432
+# b.modified_by.name = 'asd432'
+# b.created_at = [ b, b.modified_by]
+
+# require_relative 'factory'
+# a = A.new( b, Babel::Factory::DEFAULT_MAP )
+
+# p a
+# p a.to_hash
+
+# p a.id

data/lib/ixtlan/babel/model_serializer.rb

@@ -0,0 +1,103 @@
+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 ]
+          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