ixtlan-babel 0.1.2 → 0.2.0

data/lib/ixtlan/babel/factory.rb

@@ -2,6 +2,22 @@ module Ixtlan
   module Babel
     class Factory
 
+      NANOSECONDS_IN_DAY = Rational(1, 86400*10**9)
+
+      TIME_TO_S = Proc.new do |t|
+        t.strftime('%Y-%m-%dT%H:%M:%S.') + ("%06d" % t.usec) + t.strftime('%z')
+      end
+
+      DATE_TIME_TO_S = Proc.new do |dt|
+        dt.strftime('%Y-%m-%dT%H:%M:%S.') + ("%06d" % (dt.sec_fraction / NANOSECONDS_IN_DAY / 1000)) + dt.strftime('%z')
+      end
+      
+      DEFAULT_MAP = {
+        'DateTime' => DATE_TIME_TO_S,
+        'ActiveSupport::TimeWithZone' => TIME_TO_S,
+        'Time' => TIME_TO_S
+      }
+
       class EmptyArraySerializer < Array
         def use(arg)
           self
@@ -9,16 +25,7 @@ module Ixtlan
       end
 
       def initialize(custom_serializers = {})
-        @map = {}
-        add('DateTime') do |dt|
-          dt.strftime('%Y-%m-%dT%H:%M:%S.') + ("%06d" % (dt.sec_fraction / Date::NANOSECONDS_IN_DAY / 1000)) + dt.strftime('%z')
-        end
-        add('ActiveSupport::TimeWithZone') do |tz|
-          tz.strftime('%Y-%m-%dT%H:%M:%S.') + ("%06d" % tz.usec) + tz.strftime('%z')
-        end
-        add('Time') do |t|
-          t.strftime('%Y-%m-%dT%H:%M:%S.') + ("%06d" % t.usec) + t.strftime('%z')
-        end
+        @map = DEFAULT_MAP.dup
         @map.merge!(custom_serializers)
       end
 
@@ -29,7 +36,7 @@ module Ixtlan
       def new(resource)
         if resource.respond_to?(:model)
           model = resource.model
-        elsif resource.is_a? Array
+        elsif resource.respond_to? :collect
           if resource.empty?
             return EmptyArraySerializer.new
           else
@@ -39,10 +46,18 @@ module Ixtlan
         else
           model = resource.class
         end
-        ser = Object.const_get("#{model}Serializer").new(resource)
+        ser = const_retrieve("#{model}Serializer").new(resource)
         ser.add_custom_serializers(@map)
         ser
       end
+
+      def const_retrieve( const )
+        obj = Object
+        const.split(/::/).each do |part|
+          obj = obj.const_get( part )
+        end
+        obj
+      end
     end
   end
 end

data/lib/ixtlan/babel/filter_config.rb

@@ -0,0 +1,52 @@
+require 'ixtlan/babel/context'
+module Ixtlan
+  module Babel
+    class FilterConfig
+      
+      private
+
+      def context
+        @context ||= {}
+      end
+
+      def context_options( context_or_options )
+        if context_or_options
+          case context_or_options
+          when Symbol  
+            if opts = context[ context_or_options ]
+              opts.dup
+            end
+          when Hash
+            context_or_options
+          end
+        end
+      end
+
+      public
+
+      def default_context_key( single = :single, 
+                               collection = :collection )
+        @single, @collection = single, collection
+      end
+
+      def []=( key, options )
+        context[ key.to_sym ] = options if key
+      end
+
+      def []( key )
+        context[ key.to_sym ] if key
+      end
+
+      def single_options( context_or_options )
+        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]] || {}
+      end
+
+      attr_accessor :root
+
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+require 'ixtlan/babel/context'
+module Ixtlan
+  module Babel
+    class HashFilter
+
+      def initialize(context_or_options = nil)
+        use(context_or_options)
+      end
+      
+      private
+
+      def context
+        @context ||= {}
+      end
+
+      public
+
+      def add_custom_serializers( map )
+        @map = map
+      end
+
+      def default_context_key( single = :single, 
+                               collection = :collection )
+        @single, @collection = single, collection
+      end
+
+      def []=( key, options )
+        context[ key.to_sym ] = options if key
+      end
+
+      def []( key )
+        context[ key.to_sym ] if key
+      end
+
+      def use( context_or_options )
+        if context_or_options
+          case context_or_options
+          when Symbol  
+            if opts = context[ context_or_options ]
+              @options = opts.dup
+            end
+          when Hash
+            @options = context_or_options
+          end
+        else
+          @options = nil
+        end
+        self
+      end
+
+      def filter( hash = {} )
+        if hash
+          filter_data( hash, 
+                       Context.new( options_for( hash ) ) ) 
+        end
+      end
+        
+      def single_options
+        @options || context[default_context_key[0]] || {}
+      end
+
+      def collection_options
+        @options || context[default_context_key[1]] || {}
+      end
+
+      def root
+        @root ||= single_options.key?(:root) ? single_options[:root].to_s : nil
+      end
+
+      private
+
+      def options_for( hash )
+        @options || (hash.is_a?(Array) ? collection_options : single_options)
+      end
+
+      def filter_array( array, options )
+        array.collect do |item| 
+          if item.is_a?( Array ) || item.is_a?( Hash )
+            filter_data( item, options )
+          else
+            item
+          end
+        end
+      end
+
+      def serialize( data )
+        if @map && ser = @map[ data.class.to_s ]
+          ser.call(data)
+        else
+          data
+        end
+      end
+      
+      def filter_data( data, context )
+        result = {}
+        data.each do |k,v|
+          k = k.to_s
+          case v
+          when Hash
+            result[ k ] = filter_data( v, context[ k ] ) if context.include?( k )
+          when Array
+            result[ k ] = filter_array( v, context[ k ] ) if context.include?( k )
+          else
+            result[ k ] = serialize( v ) if context.allowed?( k )
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/ixtlan/babel/hash_filter.rb

