easy_serializer 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0cc2097011b0fa8a92990c2207848e77eae0891a
-  data.tar.gz: ea4d21a3fe3bf12dfdedd7b795b884962564a990
+  metadata.gz: 8c4bcd2510b26fd9bc5bce354fa24b8063ab3cd7
+  data.tar.gz: 6ad7cac70735ddc9ba2b5cec6285a04a8ef62f70
 SHA512:
-  metadata.gz: 80b141c0fb80d95525bcf0ae6b9b3335795fcf61ae6bcaff8c51b253ffd4650f277eb5f57f0be5ad0d50cf229bf0faf2f13a06e5ff65fb25e9fda1b921796f30
-  data.tar.gz: fea25e7aebe7a75967856269096a2f6ad84a049e236c1b6a88fefec005c15b5e7a024a03054d2593adbe3f451a34beb96a41a6c487e468fe1648d2eca47753af
+  metadata.gz: 8d7bedfffb05a5a67d7f6719cc6fdf2caea443d71506b227cdf10e840602516b1d8f92dcf86bcfcef5207953b42b60edc250e25b4cfd3f5cf7b5fc233139942e
+  data.tar.gz: 39425cec8ea178f8e7123483dceeac92b5790e277b7c7befa09feb4c11d950946459edcab9dc92ac1797444a7e372fa12b4299cc1e40ef1f973da20b0177a21a

data/README.md

