easy_serializer 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 358888cc7f61e9b3510147bbe505d1418225b41e
-  data.tar.gz: 2de0f0cda813e67bd51a10166da9b05a5d854f8b
+  metadata.gz: e23789313fd87585246d0510e59fa3c512d41587
+  data.tar.gz: c7bdfb7eb7f55d31f1e6a57e0009e713d88f5eb0
 SHA512:
-  metadata.gz: 09d793a662fb451a75f0a503361e62f1d38677f46e3297b432d31348f11d810c1c87dd88efbc00ff35177cde624189303273f3a730ec86c3c2d840f3f519b66c
-  data.tar.gz: 5855120cdba4d4eb42e77c7da6f0e25ab80225f62c9ada0cb19298cd09078c16c3126b66c7cf2766cce7bcd54cc905f2d4d05e6b1e6007d978fc9d83beaad568
+  metadata.gz: 19671f04e8fa2537334650ea8cc386932b38ac8e754c2d8b8fdfce9b6508b2f208f542ca6d7c81c47ceb59fc8d590b1bb6cb3034f713f44625fd72ad13951d75
+  data.tar.gz: 3a2aa87a28f38e80b90e1a5d91a90dcae99491af22513bd015cebcf72f8df3eb3cc17660f465f287f5cdcd31d54e18d9709d6ffb2905512e919797997fa36f4e

data/.coveralls.yml

@@ -0,0 +1,2 @@
+service_name: travis-ci
+repo_token: v9fcGs1CUZiWzFqYYpYYPAVTbxDbM6cm5

data/.travis.yml

@@ -1,4 +1,34 @@
+sudo: false
+cache: bundler
 language: ruby
 rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1
   - 2.1.6
-before_install: gem install bundler -v 1.10.4
+  - 2.2
+  - 2.3.0
+  - ruby-head
+  - jruby-19mode
+  - jruby-9.0.1.0
+  - rbx-3
+env:
+  # this doesn't do anything for MRI or RBX, but it doesn't hurt them either
+  # for JRuby, it enables us to get more accurate coverage data
+  - JRUBY_OPTS="--debug"
+matrix:
+  allow_failures:
+    - rvm: 1.9.3
+    - rvm: ruby-head
+    - rvm: rbx-3
+    - rvm: jruby-19mode
+    - rvm: jruby-9.0.1.0
+  fast_finish: true
+before_install: gem update --remote bundler
+install:
+  - bundle install --retry=3
+script:
+  - bundle exec rspec
+addons:
+  code_climate:
+    repo_token: 723c5d2fd0e1726d6efeea17ecd5aa22d0945a942ba3b21fdebc03f733359706

data/Gemfile

@@ -3,4 +3,6 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in easy_serializer.gemspec
 gemspec
 gem 'pry'
-gem 'simplecov', :require => false, :group => :test
+gem 'contextuable', '~> 0.4'
+gem 'coveralls', require: false
+gem "codeclimate-test-reporter", group: :test, require: false

data/README.md

@@ -1,8 +1,10 @@
 # EasySerializer
 
-[ ![Codeship Status for arturictus/easy_serializer](https://codeship.com/projects/5a101d20-6dda-0133-b7b2-666194911eaf/status?branch=master)](https://codeship.com/projects/115737)
-[![Code Climate](https://codeclimate.com/github/arturictus/easy_serializer/badges/gpa.svg)](https://codeclimate.com/github/arturictus/easy_serializer)
+[![Build Status](https://travis-ci.org/arturictus/easy_serializer.svg?branch=master)](https://travis-ci.org/arturictus/easy_serializer)
+[![Gem Version](https://badge.fury.io/rb/easy_serializer.svg)](https://badge.fury.io/rb/easy_serializer)
 [![Test Coverage](https://codeclimate.com/github/arturictus/easy_serializer/badges/coverage.svg)](https://codeclimate.com/github/arturictus/easy_serializer/coverage)
+[![Code Climate](https://codeclimate.com/github/arturictus/easy_serializer/badges/gpa.svg)](https://codeclimate.com/github/arturictus/easy_serializer)
+[![Issue Count](https://codeclimate.com/github/arturictus/easy_serializer/badges/issue_count.svg)](https://codeclimate.com/github/arturictus/easy_serializer)
 
 Semantic serializer for making easy serializing objects.
 EasySerializer is inspired in [ActiveModel Serializer > 0.10] (https://github.com/rails-api/active_model_serializers/tree/v0.10.0.rc3) it's a

data/lib/easy_serializer.rb

@@ -3,6 +3,7 @@ require 'active_support/all'
 
 module EasySerializer
   include ActiveSupport::Configurable
+  extend ActiveSupport::Autoload
 
   def self.setup
     yield self
@@ -10,9 +11,14 @@ module EasySerializer
 
   config_accessor(:perform_caching) { false }
   config_accessor(:cache)
-end
 
-require 'easy_serializer/helpers'
-require 'easy_serializer/cacher'
-require 'easy_serializer/attribute'
-require 'easy_serializer/base'
+  autoload :Helpers
+  autoload :Cacher
+  autoload :RootCacher
+  autoload :Attribute
+  autoload :AttributeSerializer
+  autoload :Base
+  autoload :CacheOutput
+  autoload :Field
+  autoload :Collection
+end

data/lib/easy_serializer/attribute.rb

@@ -1,60 +1,15 @@
 module EasySerializer
-  Attribute = Struct.new(:serializer, :setup) do
+  class Attribute < Field
     include Helpers
-    def self.call(serializer, setup)
-      new(serializer, setup).value
-    end
-
-    def object
-      serializer.object
-    end
-    def value
-      value_or_default
-    end
-
-    def value_or_default
-      value = attr_serializer
-      if value.nil? && setup[:default]
-        return option_to_value(setup[:default], object, serializer)
-      end
-      value
-    end
 
-    def attr_serializer
-      value = cache_or_attribute
-      return value.output if value.is_a?(CacheOutput)
-      return value unless serializer_class = setup[:serializer]
-      if setup[:collection]
-        Array.wrap(value).map { |o| serialize!(serializer_class, o) }
-      else
-        serialize!(serializer_class, value)
-      end
-    end
-    def send_name(obj)
-      obj.send(setup[:name])
+    def default?
+      options[:default]
     end
 
-    def cache_or_attribute
-      execute = setup[:block] || method(:send_name)
-      if EasySerializer.perform_caching && setup[:cache]
-        Cacher.call(serializer, setup, nil, &execute)
-      else
-        serializer.instance_exec object, &execute
-      end
+    def get_default(object, serializer)
+      return unless default?
+      option_to_value(options[:default], object, serializer)
     end
 
-    def send_to_serializer(serializer_class, value)
-      return unless value
-      option_to_value(serializer_class, value, serializer).call(value)
-    end
-
-    def serialize!(serializer_class, value)
-      return unless value
-      if EasySerializer.perform_caching && setup[:cache]
-        Cacher.call(serializer, setup, value)
-      else
-        send_to_serializer(serializer_class, value)
-      end
-    end
   end
 end

data/lib/easy_serializer/attribute_serializer.rb

@@ -0,0 +1,51 @@
+module EasySerializer
+  AttributeSerializer = Struct.new(:serializer, :metadata) do
+    include Helpers
+    def self.call(serializer, metadata)
+      new(serializer, metadata).value
+    end
+
+    def object
+      serializer.object
+    end
+
+    def value
+      value_or_default
+    end
+
+    def value_or_default
+      value = attr_serializer
+      # Check if value is nil
+      # eval option default ( in case is block)
+      if value.nil?
+        return metadata.get_default(object, serializer)
+      end
+      value
+    end
+
+    def attr_serializer
+      value = cache_or_attribute
+
+      return value.output if value.is_a?(CacheOutput)
+      return value unless metadata.nested_serializer?
+      if metadata.is_a? Collection
+        Array.wrap(value).map { |o| nested_serialization!(o) }
+      else
+        nested_serialization!(value)
+      end
+    end
+
+    def cache_or_attribute
+      if EasySerializer.perform_caching && metadata.catch?
+        Cacher.new(serializer, metadata).execute
+      else
+        serializer.instance_exec object, &metadata.get_value
+      end
+    end
+
+    def nested_serialization!(value)
+      return unless value
+      metadata.serialize!(value, serializer)
+    end
+  end
+end

data/lib/easy_serializer/base.rb

@@ -19,7 +19,7 @@ module EasySerializer
 
       def attribute(name, opts = {}, &block)
         @__serializable_attributes ||= []
-        @__serializable_attributes << { name: name, block: block }.merge(opts)
+        @__serializable_attributes << Attribute.new(name, opts, block)
       end
 
       def cache(bool, opts = {}, &block)
@@ -35,8 +35,8 @@ module EasySerializer
       end
 
       def collection(name, opts = {}, &block)
-        opts = opts.merge(collection: true)
-        attribute(name, opts, &block)
+        @__serializable_attributes ||= []
+        @__serializable_attributes << Collection.new(name, opts, block)
       end
     end
 
@@ -52,15 +52,19 @@ module EasySerializer
       option_to_value(serializer, value).call(value)
     end
 
+    def __cache
+      self.class.instance_variable_get(:@__cache)
+    end
+
     private
 
     def _serialize
-      __serializable_attributes.each_with_object({}) do |setup, hash|
-        if setup[:key] === false
-          hash.merge!(value_or_default(setup))
+      __serializable_attributes.each_with_object({}) do |metadata, hash|
+        if metadata.options[:key] === false
+          hash.merge!(value_or_default(metadata))
         else
-          key = (setup[:key] ? setup[:key] : setup[:name])
-          hash[key] = value_or_default(setup)
+          key = (metadata.options[:key] ? metadata.options[:key] : metadata.name)
+          hash[key] = value_or_default(metadata)
         end
       end
     end
@@ -69,62 +73,16 @@ module EasySerializer
       return false unless EasySerializer.perform_caching
       cache = __cache
       return false unless cache
-      Cacher.root_call(self, cache, object) { _serialize }.output
-    end
-
-    def __cache
-      self.class.instance_variable_get(:@__cache)
+      RootCacher.call(self){ _serialize }
     end
 
     def __serializable_attributes
       self.class.instance_variable_get(:@__serializable_attributes) || []
     end
 
-    def value_or_default(setup)
-      Attribute.call(self, setup)
+    def value_or_default(metadata)
+      AttributeSerializer.call(self, metadata)
     end
 
-    # def value_or_default(setup)
-    #   value = attr_serializer(setup)
-    #   if value.nil? && setup[:default]
-    #     return option_to_value(setup[:default], object)
-    #   end
-    #   value
-    # end
-    #
-    # def attr_serializer(setup)
-    #   value = cache_or_attribute(setup)
-    #   return value if value.respond_to?(:fetch) || value.respond_to?(:each)
-    #   return value unless serializer = setup[:serializer]
-    #   if setup[:collection]
-    #     Array.wrap(value).map { |o| cache_or_serialize(serializer, o, setup) }
-    #   else
-    #     cache_or_serialize(serializer, value, setup)
-    #   end
-    # end
-    #
-    # def cache_or_attribute(setup)
-    #   execute = setup[:block] || proc { |o| o.send(setup[:name]) }
-    #   if EasySerializer.perform_caching && setup[:cache]
-    #     Cacher.call(self, setup, nil, &execute)
-    #   else
-    #     if object.respond_to?(:each)
-    #       object.map { |o| instance_exec o, &execute }
-    #     else
-    #       instance_exec object, &execute
-    #     end
-    #   end
-    # end
-    #
-    # def cache_or_serialize(serializer, value, opts)
-    #   return unless value
-    #   if EasySerializer.perform_caching && opts[:cache]
-    #     Cacher.call(self, opts, value)
-    #   else
-    #     send_to_serializer(serializer, value)
-    #   end
-    # end
-
-
   end
 end

data/lib/easy_serializer/cache_output.rb

@@ -0,0 +1,3 @@
+module EasySerializer
+  CacheOutput = Struct.new(:output)
+end

data/lib/easy_serializer/cacher.rb

@@ -1,80 +1,31 @@
 module EasySerializer
-  CacheOutput = Struct.new(:output)
-  Cacher = Struct.new(:serializer) do
-    include Helpers
-
-    def self.call(serializer, options, value, &block)
-      Cacher.new(serializer)
-        .set(options: options, block: block, value: value)
-        .execute
-    end
-
-    def self.root_call(serializer, options, value, &block)
-      options[:cache_key] = options[:key]
-      options[:root_call] = true
-      call(serializer, options, value, &block)
-    end
-
-    attr_accessor :object, :options, :block
-    attr_writer :value
-
-    delegate :object, to: :serializer
-
-    def set(options)
-      options.each { |k, v| send("#{k}=", v) }
-      self
+  class Cacher
+    attr_reader :serializer, :metadata
+    def initialize(serializer, metadata)
+      @serializer = serializer
+      @metadata = metadata
     end
 
-    def value
-      return unless object && block
-      @value ||= serializer.instance_exec object, &block
-    end
-
-    def key(_value = nil)
-      _value ||= value
-      @key ||= if options[:cache_key]
-                 option_to_value(options[:cache_key], _value, serializer)
-               elsif options[:serializer] || options[:root_call]
-                 [_value, 'EasySerialized'].flatten
-               else
-                 [_value, options[:name], 'EasySerialized'].flatten
-               end
-    end
-
-    def options_for_cache
-      if options[:root_call]
-        options.except(:block, :cache_key, :root_call, :serializer, :key)
-      else
-        options[:cache_options]
-      end || {}
-    end
-
-    def _block_to_execute(_value = nil)
-      _value ||= value
-      if options[:serializer]
-        proc { serializer.send_to_serializer(options[:serializer], _value) }
-      else
-        proc { serializer.instance_exec object, &block }
-      end
-    end
-
-    def fetch(_key = nil, _value = nil)
-      _key ||= key
-      _value ||= value
-      EasySerializer.cache.fetch(_key, options_for_cache, &_block_to_execute(_value))
+    def execute
+      CacheOutput.new(_execute)
     end
 
-    def wrap(elem)
-      CacheOutput.new(elem)
-    end
+    private
 
-    def execute
-      elem = if options[:collection]
-        Array.wrap(value).map{ |o| fetch(key(o), o) }
-      else
-        fetch
-      end
-      wrap(elem)
+    def _execute
+      strategy = if metadata.is_a?(EasySerializer::Collection)
+                   Collection
+                 elsif metadata.serializer?
+                   Serializer
+                 else
+                   Method
+                 end
+      strategy.call(serializer, metadata)
     end
   end
 end
+
+require 'easy_serializer/cacher/template'
+require 'easy_serializer/cacher/collection'
+require 'easy_serializer/cacher/method'
+require 'easy_serializer/cacher/serializer'

data/lib/easy_serializer/cacher/collection.rb

@@ -0,0 +1,40 @@
+module EasySerializer
+  class Cacher
+    class Collection < Template
+
+      def execute
+        collection.map do |elem|
+          fetch(key(elem), elem)
+        end
+      end
+
+      def collection
+        @collection ||= serializer.instance_exec serializer.object, &metadata.get_value
+      end
+
+      def key(elem)
+        if metadata_key
+          [elem, metadata_key, nested_serializer.name]
+        else
+          [elem, nested_serializer.name]
+        end.flatten
+      end
+
+      def options
+        metadata.cache_options || {}
+      end
+
+      def block_to_get_value(elem)
+        proc { nested_serializer.call(elem) }
+      end
+
+      def nested_serializer
+        metadata.serializer(serializer.object, serializer)
+      end
+
+      def fetch(key, elem)
+        EasySerializer.cache.fetch(key, options, &block_to_get_value(elem))
+      end
+    end
+  end
+end

data/lib/easy_serializer/cacher/method.rb

@@ -0,0 +1,31 @@
+module EasySerializer
+  class Cacher
+    class Method < Template
+
+      def execute
+        fetch
+      end
+
+      def key
+        cache_key = if metadata.cache_key
+                      option_to_value(metadata.cache_key, serializer.object, serializer)
+                    else
+                      metadata.name
+                    end
+        [serializer.object, cache_key, serializer.class.name].flatten
+      end
+
+      def options
+        metadata.cache_options || {}
+      end
+
+      def block_to_get_value
+        proc { serializer.instance_exec serializer.object, &metadata.get_value }
+      end
+
+      def fetch
+        EasySerializer.cache.fetch(key, options, &block_to_get_value)
+      end
+    end
+  end
+end

data/lib/easy_serializer/cacher/serializer.rb

@@ -0,0 +1,38 @@
+module EasySerializer
+  class Cacher
+    class Serializer < Template
+
+      def execute
+        fetch
+      end
+
+      def key
+        if metadata_key
+          [value, metadata_key, nested_serializer.name]
+        else
+          [value, nested_serializer.name]
+        end.flatten
+      end
+
+      def options
+        metadata.cache_options || {}
+      end
+
+      def block_to_get_value
+        proc { metadata.serialize!(value, serializer) }
+      end
+
+      def value
+        serializer.instance_exec serializer.object, &metadata.get_value
+      end
+
+      def nested_serializer
+        metadata.serializer(serializer.object, serializer)
+      end
+
+      def fetch
+        EasySerializer.cache.fetch(key, options, &block_to_get_value)
+      end
+    end
+  end
+end

data/lib/easy_serializer/cacher/template.rb

@@ -0,0 +1,26 @@
+module EasySerializer
+  class Cacher
+    class Template
+      include Helpers
+      attr_reader :serializer, :metadata
+
+      def initialize(serializer, metadata)
+        @serializer = serializer
+        @metadata = metadata
+      end
+
+      def self.call(*args)
+        new(*args).execute
+      end
+
+      private
+
+      def metadata_key
+        return @metadata_key if defined?(@metadata_key)
+        @metadata_key = if metadata.cache_key
+          option_to_value(metadata.cache_key, serializer.object, serializer)
+        end
+      end
+    end
+  end
+end

data/lib/easy_serializer/collection.rb

@@ -0,0 +1,19 @@
+module EasySerializer
+  class Collection < Field
+    attr_reader :_options, :name, :block
+    def initialize(name, options, block)
+      @name = name
+      @_options = options
+      @block = block
+    end
+
+    def options
+      received_opts.merge(collection: true)
+    end
+
+    def received_opts
+      _options || {}
+    end
+
+  end
+end

data/lib/easy_serializer/field.rb

@@ -0,0 +1,51 @@
+module EasySerializer
+  Field = Struct.new(:name, :options, :block) do
+    include Helpers
+
+    def get_value
+      if block
+        block
+      else
+        method(:send_method)
+      end
+    end
+
+    def send_method(obj)
+      obj.send(name)
+    end
+
+    def catch?
+      options[:cache]
+    end
+
+    def serializer?
+      !!options[:serializer]
+    end
+    alias_method :nested_serializer?, :serializer?
+
+    def cache_options
+      options[:cache_options]
+    end
+
+    def cache_key
+      options[:cache_key]
+    end
+
+    def nested_serializer
+      @serializer
+    end
+
+    def serializer(object, serializer_instance)
+      return unless serializer?
+      option_to_value(options[:serializer], object, serializer_instance)
+    end
+    alias_method :nested_serializer=, :serializer
+
+    # Important!!! DO NOT memoize this method
+    def serialize!(object, serializer_instance)
+      serializer = serializer(object, serializer_instance)
+      return unless serializer
+      serializer.call(object)
+    end
+  end
+end

data/lib/easy_serializer/root_cacher.rb

@@ -0,0 +1,41 @@
+module EasySerializer
+  class RootCacher
+    include Helpers
+
+    def self.call(serializer, &block)
+      new(serializer, &block).execute
+    end
+
+    attr_reader :serializer, :block
+    def initialize(serializer, &block)
+      @serializer = serializer
+      @block = block
+    end
+
+    def execute
+      fetch
+    end
+
+    def object
+      serializer.object
+    end
+
+    def options
+      serializer.__cache.except(:block, :cache_key, :root_call, :serializer, :key)
+    end
+
+    def key
+      custom = serializer.__cache[:key]
+      if custom
+        option_to_value(custom, object, serializer)
+      else
+        [object, 'EasySerialized'].flatten
+      end
+    end
+
+    def fetch
+      EasySerializer.cache.fetch(key, options, &block)
+    end
+
+  end
+end

data/lib/easy_serializer/version.rb

@@ -1,3 +1,3 @@
 module EasySerializer
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: easy_serializer
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Artur Pañach
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-03-13 00:00:00.000000000 Z
+date: 2016-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -76,6 +76,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".coveralls.yml"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
@@ -89,9 +90,18 @@ files:
 - easy_serializer.gemspec
 - lib/easy_serializer.rb
 - lib/easy_serializer/attribute.rb
+- lib/easy_serializer/attribute_serializer.rb
 - lib/easy_serializer/base.rb
+- lib/easy_serializer/cache_output.rb
 - lib/easy_serializer/cacher.rb
+- lib/easy_serializer/cacher/collection.rb
+- lib/easy_serializer/cacher/method.rb
+- lib/easy_serializer/cacher/serializer.rb
+- lib/easy_serializer/cacher/template.rb
+- lib/easy_serializer/collection.rb
+- lib/easy_serializer/field.rb
 - lib/easy_serializer/helpers.rb
+- lib/easy_serializer/root_cacher.rb
 - lib/easy_serializer/version.rb
 homepage: https://github.com/arturictus/easy_serializer
 licenses:
@@ -113,7 +123,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.3
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Semantic serializer for making easy serializing objects.