fast_serializer_ruby 0.2.1 → 0.6.3

data/lib/fast_serializer/json_model/array.rb

@@ -3,7 +3,11 @@
 module FastSerializer
   module JsonModel
     class Array < Relationship
-      def serialize(resources, params = {}, context = nil)
+      # @param resource [Object]
+      # @param params [Hash]
+      # @param context [Hash]
+      # @return [Array]
+      def serialize(resources, params, context)
         return if resources.nil?
 
         if @serializer_klass
@@ -13,7 +17,7 @@ module FastSerializer
         end
       end
 
-      def included?(_resources, _params = {}, context = nil)
+      def included?(*)
         true
       end
     end

data/lib/fast_serializer/json_model/attribute.rb

@@ -3,32 +3,126 @@
 module FastSerializer
   module JsonModel
     class Attribute < Node
-      def serialize(resource, params = {}, context = nil)
-        context ||= self
+      attr_accessor :mixin,
+                    :method_name,
+                    :method_arity,
+                    :cond,
+                    :cond_arity,
+                    :cond_method_name,
+                    :injected
 
-        if method.is_a?(Proc)
+      def initialize(*)
+        super
 
-          if method.arity.abs == 1
-            context.instance_exec(resource, &method)
-          else
-            context.instance_exec(resource, params, &method)
-          end
+        @mixin = nil
+        @method_name = nil
+        @injected = false
+        @cond_method_name = nil
+        @cond = nil
+        @cond = @opts[:if] || @opts[:unless] || @cond
 
-        else
-          resource.public_send(method)
-        end
+        init_with_proc if method.is_a?(Proc)
+        init_with_cond if !cond.nil? && cond.is_a?(Proc)
+      end
+
+      def injectable?
+        !mixin.nil?
       end
 
-      def included?(resource, params, context = nil)
-        return true if @opts[:if].nil? && @opts[:unless].nil?
+      def inject(context)
+        context.include(mixin)
+        self.injected = true
+      end
+
+      # @param resource [Object]
+      # @param params [Hash]
+      # @param context [Hash]
+      # @return [Object]
+      def serialize(resource, params, context)
+        can_execute_on_mixin = injected && !method_name.nil? && !context.nil?
 
-        cond = @opts[:if] || @opts[:unless]
+        val = if can_execute_on_mixin
+                call_method_on_context(context, method_name, method_arity, resource, params)
+              elsif method.is_a?(Proc)
+                call_proc_binding_to_context(context, method, method_arity, resource, params)
+              else
+                resource.public_send(method)
+              end
+
+        val.freeze
+
+        val
+      end
+
+      # @param resource [Object]
+      # @param params [Hash]
+      # @param context [Hash]
+      # @return [Boolean]
+      def included?(resource, params, context)
+        return true if cond.nil?
+
+        can_execute_on_mixin = injected && !cond_method_name.nil? && !context.nil?
+
+        res = if can_execute_on_mixin
+                call_method_on_context(context, cond_method_name, cond_arity, resource, params)
+              elsif cond.is_a?(Proc)
+                call_proc_binding_to_context(context, cond, cond_arity, resource, params)
+              else
+                context.public_send(cond)
+              end
 
-        res = context.instance_exec(resource, params, &cond)
         res = !res unless @opts[:unless].nil?
 
         res
       end
+
+      private
+
+      def init_with_cond
+        @cond_method_name = "__#{key}_cond__"
+        @cond_arity = cond.arity.abs
+        @mixin ||= Module.new
+
+        if RUBY_VERSION <= '2.5.0'
+          @mixin.redefine_method @cond_method_name, &cond
+        else
+          @mixin.define_method @cond_method_name, &cond
+        end
+      end
+
+      def init_with_proc
+        @method_name = "__#{key}__"
+        @method_arity = method.arity.abs
+        @mixin = Module.new
+
+        if RUBY_VERSION <= '2.5.0'
+          @mixin.redefine_method @method_name, &method
+        else
+          @mixin.define_method @method_name, &method
+        end
+      end
+
+      def call_proc_binding_to_context(context, prc, arity, resource, params)
+        case arity
+        when 1
+          context.instance_exec(resource, &prc)
+        when 2
+          context.instance_exec(resource, params, &prc)
+        when 0
+          context.instance_exec(&prc)
+        end
+      end
+
+      def call_method_on_context(context, method_name, arity, resource, params)
+        case arity
+        when 0
+          context.public_send(method_name)
+        when 1
+          context.public_send(method_name, resource)
+        when 2
+          context.public_send(method_name, resource, params)
+        end
+      end
     end
   end
 end

data/lib/fast_serializer/json_model/has_many_relationship.rb