@@ -1,144 +1,38 @@
+require 'ixtlan/babel/abstract_filter'
 module Ixtlan
   module Babel
-    class HashFilter
+    class HashFilter < AbstractFilter
 
-      def initialize(context_or_options = nil)
-        use(context_or_options)
-      end
-      
-      private
-
-      def context
-        @context ||= {}
-      end
-
-      public
-
-      def add_custom_serializers(map)
-        @map = map
-      end
-
-      def default_context_key(default = nil)
-        @default = default if default
-        @default
-      end
-
-      def []=(key, options)
-        context[key.to_sym] = options if key
-      end
-
-      def [](key)
-        context[key.to_sym] if key
-      end
-
-      def use(context_or_options)
-        if context_or_options
-          case context_or_options
-          when Symbol  
-            if opts = context[context_or_options]
-              @options = opts.dup
-            end
-          when Hash
-            @options = context_or_options
-          end
-        else
-          @options = nil
+      def filter( data )
+        if data
+          filter_data( data, 
+                       Context.new( options ) )
         end
-        self
-      end
-
-      NO_MODEL = Object.new
-      def NO_MODEL.send(*args)
-        self
-      end
-      def NO_MODEL.[](*args)
-        self
-      end
-
-      def filter(hash = {}, model = NO_MODEL, &block)
-        filter_data(model, hash, options, &block) if hash
-      end
-
-      def options
-        @options || context[default_context_key] || {}
       end
 
       private
 
-      def filter_data(model, data, options = {}, &block)
-        model = NO_MODEL if model == data
-        only = options[:only].collect { |o| o.to_s } if options[:only]
-        except = (options[:except] || []).collect { |e| e.to_s }
-
-        include =
-          case options[:include]
-          when Array
-            options[:include].collect { |i| i.to_s }
-          when Hash
-            Hash[options[:include].collect {|k,v| [k.to_s, v]}]
+      def filter_array( array, options )
+        array.collect do |item| 
+          if item.is_a?( Array ) || item.is_a?( Hash )
+            filter_data( item, options )
           else
-            []
-          end
-        if model != NO_MODEL
-          methods = (options[:methods] || []).collect { |e| e.to_s }
-          methods.each do |m|
-            data[m] = model.send(m.to_sym)
-          end
-
-          include_methods = include.is_a?(Array) ? include : include.keys 
-          include_methods.each do |m|
-            unless data.include?(m)
-              raise "no block given to calculate the attributes from model" unless block
-              models_or_model = model.send(m)
-              if models_or_model.respond_to?(:collect)
-                data[m] = models_or_model.collect { |i| block.call(i) }
-              else
-                data[m]= block.call(model.send(m))
-              end
-            end
+            item
           end
         end
-        methods ||= []
+      end
 
+      def filter_data( data, context )
         result = {}
         data.each do |k,v|
+          k = k.to_s
           case v
           when Hash
-            if include.include?(k.to_s)
-              case include
-              when Array
-                result[k.to_s] = filter_data(model.send(k), v, &block)
-              when Hash
-                result[k.to_s] = filter_data(model.send(k), v, include[k.to_s], &block)
-              end
-            end
+            result[ k ] = filter_data( v, context[ k ] ) if context.include?( k )
           when Array
-            if include.include?(k.to_s)
-              models = model.send(k)
-              j = -1
-              case include
-              when Array
-                result[k.to_s] = v.collect do |i| 
-                  j += 1
-                  if i.is_a?(Array) || i.is_a?(Hash)
-                    filter_data(models[j], i, &block)
-                  else
-                    i
-                  end
-                end
-              when Hash
-                opts = include[k]
-                result[k.to_s] = v.collect { |i| j += 1; filter_data(models[j], i, opts, &block) }
-              end
-            end
+            result[ k ] = filter_array( v, context[ k ] ) if context.include?( k )
           else
