ixtlan-babel 0.1.2 → 0.2.0

data/Gemfile.lock

@@ -6,15 +6,19 @@ PATH
 GEM
   remote: http://rubygems.org/
   specs:
+    backports (2.6.2)
     json_pure (1.6.1)
-    minitest (2.11.3)
-    rake (0.9.2.2)
+    minitest (4.3.2)
+    rake (10.0.2)
+    virtus (0.5.1)
+      backports (~> 2.6.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   ixtlan-babel!
-  json_pure (~> 1.6.1)
-  minitest (= 2.11.3)
-  rake (= 0.9.2.2)
+  json_pure (~> 1.6)
+  minitest (~> 4.3.0)
+  rake (~> 10.0.0)
+  virtus (~> 0.5.0)

data/README.md

@@ -1,4 +1,8 @@
-# vellam [![Build Status](https://secure.travis-ci.org/mkristian/babel.png)](http://travis-ci.org/mkristian/babel) #
+# babel #
+
+* [![Build Status](https://secure.travis-ci.org/mkristian/babel.png)](http://travis-ci.org/mkristian/babel) 
+* [![Dependency Status](https://gemnasium.com/mkristian/ixtlan-babel.png)](https://gemnasium.com/mkristian/ixtlan-babel)
+* [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/mkristian/ixtlan-babel)
 
 rails comes with `to_json` and `to_xml` on models and you can give them an option map to control how the whole object tree gets serialized.
 

data/lib/ixtlan/babel/abstract_filter.rb

@@ -0,0 +1,26 @@
+require 'ixtlan/babel/context'
+module Ixtlan
+  module Babel
+    class AbstractFilter
+
+      attr_accessor :options
+
+      def options
+        @options || {}
+      end
+        
+      def add_custom_serializers( map )
+        @map = map
+      end
+
+      def serialize( data )
+        if @map && ser = @map[ data.class.to_s ]
+          ser.call(data)
+        else
+          data
+        end
+      end
+      
+    end
+  end
+end

data/lib/ixtlan/babel/abstract_filter.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( data )
+        if data
+          filter_data( data, 
+                       Context.new( @options || {} ) )
+        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/config.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/context.rb

@@ -0,0 +1,43 @@
+module Ixtlan
+  module Babel
+    class Context
+
+      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
+        @methods = (options[:methods] || []).collect { |m| m.to_s }
+      end
+
+      def methods
+        @methods + ( @include.is_a?( Array ) ? @include : @include.keys ) 
+      end
+
+      def allowed?( key )
+        ( @only && @only.include?( key ) ) || ( @only.nil? && !@except.include?( key ) ) || @methods.include?( key )
+      end
+
+      def include?( key )
+        @include.include? key
+      end
+
+      def array?
+        @include.is_a?( Array )
+      end
+
+      def []( key )
+        self.class.new( @include.is_a?( Array ) ? {} : @include[ key ] )
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Ixtlan
+  module Babel
+    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
+        @methods = (options[:methods] || []).collect { |m| m.to_s }
+      end
+
+      def methods
+        @methods + ( @include.is_a?( Array ) ? @include : @include.keys ) 
+      end
+
+      def allowed?( key )
+        ( @only && @only.include?( key ) ) || ( @only.nil? && !@except.include?( key ) ) || @methods.include?( key )
+      end
+
+      def include?( key )
+        @include.include? key
+      end
+
+      def array?
+        @include.is_a?( Array )
+      end
+
+      def []( key )
+        self.class.new( @include.is_a?( Array ) ? {} : @include[ key ] )
+      end
+
+    end
+  end
+end

data/lib/ixtlan/babel/deserializer.rb

@@ -8,46 +8,48 @@ module Ixtlan
 
       private
 
-      def self.filter
-        @filter ||= HashFilter.new
+      def self.config
+        @config ||= FilterConfig.new
       end
 
       def filter
-        @filter ||= self.class.filter.dup
+        @filter ||= HashFilter.new
       end
 
       protected
 
       def self.default_context_key(default)
-        filter.default_context_key(default)
+        config.default_context_key(default)
       end
 
       def self.add_context(key, options = {})
-        filter[key] = options
+        config[key] = options
       end
 
       public
 
       def use(context_or_options)
-        filter.use(context_or_options)
+        @context_or_options = context_or_options
         self
       end
+      
+      def from_array_hash( data )
+        if filter.options[:root]
+          data.collect{ |d| @model_class.new( filter.filter( d[ filter.options[:root] ] ) ) }
+        else
+          data.collect{ |d| @model_class.new( filter.filter( d ) ) }
+        end
+      end
+      private :from_array_hash
 
       def from_hash(data, options = nil)
-        filter.use(options) if options
-        if root = filter.options[:root]
-          if data.is_a? Array
-            root = root.to_s
-            data.collect{ |d| @model_class.new(filter.filter(d[root])) }
-          else
-            @model_class.new(filter.filter(data[root.to_s]))
-          end
+        filter.options = options || {}
+        filter.options[:root] ||= self.class.config.root
+        if data.is_a? Array
+          from_array_hash( data )
         else
-          if data.is_a? Array
-            data.collect{ |d| @model_class.new(filter.filter(d)) }
-          else
-            @model_class.new(filter.filter(data))
-          end
+          data = data[ filter.options[:root] ] if filter.options[:root]
+          @model_class.new( filter.filter( data ) )
         end
       end