fast_serializer_ruby 0.1.4 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fb6eb91b6bb055330cdbc9c985ae9adcbabec5c0b03c201c5d2e131a58dbd7d
-  data.tar.gz: 3f2ecb8143d86959d6539e625aa606b101eda57c4d32ae1b38760184e5b63e6c
+  metadata.gz: 4226b5f0bc68c749226425f93db90d60bfe5b0cba0faa74a77e9cfd24680a73b
+  data.tar.gz: 697304fc0c88cdd9848c974027689c5eb4a0f90daa3e95fb4c2d2e723ceb8040
 SHA512:
-  metadata.gz: a895d4646f7f341411c7d52950ac9c28a34a809d5dc064ed4a9c7a26bf59527389596e3f9223a4e38aad21aba50a6b0d100e1132b2138f299c62b07ca0bdfef1
-  data.tar.gz: c8c237765f1c08cecf753483b878ecdb360fcdf03982a93270832872097389169030e22432a74f20f42b07b5e7e20b348f744235c8629921e28fd1521aab6a45
+  metadata.gz: ad76357998ec5b0de5768057e6dd6191f4cc8f7eba5dfc9170206245570ad725ba822f1bbf5d35dfed5364227f6dd28130aaadc70717158f42d80d906f76f98b
+  data.tar.gz: 2a43e81fe55e7d4a8dd56b56a489030d38f4d810564b332ee0f965b0d16b3152622a5aab97779dfa45b8cfe276640b16da6fd1eb7c81c4a629bbb82939ab6e05

data/.travis.yml

@@ -19,7 +19,6 @@ matrix:
 
 before_install:
   - gem update --system -N
-  - gem install bundler:2.0.2 -N
 
 before_script:
   - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    fast_serializer_ruby (0.1.4)