-            if methods.include?(k.to_s) || (only && only.include?(k.to_s)) || (only.nil? && !except.include?(k.to_s))
-              if @map && ser = @map[v.class.to_s]
-                result[k.to_s] = ser.call(v)
-              else
-                result[k.to_s] = v
-              end
-            end
+            result[ k ] = serialize( v ) if context.allowed?( k )
           end
         end
         result

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

@@ -0,0 +1,170 @@
+module Ixtlan
+  module Babel
+    class HashFilter
+
+      def initialize(context_or_options = nil)
+        use(context_or_options)
+      end
+      
+      private
+
+      def context
+        @context ||= {}
+      end
+
+      public
+
+      def add_custom_serializers(map)
+        @map = map
+      end
+
+      def default_context_key(single = :single, collection = :collection)
+        @single, @collection = single, collection
+      end
+
+      def []=(key, options)
+        context[key.to_sym] = options if key
+      end
+
+      def [](key)
+        context[key.to_sym] if key
+      end
+
+      def use(context_or_options)
+        if context_or_options
+          case context_or_options
+          when Symbol  
+            if opts = context[context_or_options]
+              @options = opts.dup
+            end
+          when Hash
+            @options = context_or_options
+          end
+        else
+          @options = nil
+        end
+        self
+      end
+
+      NO_MODEL = Object.new
+      def NO_MODEL.send(*args)
+        self
+      end
+      def NO_MODEL.[](*args)
+        self
+      end
+
+      def filter(hash = {}, model = NO_MODEL, &block)
+        filter_data(model, hash, hash.is_a?(Array) ? collection_options : single_options, &block) if hash
+      end
+
+      def single_options
+        @options || context[default_context_key[0]] || {}
+      end
+
+      def collection_options
+        @options || context[default_context_key[1]] || {}
+      end
+
+      def root
+        @root ||= single_options.key?(:root) ? single_options[:root].to_s : nil
+      end
+
+      private
+
+      def filter_data(model, data, options = {}, &block)
+        model = NO_MODEL if model == data
+        only = options[:only].collect { |o| o.to_s } if options[:only]
+        except = (options[:except] || []).collect { |e| e.to_s }
+
+        include =
+          case options[:include]
+          when Array
+            options[:include].collect { |i| i.to_s }
+          when Hash
+            Hash[options[:include].collect {|k,v| [k.to_s, v]}]
+          else
+            []
+          end
+        if model != NO_MODEL
+          methods = (options[:methods] || []).collect { |e| e.to_s }
+          methods.each do |m|
+            data[m] = model.send(m.to_sym)
+          end
+
+          include_methods = include.is_a?(Array) ? include : include.keys 
+          include_methods.each do |m|
+            unless data.include?(m)
+              raise "no block given to calculate the attributes from model" unless block
+              models_or_model = model.send(m)
+              if models_or_model.is_a?(Array) && models_or_model.first.is_a?(String)
+                data[m] = models_or_model
+              elsif models_or_model.respond_to?(:collect)
+                data[m] = models_or_model.collect { |i| block.call(i) }
+              else
+                val = model.send(m)
+                case val
+                when Fixnum
+                  data[m] = val
+                when String
+                  data[m] = val
+                when TrueClass
+                  data[m] = val
+                else
+                  data[m]= block.call(val)
+                end
+              end
+            end
+          end
+        end
+        methods ||= []
+        result = {}
+        data.each do |k,v|
+          case v
+          when Hash
+            if include.include?(k.to_s)
+              case include
+              when Array
+                result[k.to_s] = filter_data(model.send(k), v, &block)
+              when Hash
+                result[k.to_s] = filter_data(model.send(k), v, include[k.to_s], &block)
+              end
+            end
+          when Array
+            if include.include?(k.to_s)
+              models = model.send(k)
+              j = -1
+              case include
+              when Array
+                result[k.to_s] = v.collect do |i| 
+                  j += 1
+                  if i.is_a?(Array) || i.is_a?(Hash)
+                    filter_data(models[j], i, &block)
+                  else
+                    i
+                  end
+                end
+              when Hash
+                opts = include[k.to_s]
+                result[k.to_s] = v.collect do |i| 
+                  j += 1
+                  ndata = i.is_a?(Hash)? i : block.call(i)
+                  filter_data(models[j], ndata, opts, &block)
+                end
+              end
+            end
+          else
+            if methods.include?(k.to_s) || (only && only.include?(k.to_s)) || (only.nil? && !except.include?(k.to_s))
+              if @map && ser = @map[v.class.to_s]
+                result[k.to_s] = ser.call(v)
+              else
+                result[k.to_s] = v
+              end
+            end
+          end
+        end
+        result
+      end
+    end
+  end
+end