@@ -3,16 +3,18 @@
 module FastSerializer
   module JsonModel
     class HasManyRelationship < Relationship
-      def serialize(resource, params = {}, context = nil)
+      # @param resource [Object]
+      # @param params [Hash]
+      # @return [Array<Hash>]
+      def serialize(resource, params, _context)
         collection = resource.public_send(method)
         return if collection.nil?
 
         if @serializer_klass
           @serializer_klass.new(collection, params).serializable_hash
         elsif @schema
-          collection.map { |resource| @schema.serialize_resource(resource, params) }
+          collection.map { |entry| @schema.serialize_resource(entry, params) }
         end
-
       end
     end
   end

data/lib/fast_serializer/json_model/has_one_relationship.rb

@@ -3,7 +3,10 @@
 module FastSerializer
   module JsonModel
     class HasOneRelationship < Relationship
-      def serialize(resource, params = {}, context = nil)
+      # @param resource [Object]
+      # @param params [Hash]
+      # @return [Hash]
+      def serialize(resource, params, _)
         relation = resource.public_send(method)
 
         if @serializer_klass

data/lib/fast_serializer/json_model/node.rb

@@ -5,17 +5,25 @@ module FastSerializer
     class Node
       attr_accessor :key, :method, :context
 
+      # @param key [String]
+      # @param method [String]
+      # @param opts [Hash]
       def initialize(key: nil, method: nil, opts: {}, **_)
-        @key = key
+        @key = key&.to_sym
         @method = method || key
         @opts = opts || {}
       end
 
-      def serialize(_resource, _params = {}, context = nil)
+      # @return [Boolean]
+      def injectable?
+        false
+      end
+
+      def serialize(_resource, _params, _context = nil)
         raise NotImplementedError
       end
 
-      def included?(_resource, _params = {}, context = nil)
+      def included?(_resource, _params, _context = nil)
         raise NotImplementedError
       end
     end

data/lib/fast_serializer/json_model/object.rb

@@ -5,27 +5,37 @@ module FastSerializer
     class Object < Node
       attr_accessor :attributes
 
-      def initialize(*args)
+      def initialize(args = {})
         super
         @attributes = {}
       end
 
+      # @param attribute [FastSerializer::JsonModel::Node]
       def add_attribute(attribute)
         attributes[attribute.key] = attribute
       end
 
-      def serialize(resource, params = {}, context = nil)
+      # @param resource [Object]
+      # @param params [Hash]
+      # @param context [Hash]
+      # @return [Hash]
+      def serialize(resource, params, context)
         return if resource.nil?
 
-        attributes.values.each_with_object({}) do |attribute, res|
-          next res unless attribute.included?(resource, params, context)
+        result = {}
+
+        attributes.each do |_, attribute|
+          next unless attribute.included?(resource, params, context)
 
           val = attribute.serialize(resource, params, context)
-          res[attribute.key] = val
+          result[attribute.key] = val
         end
+
+        result
       end
 
-      def included?(_resource, _params = {}, context = nil)
+      # @return [Boolean]
+      def included?(*)
         true
       end
     end

data/lib/fast_serializer/json_model/relationship.rb

@@ -5,22 +5,49 @@ module FastSerializer
     class Relationship < Attribute
       attr_accessor :serialization_schema
 
-      def initialize(key: nil, method: nil, opts: {}, serializer: nil, schema: nil)
+      # @param serializer [FastSerializer::Schema::Mixin]
+      # @param schema [FastSerializer::Schema]
+      def initialize(serializer: nil, schema: nil, **)
         super
+
         @serializer_klass = serializer
         @schema = schema
 
-        raise ArgumentError, "must provide serializer or schema" if @serializer_klass.nil? && @schema.nil?
+        if @serializer_klass.nil? && @schema.nil?
+          raise ArgumentError, 'must provide serializer or schema'
+        end
       end
 
+      # @param resource [Object]
+      # @param params [Hash]
+      # @param context [Hash]
+      # @return [Boolean]
       def included?(resource, params, context)
-        super(resource, params) && include_relation?(params)
+        super && include_relation?(params)
       end
 
+      # @param params [Hash]
+      # @return [Boolean]
       def include_relation?(params)
+        include?(params) && !exclude?(params)
+      end
+
+      # @param params [Hash]
+      # @return [Boolean]
+      def exclude?(params)
+        return false if params[:exclude].nil?
+        return false if params[:exclude].empty?
+
+        params[:exclude_index].key?(key)
+      end
+
+      # @param params [Hash]
+      # @return [Boolean]
+      def include?(params)
         return true if params[:include].nil?
+        return false if params[:include].empty?
 
-        params[:include].include?(key)
+        params[:include_index].key?(key)
       end
     end
   end

data/lib/fast_serializer/schema.rb

@@ -3,91 +3,125 @@
 require 'forwardable'
 
 module FastSerializer
-
   class Schema
-    attr_accessor :_root, :serialization_schema, :params
-
-    def initialize(params = {})
-      @root                 = nil
-      @serialization_schema = JsonModel::Object.new
-      @params               = (params || {}).symbolize_keys
-      @params[:self]        = self
-
-      if @params[:include]
-        if @params[:include].any?
-          @params[:include] = @params[:include].map(&:to_sym)
-        end
-      end
+    attr_reader :_root, :serialization_schema, :params, :strict
+
+    def initialize(params = {}, root = nil, strict = nil)
+      @root                   = root
+      @strict                 = strict || FastSerializer.config.strict
+      @serialization_schema   = FastSerializer::JsonModel::Object.new
+      @params                 = FastSerializer::Utils.symbolize_keys(params || {})
+      @params[:self]          = self
+      @params[:include_index] = {}
+      @params[:exclude_index] = {}
+
+      self.include = @params.delete(:include)
+      self.exclude = @params.delete(:exclude)
+    end
+
+    def include=(list)
+      return unless list
+      return if list.empty?
+
+      @params[:include]       = list.map(&:to_sym)
+      @params[:include_index] = @params[:include].map { |key| [key, nil] }.to_h
     end
 
-    # @param [Array] attribute_names
+    def exclude=(list)
+      return unless list
+      return if list.empty?
+
+      @params[:exclude]       = list.map(&:to_sym)
+      @params[:exclude_index] = @params[:exclude].map { |key| [key, nil] }.to_h
+    end
+
+    # Defines a list of attributes for serialization
+    #
+    # @param attribute_names [Array<String, Symbol>] a list of attributes to serialize
+    # each of these attributes value is fetched calling a corresponding method from a resource instance
+    # passed to the serializer
     def attributes(*attribute_names)
       attribute_names.each do |attribute_name|
-        serialization_schema.add_attribute JsonModel::Attribute.new(
-          key:    attribute_name,
-          method: attribute_name
+        serialization_schema.add_attribute(
+          JsonModel::Attribute.new(key: attribute_name, method: attribute_name)
         )
       end
     end
 
-    # @param [String] attribute_name
-    # @param [Hash] opts - attribute options
-    # @param [Proc] block - result is used as the attribute value
+    # Defines an attribute for serialization
+    #
+    # @param attribute_name [String, Symbol] an attribute name
+    # @param opts [Hash] attribute options
+    # @option opts [Proc] :if conditional clause. accepts a proc/lambda which has to return a boolean
+    # @option opts [Proc] :unless (see opts:if)
+    # @param block [Proc] result is used as the attribute value
+    #
     def attribute(attribute_name, opts = {}, &block)
-      serialization_schema.add_attribute JsonModel::Attribute.new(
-        key:    attribute_name,
-        method: block,
-        opts:   opts
+      serialization_schema.add_attribute(
+        JsonModel::Attribute.new(
+          key: attribute_name,
+          method: block,
+          opts: opts
+        )
       )
     end
 
-    # @param [String] attribute_name
-    # @param [Hash] opts - attribute options
+    # Defines an attribute for serialization
+    #
+    # @param attribute_name [String, Symbol] an attribute name
+    # @param opts [Hash] attribute options
+    # @option opts [Proc] :if conditional clause. accepts a proc/lambda which has to return a boolean
+    # @option opts [Proc] :unless (see opts:if)
+    # @option opts [FastSerializer::Schema::Mixin, nil] :serializer a serializer class with injected  module or a inherited class
+    # @option opts [FastSerializer::Schema] :schema
+    #
     def has_one(attribute_name, opts = {})
       serialization_schema.add_attribute JsonModel::HasOneRelationship.new(
-        key:        opts.delete(:key) || attribute_name,
-        method:     opts.delete(:method) || attribute_name,
-        opts:       opts,
-        schema:     opts.delete(:schema),
+        key: opts.delete(:key) || attribute_name,
+        method: opts.delete(:method) || attribute_name,
+        opts: opts,
+        schema: opts.delete(:schema),
         serializer: opts.delete(:serializer)
       )
     end
 
     alias belongs_to has_one
 
-    # @param [String] attribute_name
-    # @param [Hash] opts - attribute options
+    # @param attribute_name [String]
+    # @param opts [Hash] attribute options
     def has_many(attribute_name, opts = {})
-      serialization_schema.add_attribute JsonModel::HasManyRelationship.new(
-        key:        opts.delete(:key) || attribute_name,
-        method:     opts.delete(:method) || attribute_name,
-        opts:       opts,
-        schema:     opts.delete(:schema),
-        serializer: opts.delete(:serializer),
+      serialization_schema.add_attribute(
+        JsonModel::HasManyRelationship.new(
+          key: opts.delete(:key) || attribute_name,
+          method: opts.delete(:method) || attribute_name,
+          opts: opts,
+          schema: opts.delete(:schema),
+          serializer: opts.delete(:serializer)
+        )
       )
     end
 
     # @param [String] attribute_name
     # @param [Hash] opts - attribute options
     def list(attribute_name, opts = {})
-      serialization_schema.add_attribute JsonModel::Array.new(
-        key:        attribute_name,
-        method:     attribute_name,
-        opts:       opts,
-        schema:     opts.delete(:schema),
-        serializer: opts.delete(:serializer)
+      serialization_schema.add_attribute(
+        JsonModel::Array.new(
+          key: attribute_name,
+          method: attribute_name,
+          opts: opts,
+          schema: opts.delete(:schema),
+          serializer: opts.delete(:serializer)
+        )
       )
     end
 
     # @param [String] root_key - a key under which serialization result is nested
     def root(root_key)
-      self._root = root_key
+      @_root = root_key
     end
 
     def deep_copy
-      schema        = FastSerializer::Schema.new
-      schema.params = params
-      schema._root  = _root
+      schema = FastSerializer::Schema.new(params, _root, strict)
 
       serialization_schema.attributes.each do |key, attribute|
         schema.serialization_schema.attributes[key] = attribute
@@ -97,20 +131,33 @@ module FastSerializer
     end
 
     def serialize_resource(resource, params = {}, context = self)
-      _params_dup = self.params.merge(params).symbolize_keys
+      Utils.ref_merge(self.params, params)
+      _params_dup = FastSerializer::Utils.symbolize_keys(self.params)
       meta        = _params_dup.delete(:meta)
 
-      is_collection = resource.respond_to?(:size) && !resource.respond_to?(:each_pair)
+      is_collection = if _params_dup.key?(:is_collection)
+        _params_dup.delete(:is_collection)
+        params.delete(:is_collection)
+      else
+        resource.respond_to?(:each) && !resource.respond_to?(:each_pair)
+      end
+
+      root = (_root || _params_dup.delete(:root))
+
+      res = if is_collection
 
-      _serialization_schema = if is_collection
-                                JsonModel::Array.new(schema: serialization_schema)
-                              else
-                                serialization_schema
-                              end
+              if !context.is_a?(self.class)
+                # need to bind context
+                resource.map { |entry| context.class.new(entry, _params_dup).serializable_hash }
+              else
+                JsonModel::Array.new(schema: serialization_schema).serialize(resource, _params_dup, context)
+              end
 
-      res        = _serialization_schema.serialize(resource, _params_dup, context)
-      root       = (_root || _params_dup.delete(:root))
-      res        = { root => res } if root && !root.empty?
+            else
+              serialization_schema.serialize(resource, _params_dup, context)
+            end
+
+      res = { root => res } if root && !root.empty?
 
       res[:meta] = meta if res.is_a?(Hash) && meta
 
@@ -118,52 +165,7 @@ module FastSerializer
     end
 
     def serialize_resource_to_json(resource, params = {}, context = self)
-      FastSerializer.config.coder.dump(serialize_resource(resource, params))
-    end
-
-    module Mixin
-
-      module ClassMethods
-        attr_accessor :__schema__
-
-        def inherited(subclass)
-          subclass.__schema__ = self.__schema__.deep_copy
-        end
-
-        def method_missing(method, *args, &block)
-          if __schema__.respond_to?(method)
-            __schema__.public_send(method, *args, &block)
-          else
-            super
-          end
-        end
-      end
-
-      module InstanceMethods
-        attr_accessor :resource, :params
-
-        def initialize(resource, params = {})
-          self.resource = resource
-          self.params   = params || {}
-        end
-
-        def serializable_hash
-          self.class.__schema__.serialize_resource(resource, params, self)
-        end
-
-        def serialized_json
-          self.class.__schema__.serialize_resource_to_json(resource, params, self)
-        end
-
-        alias as_json serializable_hash
-        alias to_json serialized_json
-      end
-
-      def self.included(base)
-        base.extend ClassMethods
-        base.include InstanceMethods
-        base.__schema__ = FastSerializer::Schema.new
-      end
+      FastSerializer.config.coder.dump(serialize_resource(resource, params, context))
     end
   end
 end