@@ -5,8 +5,11 @@
 [![Test Coverage](https://codeclimate.com/github/arturictus/easy_serializer/badges/coverage.svg)](https://codeclimate.com/github/arturictus/easy_serializer/coverage)
 
 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
+simple solution for a day to day work with APIs.
+It tries to give you a serializer with flexibility, full of features and important capabilities for caching.
 
-features:
+Features:
 - Nice and simple serialization DSL.
 - Cache helpers to use with your favorite adapter like rails cache.
 
@@ -76,6 +79,8 @@ UserSerializer.call(user)
 ```
 **Using blocks:**
 
+Object being serialized is pass in the block as a first argument.
+
 ```ruby
 class UserSerializer < EasySerializer::Base
   attribute(:name) { |user| user.name.capitalize }
@@ -83,16 +88,70 @@ class UserSerializer < EasySerializer::Base
 end
 ```
 
+**Using helpers in blocks:**
+
+Blocks are executed in the serializer instance, this way you can build your helpers and use them inside the blocks.
+
+```ruby
+class BlockExample < EasySerializer::Base
+  attribute :name do |object|
+    upcase object.name
+  end
+
+  def upcase(str)
+    str.upcase
+  end
+end
+```
+
 **Changing keys:**
 
 ```ruby
 class UserSerializer < EasySerializer::Base
-  attribute :name, key: :named
-  attribute(:surname, key: :lastname) { |user| user.surname.capitalize }
+  attribute :name, key: :first_name
+  attribute(:surname, key: :last_name) { |user| user.surname.capitalize }
 end
 ```
 
-### Serializing attributes with serializer
+**Using defaults:**
+
+Default will only be triggered when value is `nil`
+
+```ruby
+obj = OpenStruct.new(name: 'Jack', boolean: nil, missing: nil)
+
+class DefaultLiteral < EasySerializer::Base
+  attribute :name
+  attribute :boolean, default: true
+  attribute(:missing, default: 'anything') { |obj| obj.missing }
+end
+
+output = DefaultLiteral.call(obj)
+output.fetch(:name) #=> 'Jack'
+output.fetch(:boolean) #=> true
+output.fetch(:missing) #=> 'anything'
+```
+
+Using blocks:
+
+```ruby
+obj = OpenStruct.new(name: 'Jack', boolean: nil, missing: nil)
+
+class DefaultBlock < EasySerializer::Base
+  attribute :name
+  attribute :boolean, default: proc { |obj| obj.name == 'Jack' }
+  attribute :missing, default: proc { |obj| "#{obj.name}-missing" } do |obj|
+    obj.missing
+  end
+end
+
+output = DefaultBlock.call(obj)
+output.fetch(:name) #=> 'Jack'
+output.fetch(:boolean) #=> true
+output.fetch(:missing) #=> 'Jack-missing'
+```
+
+### Serializing nested objects
 
 ```ruby
 user = OpenStruct.new(
@@ -110,7 +169,7 @@ end
 
 class UserSerializer < EasySerializer::Base
   attributes :name, :surname
-  collection :address, serializer: AddressSerializer
+  attribute :address, serializer: AddressSerializer
 end
 
 UserSerializer.call(user)
@@ -144,16 +203,39 @@ UserSerializer.call(user)
 }
 ```
 
-**Serializer option accepts a Proc:**
+**Serializer option accepts a Block:**
+
+The block will be executed in the Serializer instance.
 
 ```ruby
-class UserSerializer < EasySerializer::Base
-  attributes :name, :surname
-  attribute :address,
-            serializer: proc { |serializer| "#{serializer.klass_ins.name}Serializer" },
-            cache: true
+class DynamicSerializer < EasySerializer::Base
+  attribute :thing, serializer: proc { serializer_for_object }
+  attribute :d_name
+
+  def serializer_for_object
+    "#{object.class.name}Serializer".classify
+  end
 end
 ```
+Inside the block is yielded the value of the method
+
+```ruby
+thing = OpenStruct.new(name: 'rigoverto', serializer: 'ThingSerializer')
+obj = OpenStruct.new(d_name: 'a name', thing: thing)
+
+class DynamicWithContentSerializer < EasySerializer::Base
+  attribute :thing,
+            serializer: proc { |value| to_const value.serializer }
+            # => block will output ThingSerializer
+  attribute :d_name
+
+  def to_const(str)
+    Class.const_get str.classify
+  end
+end
+
+DynamicWithContentSerializer.call(obj)
+```
 
 ### Collection Example:
 
@@ -190,7 +272,7 @@ UserSerializer.call(user)
 
 **Caching the serialized object:**
 
-Serialization will happen only once and the result hash will be stored in the cache.
+Serialization will happen only once and the resulting hash will be stored in the cache.
 
 ```ruby
 class UserSerializer < EasySerializer::Base
@@ -210,7 +292,7 @@ class UserSerializer < EasySerializer::Base
 end
 ```
 
-of course it works with blocks:
+Of course it works with blocks:
 
 ```ruby
 class UserSerializer < EasySerializer::Base
@@ -221,6 +303,62 @@ class UserSerializer < EasySerializer::Base
 end
 ```
 
+Passing cache key:
+
+```ruby
+class UserSerializer < EasySerializer::Base
+  attribute(:costly_query, cache: true, cache_key: 'hello') do |user|
+    user.best_friends
+  end
+end
+```
+
+Passing cache key block:
+
+```ruby
+class UserSerializer < EasySerializer::Base
+  attribute(
+    :costly_query,
+    cache: true,
+    cache_key: proc { |object| [object, 'costly_query'] }
+    ) do |user|
+      user.best_friends
+  end
+end
+```
+
+Passing options to the cache:
+
+Any option passed in the cache method not specified for EasySerializer will be
+forwarded as options to the set Cache as options for the fetch method.
+
+example:
+
+```ruby
+class OptionForRootCache < EasySerializer::Base
+  cache true, expires_in: 10.minutes, another_option: true
+  attribute :name
+end
+```
+
+Cache fetch will receive:
+
+```ruby
+EasySerializer.cache.fetch(
+  key,# object or defined key
+  expires_in: 10.minutes,
+  another_option: true
+)
+```
+
+Use **cache_options** in attributes
+
+```ruby
+class OptionForAttributeCache < EasySerializer::Base
+  attribute :name, cache: true, cache_options: { expires_in: 10.minutes }
+end
+```
+
 **Caching Collections:**
 
 Cache will try to fetch the cached object in the collection **one by one, the whole collection is not cached**.
@@ -232,7 +370,7 @@ class UserSerializer < EasySerializer::Base
 end
 ```
 
-### Complex example using all features:
+### Complex example using all features
 
 ```ruby
 class PolymorphicSerializer < EasySerializer::Base
@@ -253,9 +391,8 @@ class PolymorphicSerializer < EasySerializer::Base
   collection :elements, serializer: ElementsSerializer, cache: true
 
   def serializer_for_subject
-    namespace = self.class.name.gsub(self.class.name.demodulize, '')
-    object_name = klass_ins.subject_type.demodulize
-    "#{namespace}#{object_name}Serializer".constantize
+    object_name = object.subject_type.demodulize
+    "#{object_name}Serializer".constantize
   end
 end
 ```

data/easy_serializer.gemspec

@@ -10,7 +10,9 @@ Gem::Specification.new do |spec|
   spec.email         = ["arturictus@gmail.com"]
 
   spec.summary       = %q{Semantic serializer for making easy serializing objects.}
-  spec.description   = %q{Semantic serializer for making easy serializing objects.}
+  spec.description   = %q{EasySerializer is inspired in ActiveModel Serializer > 0.10 it's a
+  simple solution for a day to day work with APIs.
+  It tries to give you a serializer with flexibility, full of features and important capabilities for caching.}
   spec.homepage      = "https://github.com/arturictus/easy_serializer"
   spec.license       = "MIT"
 

data/lib/easy_serializer.rb

@@ -12,4 +12,6 @@ module EasySerializer
   config_accessor(:cache)
 end
 
+require 'easy_serializer/helpers'
+require 'easy_serializer/cacher'
 require 'easy_serializer/base'

data/lib/easy_serializer/base.rb

@@ -1,9 +1,11 @@
 module EasySerializer
   class Base
+    include Helpers
+
     delegate :to_json, :[], to: :serialize
-    attr_reader :klass_ins
-    def initialize(klass_ins)
-      @klass_ins = klass_ins
+    attr_reader :object
+    def initialize(object)
+      @object = object
     end
 
     class << self
@@ -48,12 +50,12 @@ module EasySerializer
     private
 
     def _serialize
-      __serializable_attributes.each_with_object(HashWithIndifferentAccess.new) do |setup, object|
+      __serializable_attributes.each_with_object(HashWithIndifferentAccess.new) do |setup, hash|
         if setup[:key] === false
-          object.merge!(attr_serializer(setup))
+          hash.merge!(value_or_default(setup))
         else
           key = (setup[:key] ? setup[:key] : setup[:name])
-          object[key] = attr_serializer(setup)
+          hash[key] = value_or_default(setup)
         end
       end
     end
@@ -62,17 +64,7 @@ module EasySerializer
       return false unless EasySerializer.perform_caching
       cache = __cache
       return false unless cache
-      if cache[:block]
-        cache[:block].call(klass_ins, self)
-      else
-        key = if cache[:key]
-          cache[:key].call(klass_ins)
-        else
-          [klass_ins, 'EasySerialized']
-        end
-        fail "[Serializer] No key for cache" unless key
-        EasySerializer.cache.fetch(key) { _serialize }
-      end
+      Cacher.root_call(self, cache, object) { _serialize }
     end
 
     def __cache
@@ -83,53 +75,46 @@ module EasySerializer
       self.class.instance_variable_get(:@__serializable_attributes) || []
     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)
-      content = cache_or_attribute(klass_ins, setup)
-      return content unless serializer = setup[:serializer]
+      value = cache_or_attribute(setup)
+      return value unless serializer = setup[:serializer]
       if setup[:collection]
-        Array.wrap(content).map { |o|  cache_or_serialize(serializer, o, setup) }
+        Array.wrap(value).map { |o| cache_or_serialize(serializer, o, setup) }
       else
-        cache_or_serialize(serializer, content, setup)
+        cache_or_serialize(serializer, value, setup)
       end
     end
 
-    def cache_or_attribute(obj, setup)
+    def cache_or_attribute(setup)
       execute = setup[:block] || proc { |o| o.send(setup[:name]) }
-      if EasySerializer.perform_caching && setup[:cache] && !setup[:serializer]
-        EasySerializer.cache.fetch(obj, setup[:name]) { execute.call(obj) }
+      if EasySerializer.perform_caching && setup[:cache]
+        Cacher.call(self, setup, nil, &execute)
       else
-        execute.call(obj)
+        instance_exec object, &execute
       end
     end
 
-    def cache_or_serialize(serializer, content, opts)
-      return unless content
+    def cache_or_serialize(serializer, value, opts)
+      return unless value
       if EasySerializer.perform_caching && opts[:cache]
-        key = if opts[:cache_key]
-          opts[:cache_key].call(content)
-        else
-          [content, 'EasySerialized']
-        end
-        # Be Aware
-        # We are caching the serialized object
-        EasySerializer.cache.fetch(key) { send_to_serializer(serializer, content) }
+        Cacher.call(self, opts, value)
       else
-        send_to_serializer(serializer, content)
+        send_to_serializer(serializer, value)
       end
     end
 
-    def from_setup_serializer(serializer, content)
-      case serializer
-      when Proc
-        serializer.call(self, klass_ins, content)
-      else
-        serializer
-      end
-    end
 
-    def send_to_serializer(serializer, content)
-      return unless content
-      from_setup_serializer(serializer, content).new(content).serialize
+    def send_to_serializer(serializer, value)
+      return unless value
+      option_to_value(serializer, value).call(value)
     end
   end
 end

data/lib/easy_serializer/cacher.rb

@@ -0,0 +1,60 @@
+module EasySerializer
+  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
+    end
+
+    def value
+      return unless object && block
+      @value ||= serializer.instance_exec object, &block
+    end
+
+
+    def key
+      @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 execute
+      to_execute = if options[:serializer]
+        proc { serializer.send_to_serializer(options[:serializer], value) }
+      elsif !options[:serializer]
+        proc { serializer.instance_exec object, &block }
+      end
+      EasySerializer.cache.fetch(key, options_for_cache, &to_execute)
+    end
+  end
+end

data/lib/easy_serializer/helpers.rb

@@ -0,0 +1,17 @@
+module EasySerializer
+  module Helpers
+    def option_to_value(option, value, instance = nil)
+      inst = instance || self
+      case option
+      when Proc
+        inst.instance_exec value, &option
+        # TODO
+        # Will be nice to be able to add classes in the options responding to call
+        # for complex algorithms.
+        # when ->(opt) { opt.respond_to?(:call) }
+      else
+        option
+      end
+    end
+  end
+end

data/lib/easy_serializer/version.rb

@@ -1,3 +1,3 @@
 module EasySerializer
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: easy_serializer
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Artur Pañach
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-01-21 00:00:00.000000000 Z
+date: 2016-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,7 +66,10 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4.2'
-description: Semantic serializer for making easy serializing objects.
+description: |-
+  EasySerializer is inspired in ActiveModel Serializer > 0.10 it's a
+    simple solution for a day to day work with APIs.
+    It tries to give you a serializer with flexibility, full of features and important capabilities for caching.
 email:
 - arturictus@gmail.com
 executables: []
@@ -86,6 +89,8 @@ files:
 - easy_serializer.gemspec
 - lib/easy_serializer.rb
 - lib/easy_serializer/base.rb
+- lib/easy_serializer/cacher.rb
+- lib/easy_serializer/helpers.rb
 - lib/easy_serializer/version.rb
 homepage: https://github.com/arturictus/easy_serializer
 licenses: