ixtlan-babel 0.3.3 → 0.3.4

data/lib/ixtlan/babel/dm_validation_errors_serializer.rb

@@ -0,0 +1,8 @@
+require 'ixtlan/babel/serializer'
+class DataMapper::Validations::ValidationErrorsSerializer < Ixtlan::Babel::Serializer
+
+  def to_hash( o = nil)
+    @model_or_models.to_hash
+  end
+  
+end

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

@@ -0,0 +1,6 @@
+class DataMapper::Validations::ValidationErrorsSerializer < Ixtlan::Babel::Serializer
+  def to_hash( o = nil)
+    @model_or_models.to_hash
+  end
+  
+end

data/lib/ixtlan/babel/factory.rb

@@ -18,6 +18,7 @@
 # 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/dm_validation_errors_serializer' if defined? DataMapper
 module Ixtlan
   module Babel
     class Factory
@@ -56,7 +57,7 @@ module Ixtlan
       def new_serializer( resource )
         if resource.respond_to?(:model)
           model = resource.model
-        elsif resource.respond_to? :collect
+        elsif resource.respond_to?( :collect) && !resource.respond_to?( :to_hash)
           if resource.empty?
             return EmptyArraySerializer.new
           else

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

@@ -0,0 +1,95 @@
+#
+# 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.
+#
+module Ixtlan
+  module Babel
+    class Factory
+
+      NANOSECONDS_IN_DAY = 86400*10**6
+
+      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 ) ) + 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
+        end
+      end
+
+      def initialize(custom_serializers = {})
+        @map = DEFAULT_MAP.dup
+        @map.merge!(custom_serializers)
+      end
+
+      def add( clazz, &block )
+        @map[ clazz.to_s ] = block
+      end
+
+      def new_serializer( resource )
+        if resource.respond_to?(:model)
+          model = resource.model
+        elsif resource.respond_to?( :collect) && !resource.respond_to?( :to_hash)
+          if resource.empty?
+            return EmptyArraySerializer.new
+          else
+p resource
+p resource.class
+            r = resource.first
+            model = r.respond_to?( :model ) ? r.model : r.class
+p model
+          end
+        else
+          model = resource.class
+        end
+        ser = const_retrieve( "#{model}Serializer" ).new( resource )
+        ser.add_custom_serializers( @map )
+        ser
+      end
+
+      def new( resource )
+        warn 'DEPRECATED use new_serializer instead'
+        new_serializer( resource )
+      end
+
+      def new_filter( clazz )
+        const_retrieve( "#{clazz}Filter" ).new( clazz )
+      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/hash_filter.rb~

@@ -1,107 +1,58 @@
-require 'ixtlan/babel/config'
+#
+# 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
+    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( 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
+      def filter( data )
+        if data
+          filter_data( data, 
+                       Context.new( options ) )
         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
+            serialize( 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 )
+      def filter_data( data, context )
         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 )
+            result[ k ] = filter_data( v, context[ k ] ) if context.include?( k )
           when Array
-            result[ k ] = filter_array( v, config[ k ] ) if config.include?( k )
+            result[ k ] = filter_array( v, context[ k ] ) if context.include?( k )
           else
-            result[ k ] = serialize( v ) if config.allowed?( k )
+            result[ k ] = serialize( v ) if context.allowed?( k )
           end
         end
         result

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

@@ -1,166 +1,69 @@
+#
+# 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
-
-      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
+    class ModelFilter < AbstractFilter
+
+      def filter( model, &block )
+        if model
+          data = block.call( model )
+          filter_data( model, data,
+                       Context.new( options ),
+                       &block ) 
         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]}]
+      def filter_array( models, options, &block )
+        models.collect do |i|
+          if i.respond_to? :attributes
+            filter_data(i, block.call(i), options, &block)
           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)
+            serialize( i )
           end
+        end
+      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
+      def setup_data(model, data, context)
+        context.methods.each do |m|
+          unless data.include?(m)
+            data[ m ] = model.send( m.to_sym )
           end
         end
-        methods ||= []
+      end
+
+      def filter_data(model, data, context, &block)
+        setup_data(model, data, context)
+        
         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