+    fast_serializer_ruby (0.2.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -76,7 +76,7 @@ schema.attribute(:id)
 schema.attribute(:email)
 schema.attribute(:full_name) { |resource| "#{resource.first_name} #{resource.last_name}"}
 schema.attribute(:phone)
-schema.has_one(:has_one_relationship, serializer: schema)
+schema.has_one(:has_one_relationship, schema: schema)
 
 schema.serializable_hash
 => {

data/lib/fast_serializer/json_model/array.rb

@@ -2,16 +2,18 @@
 
 module FastSerializer
   module JsonModel
-    class Array < HasManyRelationship
-      def serialize(resources, params = {})
+    class Array < Relationship
+      def serialize(resources, params = {}, context = nil)
         return if resources.nil?
 
-        resources.map do |resource|
-          serialization_schema.serialize(resource, params)
+        if @serializer_klass
+          @serializer_klass.new(resources, params).serializable_hash
+        elsif @schema
+          resources.map { |resource| @schema.serialize(resource, params, context) }
         end
       end
 
-      def included?(_resources, _params = {})
+      def included?(_resources, _params = {}, context = nil)
         true
       end
     end

data/lib/fast_serializer/json_model/attribute.rb

@@ -3,20 +3,28 @@
 module FastSerializer
   module JsonModel
     class Attribute < Node
-      def serialize(resource, params = {})
+      def serialize(resource, params = {}, context = nil)
+        context ||= self
+
         if method.is_a?(Proc)
-          method.arity.abs == 1 ? method.call(resource) : method.call(resource, params)
+
+          if method.arity.abs == 1
+            context.instance_exec(resource, &method)
+          else
+            context.instance_exec(resource, params, &method)
+          end
+
         else
           resource.public_send(method)
         end
       end
 
-      def included?(resource, params)
+      def included?(resource, params, context = nil)
         return true if @opts[:if].nil? && @opts[:unless].nil?
 
         cond = @opts[:if] || @opts[:unless]
 
-        res = cond.call(resource, params)
+        res = context.instance_exec(resource, params, &cond)
         res = !res unless @opts[:unless].nil?
 
         res

data/lib/fast_serializer/json_model/has_many_relationship.rb

@@ -3,13 +3,16 @@
 module FastSerializer
   module JsonModel
     class HasManyRelationship < Relationship
-      def serialize(resource, params = {})
+      def serialize(resource, params = {}, context = nil)
         collection = resource.public_send(method)
         return if collection.nil?
 
-        collection.map do |relation_resource|
-          serialization_schema.serialize(relation_resource, params)
+        if @serializer_klass
+          @serializer_klass.new(collection, params).serializable_hash
+        elsif @schema
+          collection.map { |resource| @schema.serialize_resource(resource, params) }
         end
+
       end
     end
   end

data/lib/fast_serializer/json_model/has_one_relationship.rb

@@ -3,8 +3,14 @@
 module FastSerializer
   module JsonModel
     class HasOneRelationship < Relationship
-      def serialize(resource, params = {})
-        serialization_schema.serialize(resource.public_send(method), params)
+      def serialize(resource, params = {}, context = nil)
+        relation = resource.public_send(method)
+
+        if @serializer_klass
+          @serializer_klass.new(relation, params).serializable_hash
+        elsif @schema
+          @schema.serialize_resource(relation, params)
+        end
       end
     end
   end

data/lib/fast_serializer/json_model/node.rb

@@ -3,7 +3,7 @@
 module FastSerializer
   module JsonModel
     class Node
-      attr_accessor :key, :method
+      attr_accessor :key, :method, :context
 
       def initialize(key: nil, method: nil, opts: {}, **_)
         @key = key
@@ -11,11 +11,11 @@ module FastSerializer
         @opts = opts || {}
       end
 
-      def serialize(_resource, _params = {})
+      def serialize(_resource, _params = {}, context = nil)
         raise NotImplementedError
       end
 
-      def included?(_resource, _params = {})
+      def included?(_resource, _params = {}, context = nil)
         raise NotImplementedError
       end
     end

data/lib/fast_serializer/json_model/object.rb

@@ -14,18 +14,18 @@ module FastSerializer
         attributes[attribute.key] = attribute
       end
 
-      def serialize(resource, params = {})
+      def serialize(resource, params = {}, context = nil)
         return if resource.nil?
 
         attributes.values.each_with_object({}) do |attribute, res|
-          next res unless attribute.included?(resource, params)
+          next res unless attribute.included?(resource, params, context)
 
-          val = attribute.serialize(resource, params)
-          res[attribute.key] = val if val
+          val = attribute.serialize(resource, params, context)
+          res[attribute.key] = val
         end
       end
 
-      def included?(_resource, _params = {})
+      def included?(_resource, _params = {}, context = nil)
         true
       end
     end

data/lib/fast_serializer/json_model/relationship.rb

@@ -5,12 +5,15 @@ module FastSerializer
     class Relationship < Attribute
       attr_accessor :serialization_schema
 
-      def initialize(key: nil, method: nil, opts: {}, serialization_schema:)
+      def initialize(key: nil, method: nil, opts: {}, serializer: nil, schema: nil)
         super
-        @serialization_schema = serialization_schema
+        @serializer_klass = serializer
+        @schema = schema
+
+        raise ArgumentError, "must provide serializer or schema" if @serializer_klass.nil? && @schema.nil?
       end
 
-      def included?(resource, params)
+      def included?(resource, params, context)
         super(resource, params) && include_relation?(params)
       end
 

data/lib/fast_serializer/schema.rb

@@ -1,168 +1,168 @@
 # frozen_string_literal: true
 
-module FastSerializer
-  class Schema
-    module InheritanceSupport
-      def inherited(subclass)
-        subclass._serialization_schema ||= JsonModel::Object.new
+require 'forwardable'
 
-        _serialization_schema.attributes.each do |key, attribute|
-          subclass._serialization_schema.attributes[key] = attribute
-        end
-      end
-    end
+module FastSerializer
 
-    module SchemaInterface
-      attr_accessor :_root, :_serialization_schema
+  class Schema
+    attr_accessor :_root, :serialization_schema, :params
 
-      def init
-        @_root ||= nil
-        @_serialization_schema ||= JsonModel::Object.new
-      end
+    def initialize(params = {})
+      @root                 = nil
+      @serialization_schema = JsonModel::Object.new
+      @params               = (params || {}).symbolize_keys
+      @params[:self]        = self
 
-      # @param [Array] attribute_names
-      def attributes(*attribute_names)
-        attribute_names.each do |attribute_name|
-          _serialization_schema.add_attribute JsonModel::Attribute.new(
-            key: attribute_name,
-            method: attribute_name
-          )
+      if @params[:include]
+        if @params[:include].any?
+          @params[:include] = @params[:include].map(&:to_sym)
         end
       end
+    end
 
-      # @param [String] attribute_name
-      # @param [Hash] opts - attribute options
-      # @param [Proc] block - 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
+    # @param [Array] attribute_names
+    def attributes(*attribute_names)
+      attribute_names.each do |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
-      def has_one(attribute_name, opts = {})
-        unless opts[:serializer]
-          raise ArgumentError, 'Serializer is not provided'
-        end
+    # @param [String] attribute_name
+    # @param [Hash] opts - attribute options
+    # @param [Proc] block - 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
+      )
+    end
 
-        serialization_schema = opts.delete(:serializer)._serialization_schema
-        _serialization_schema.add_attribute JsonModel::HasOneRelationship.new(
-          key: attribute_name,
-          method: attribute_name,
-          opts: opts,
-          serialization_schema: serialization_schema
-        )
-      end
+    # @param [String] attribute_name
+    # @param [Hash] opts - attribute options
+    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),
+        serializer: opts.delete(:serializer)
+      )
+    end
 
