ixtlan-babel 0.1.2 → 0.2.0

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

@@ -0,0 +1,111 @@
+require 'ixtlan/babel/config'
+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, 
+                       Config.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, config )
+        result = {}
+        data.each do |k,v|
+          k = k.to_s
+          case v
+          when Hash
+            result[ k ] = filter_data( v, config[ k ] ) if config.include?( k )
+          when Array
+            result[ k ] = filter_array( v, config[ k ] ) if config.include?( k )
+          else
+            result[ k ] = serialize( v ) if config.allowed?( k )
+          end
+        end
+        result
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+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 = {}, model = nil, &block)
+        if hash
+          filter_data( hash, 
+                       Config.new( options_for( hash ) ), 
+                       &block) 
+        end
+      end
+
+      def options_for( hash )
+        @options || (hash.is_a?(Array) ? collection_options : single_options)
+      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
+
+      class Config
+
+        def initialize( options )
+          @only = options[ :only ].collect { |o| o.to_s } if options[ :only ]
+          @except = ( options[:except] || [] ).collect { |e| e.to_s }
+
+          opts = options[ :include ]
+          @include =
+            case opts
+            when Array
+              opts.collect { |i| i.to_s }
+            when Hash
+              Hash[ opts.collect { |k,v| [ k.to_s, v ] } ]
+            else
+              []
+            end
+        end
+
+        def allowed?( key )
+          ( @only && @only.include?( key ) ) || ( @only.nil? && !@except.include?( key ) )
+        end
+
+        def include?( key )
+          @include.include? key
+        end
+
+        def []( key )
+          self.class.new( @include.is_a?( Array ) ? {} : @include[ key ] )
+        end
+      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, config )
+        result = {}
+        data.each do |k,v|
+          k = k.to_s
+          case v
+          when Hash
+            result[ k ] = filter_data( v, config[ k ] ) if config.include?( k )
+          when Array
+            result[ k ] = filter_array( v, config[ k ] ) if config.include?( k )
+          else
+            result[ k ] = serialize( v ) if config.allowed?( k )
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/ixtlan/babel/model_filter.rb

@@ -0,0 +1,53 @@
+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
+      end
+
+      private
+
+      def filter_array( models, options, &block )
+        models.collect do |i|
+          if i.respond_to? :attributes
+            filter_data(i, block.call(i), options, &block)
+          else
+            i
+          end
+        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
+        end
+      end
+
+      def filter_data(model, data, context, &block)
+        setup_data(model, data, context)
+        
+        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 )
+          else
+            result[ k ] = serialize( v ) if context.allowed?( k ) && ! v.respond_to?( :attributes )
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/ixtlan/babel/model_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