+          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
-            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 ) && ! v.respond_to?( :attributes )
           end
         end
         result

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

@@ -0,0 +1,160 @@
+#
+# 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 'multi_json'
+require 'ixtlan/babel/hash_filter'
+require 'ixtlan/babel/model_filter'
+require 'ixtlan/babel/filter_config'
+module Ixtlan
+  module Babel
+    class Serializer
+
+      def id
+        if @model_or_models.is_a? Array
+          super
+        else
+          @model_or_models.id
+        end
+      end
+
+      def initialize(model_or_models)
+        @model_or_models = model_or_models
+      end
+      
+      def respond_to?(method)
+        @model_or_models.respond_to?(method)
+      end
+
+      def method_missing(method, *args, &block)
+        @model_or_models.send(method, *args, &block)
+      end
+      
+      def add_custom_serializers(map)
+        filter.add_custom_serializers(map)
+      end
+
+      private
+
+      def self.config
+        @config ||= FilterConfig.new
+      end
+
+      def filter
+        @filter ||= @model_or_models.is_a?( Hash ) ? HashFilter.new :  ModelFilter.new
+      end
+
+      protected
+
+      # for rails
+      def self.model(model = nil)
+        @model_class = model if model
+        @model_class ||= self.to_s.sub(/Serializer$/, '').constantize
+      end
+
+      # for rails
+      def self.model_name
+        model.model_name
+      end
+
+      def self.default_context_key(single = :single, collection = :collection)
+        config.default_context_key(single, collection)
+      end
+
+      def self.add_context(key, options = {})
+        config[key] = options
+      end
+
+      def self.root( root )
+        config.root = root
+      end
+
+      public
+
+      def use( context_or_options )
+        @context_or_options = context_or_options
+        self
+      end
+
+      def to_hash(options = nil)
+        setup_filter( options )
+        if collection?
+          @model_or_models.collect do |m|
+            filter_model( m )
+          end
+        else
+          filter_model( @model_or_models )
+        end
+      end
+
+      def to_json(options = nil)
+        to_hash(options).to_json
+      end
+
+      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.pluralize
+        end
+        result.to_xml :root => root
+      end
+
+      def to_yaml(options = nil)
+        to_hash(options).to_yaml
+      end
+      
+      protected
+
+      def attr(model)
+        model.attributes if model
+      end
+
+      private
+
+      def filter_model( model )
+        if root = filter.options[:root]
+          { root.to_s => filter.filter( model ){ |model| attr(model) } }
+        else
+          filter.filter( model ){ |model| attr(model) }
+        end
+      end 
+    end
+  end
+end

metadata

@@ -2,14 +2,14 @@
 name: ixtlan-babel
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 0.3.3
+  version: 0.3.4
 platform: ruby
 authors:
 - Christian Meier
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-02-28 00:00:00.000000000 Z
+date: 2013-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -117,6 +117,7 @@ files:
 - lib/ixtlan-babel.rb
 - lib/ixtlan/babel/deserializer.rb
 - lib/ixtlan/babel/hash_filter.rb
+- lib/ixtlan/babel/serializer.rb~
 - lib/ixtlan/babel/params_filter.rb
 - lib/ixtlan/babel/abstract_filter.rb
 - lib/ixtlan/babel/no_timestamp_serializer.rb
@@ -125,9 +126,12 @@ files:
 - lib/ixtlan/babel/context.rb
 - lib/ixtlan/babel/factory.rb
 - lib/ixtlan/babel/model_filter.rb~
+- lib/ixtlan/babel/dm_validation_errors_serializer.rb
 - lib/ixtlan/babel/hash_filter.rb~
 - lib/ixtlan/babel/filter_config.rb~
 - lib/ixtlan/babel/hash_only_filter.rb~
+- lib/ixtlan/babel/factory.rb~
+- lib/ixtlan/babel/dm_validation_errors_serializer.rb~
 - lib/ixtlan/babel/context.rb~
 - lib/ixtlan/babel/model_filter.rb
 - lib/ixtlan/babel/hash_filter.rb-