-      alias belongs_to has_one
+    alias belongs_to has_one
+
+    # @param [String] attribute_name
+    # @param [Hash] opts - 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),
+      )
+    end
 
-      # @param [String] attribute_name
-      # @param [Hash] opts - attribute options
-      def has_many(attribute_name, opts = {})
-        unless opts[:serializer]
-          raise ArgumentError, 'Serializer is not provided'
-        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)
+      )
+    end
 
-        serialization_schema = opts.delete(:serializer)._serialization_schema
-        _serialization_schema.add_attribute JsonModel::HasManyRelationship.new(
-          key: attribute_name,
-          method: attribute_name,
-          opts: opts,
-          serialization_schema: serialization_schema
-        )
-      end
+    # @param [String] root_key - a key under which serialization result is nested
+    def root(root_key)
+      self._root = root_key
+    end
 
-      # @param [String] attribute_name
-      # @param [Hash] opts - attribute options
-      def list(attribute_name, opts = {})
-        unless opts[:serializer]
-          raise ArgumentError, 'Serializer is not provided'
-        end
+    def deep_copy
+      schema        = FastSerializer::Schema.new
+      schema.params = params
+      schema._root  = _root
 
-        serialization_schema = opts.delete(:serializer)._serialization_schema
-        _serialization_schema.add_attribute JsonModel::Array.new(
-          key: attribute_name,
-          method: attribute_name,
-          opts: opts,
-          serialization_schema: serialization_schema
-        )
+      serialization_schema.attributes.each do |key, attribute|
+        schema.serialization_schema.attributes[key] = attribute
       end
 
-      # @param [String] root_key - a key under which serialization result is nested
-      def root(root_key)
-        self._root = root_key
-      end
+      schema
     end
 
-    module Serialization
-      attr_accessor :resource, :params
-
-      def initialize(resource, params = {})
-        init if respond_to?(:init)
-        @resource = resource
-        @params = (params || {}).symbolize_keys
-        @params[:self] = self
+    def serialize_resource(resource, params = {}, context = self)
+      _params_dup = self.params.merge(params).symbolize_keys
+      meta        = _params_dup.delete(:meta)
 
-        if @params[:include]
-          if @params[:include].empty?
-            @params.delete(:include)
-          else
-            @params[:include] = @params[:include].map(&:to_sym)
-          end
-        end
-      end
+      is_collection = resource.respond_to?(:size) && !resource.respond_to?(:each_pair)
 
-      def serializable_hash
-        meta = params.delete(:meta)
-        res = schema.serialize(resource, params)
+      _serialization_schema = if is_collection
+                                JsonModel::Array.new(schema: serialization_schema)
+                              else
+                                serialization_schema
+                              end
 
-        root = (_root || params.delete(:root))
+      res        = _serialization_schema.serialize(resource, _params_dup, context)
+      root       = (_root || _params_dup.delete(:root))
+      res        = { root => res } if root && !root.empty?
 
-        res = { root => res } if root && !root.empty?
+      res[:meta] = meta if res.is_a?(Hash) && meta
 
-        res[:meta] = meta if res.is_a?(Hash) && meta
+      res
+    end
 
-        res
-      end
+    def serialize_resource_to_json(resource, params = {}, context = self)
+      FastSerializer.config.coder.dump(serialize_resource(resource, params))
+    end
 
-      def serialized_json
-        FastSerializer.config.coder.dump(serializable_hash)
-      end
+    module Mixin
 
-      private
+      module ClassMethods
+        attr_accessor :__schema__
 
-      def schema
-        is_collection = resource.respond_to?(:size) && !resource.respond_to?(:each_pair)
+        def inherited(subclass)
+          subclass.__schema__ = self.__schema__.deep_copy
+        end
 
-        if is_collection
-          JsonModel::Array.new(serialization_schema: _serialization_schema)
-        else
-          _serialization_schema
+        def method_missing(method, *args, &block)
+          if __schema__.respond_to?(method)
+            __schema__.public_send(method, *args, &block)
+          else
+            super
+          end
         end
       end
-    end
 
-    include SchemaInterface
-    include Serialization
+      module InstanceMethods
+        attr_accessor :resource, :params
 
-    module Mixin
-      def _serialization_schema
-        self.class._serialization_schema
-      end
+        def initialize(resource, params = {})
+          self.resource = resource
+          self.params   = params || {}
+        end
 
-      def _root
-        self.class._root
+        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.include Serialization
-        base.extend InheritanceSupport
-        base.extend SchemaInterface
-
-        base.init
+        base.extend ClassMethods
+        base.include InstanceMethods
+        base.__schema__ = FastSerializer::Schema.new
       end
     end
   end

data/lib/fast_serializer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FastSerializer
-  VERSION = '0.1.4'
+  VERSION = '0.2.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fast_serializer_ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.1
 platform: ruby
 authors:
 - Evgeny Stepanov