userializer 0.1.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 176f64904bdd2aebe075ad93bb12ff1f900bdf5624b2a8a1c86001d7e9de497d
-  data.tar.gz: e7ca4ff8d4436e8880772f4e8c526137669b9993fdce4e87f23674d92ab071fd
+  metadata.gz: f3ef32ea4a17b463844f6c5f59453e206253c59c21735ea9aa6e97c353db2c3d
+  data.tar.gz: 77c4cdcba82ef5a5470da04db24e2984ae7754d8ba25593c0097470f3c0fdf65
 SHA512:
-  metadata.gz: 51e1b63bcd632e558169f670fef2c83a5360fc8c0cce079504088b0574c972050f523ffcc93b5f6fd3ce970e0bb7c20d9d9873a47ad7587051012b7b96853052
-  data.tar.gz: b9d61df410bf4d35d7f91d66fa439999c424164acf159990ca8105ed9795889e5619f3fa22b6cde3d8018a846dd9cd917caf6131334c257dd3027c3c0dd61873
+  metadata.gz: 4e48196e2d4264d655eb4da209e7635c56f4849eac2e977522379f358ccf7969cd6189bf3fe5675a721ef3ac9f2e89392099541189ef97f503a1ed1c0ea94f4f
+  data.tar.gz: d8a897a3e951c27488e700fb1f80385501367088219ab7b24505f1a7420b478f5171734f4641d319c9b8d9bf2a119407a8f2012c1bf4d5e6926709b33c99c7db

data/.circleci/config.yml

@@ -0,0 +1,18 @@
+version: 2
+jobs:
+  run_tests:
+    docker:
+      - image: circleci/ruby:2.7
+
+    working_directory: ~/userializer
+
+    steps:
+      - checkout
+      - run: bundle install --path=vendor/bundle
+      - run: bundle exec rspec --color --require spec_helper --format progress spec
+
+workflows:
+  version: 2
+  test:
+    jobs:
+      - run_tests

data/.gitignore

@@ -9,3 +9,4 @@
 
 # rspec failure tracking
 .rspec_status
+Gemfile.lock

data/README.md

@@ -20,7 +20,179 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+USerializer's DSL is relatively close to Active Model Serializer's,
+while having a few additional features including:
+* Attributes Conditional Declaration
+* Attributes Inline Definition
+
+### Attributes Conditional Declaration
+
+USerializer allows you to dynamically decide wether an attribute should
+be serialized or not by passing its definition an `if` block as follows:
+```ruby
+attributes :conditional_attr, if: proc { |_, opts| ... }
+```
+
+Eg: Let's say you want to serialize an `Order` object but want to
+include its `price` only if it's superior to *10*, your serializer
+would look like the following:
+```ruby
+class Order < ActiveRecord::Base
+  def price
+    10
+  end
+end
+
+class OrderSerializer < USerializer::BaseSerializer
+  attributes :price, if: proc do |obj, _|
+    obj.price > 10
+  end
+end
+```
+
+In that case for example, the `price` attribute would be omitted from
+the final response.
+
+### Attributes Inline Definition
+
+Using AMS, the only way to rewrite an attribute prior to serialization
+is to override it using a method with the same name, leading to
+something like this:
+```ruby
+class MyObject < ActiveRecord::Base
+  def random_attr
+    0
+  end
+end
+
+class MyObjectSerializer < ActiveModel::Serializer
+  attributes :random_attr
+
+  def random_attr
+    object.random_attr + 1
+  end
+end
+```
+
+While this code works perfectly, it pushes the serialized attribute
+value definition back from its declaration, causing developers to lose
+focus when listing their serialized attributes because the overriding is
+done farther.
+
+With USerializer, all of this is done in an inline way, so that you can
+override the attribute's value while declaring using a block as
+follows:
+```ruby
+attributes :your_attribute do |object, _|
+  ...
+end
+```
+
+Our `random_attr` serialization would then looks like this with
+USerializer:
+```ruby
+class MyObjectSerializer < USerializer::BaseSerializer
+  attributes :random_attr do |object, _|
+    object.random_attr + 1
+  end
+end
+```
+
+Way nicer, right?
+
+### Relationships
+
+Just like AMS, USerializer supports `has_one` and `has_many`
+relationships
+
+### Serialized Output
+
+The following outputs will be based an on our `Order` object in
+different situations:
+
+* Order is serialized without any relationships:
+```json
+{
+  "order": {
+    "id": 1,
+    "attr_1": "value_1",
+    "attr_2": "value_2",
+    "attr_3": "value_3",
+  }
+}
+```
+
+* Order has a `has_one` relationship with a `Client` model
+```json
+{
+  "clients": [
+    {
+      "id": 4,
+      "name": "userializer client",
+      ...
+    }
+  ],
+  "order": {
+    "id": 1,
+    "attr_1": "value_1",
+    "attr_2": "value_2",
+    "attr_3": "value_3",
+    "client_id": 4
+  }
+}
+```
+
+* Order has a `has_many` relationship with an `Article` model
+```json
+{
+  "articles": [
+    {
+      "id": 1,
+      "name": "Article #1",
+      ...
+    },
+    {
+      "id": 1,
+      "name": "Article #2",
+      ...
+    }
+  ],
+  "order": {
+    "id": 1,
+    "attr_1": "value_1",
+    "attr_2": "value_2",
+    "attr_3": "value_3",
+    "article_ids": [1, 2]
+  }
+}
+```
+
+### CompositeSerializer
+
+Imagine you have a compound of different data that you want to return to the same payload.
+For example, you have an **array** of a `Foo` class and a `Bar` value to return.
+You can use a `CompositeSerializer` to serialize both.
+
+```ruby
+array_foo = [Foo.new, Foo.new]
+bar = Bar.new
+
+CompositeSerializer.new(
+  { key_foo: array_foo, key_bar: bar },
+  each_serializer: { key_foo: FooCustomSerializer },
+  serializer: { key_bar: BarSerializer },
+  root: { key_foo: :foo_root, key_bar: :bar_root }
+).to_json
+```
+
+this will render:
+
+```json
+{
+  "foo_root": [{... foo1 attributes ...}, {... foo2 attributes ...}],
+  "bar_root": {... bar attributes ...}
+}
+```
 
 ## Development
 

data/lib/userializer.rb

@@ -1,6 +1,7 @@
 require 'userializer/version'
 require 'userializer/base_serializer'
 require 'userializer/array_serializer'
+require 'userializer/composite_serializer'
 
 module USerializer
   NS_SEPARATOR = '::'.freeze

data/lib/userializer/array_serializer.rb

@@ -19,14 +19,18 @@ module USerializer
         ActiveSupport::Inflector.underscore(obj_class.name).split('/').last
       ).to_sym if obj_class
 
-      @serializer = opts[:each_serializer] || USerializer.infered_serializer_class(
-        obj_class
-      )
+      serializer = opts[:each_serializer]
+
+      @serializer = if serializer&.is_a?(Proc)
+                      serializer
+                    elsif serializer
+                      proc { serializer }
+                    end
     end
 
     def merge_root(res, opts)
       @objs.each do |obj|
-        @serializer.new(obj, @opts).merge_root(res, @root_key, false, opts)
+        serializer(obj, opts).merge_root(res, @root_key, false, opts)
       end
     end
 
@@ -46,5 +50,14 @@ module USerializer
     end
 
     def scope; @opts[:scope]; end
+
+    private
+
+    def serializer(obj, opts)
+      return @serializer.call(obj, opts).new(obj, @opts) if @serializer
+      return obj.serialize if obj.respond_to?(:serialize)
+
+      USerializer.infered_serializer_class(obj.class).new(obj, @opts)
+    end
   end
 end

data/lib/userializer/base_serializer.rb

@@ -8,8 +8,8 @@ module USerializer
   class BaseSerializer
     class << self
       def inherited(subclass)
-        subclass.attrs = self.attrs || { id: Attribute.new(:id, {}, nil) }
-        subclass.relations = self.relations || {}
+        subclass.attrs = self.attrs.dup || { id: Attribute.new(:id, {}, nil) }
+        subclass.relations = self.relations.dup || {}
       end
 
       def attributes(*attrs, &block)

data/lib/userializer/composite_serializer.rb

@@ -0,0 +1,78 @@
+require 'oj'
+
+module USerializer
+  class CompositeObject
+    def initialize(obj, opts = {})
+      @obj = obj
+      @opts = opts
+      @root_key = opts[:root].to_sym
+      serializer = opts[:serializer]
+      @serializer = if serializer.is_a?(Proc)
+                      serializer
+                    elsif serializer
+                      proc { serializer }
+                    end
+    end
+
+    def merge_root(res, opts)
+      serializer(@obj, opts).merge_root(res, @root_key, true, opts)
+    end
+
+    private
+
+    def serializer(obj, opts)
+      return @serializer.call(obj, opts).new(obj, @opts) if @serializer
+      return obj.serialize if obj.respond_to?(:serialize)
+
+      USerializer.infered_serializer_class(obj.class).new(obj, @opts)
+    end
+  end
+
+  class CompositeSerializer
+    def initialize(objs, opts = {})
+      @opts = opts
+      @objs = compose_objs(objs)
+    end
+
+    def merge_root(res, opts)
+      @objs.each do |obj|
+        obj.merge_root(res, opts)
+      end
+    end
+
+    def to_hash
+      res = {}
+
+      merge_root(res, @opts)
+      res
+    end
+
+    def serialize(*_args)
+      to_hash
+    end
+
+    def to_json(*_args)
+      Oj.dump(to_hash, mode: :compat)
+    end
+
+    private
+
+    def compose_objs(objs)
+      objs.map do |(key, obj)|
+        opts = options_for(key)
+
+        if obj.is_a? Enumerable
+          ArraySerializer.new(obj, opts)
+        else
+          CompositeObject.new(obj, opts)
+        end
+      end
+    end
+
+    def options_for(key)
+      @opts.reduce({}) do |acc, (opt_key, values)|
+        acc.merge(opt_key.to_sym => values[key.to_sym])
+      end.compact.merge(root: key) { |_, x, y| x || y }
+    end
+  end
+end

data/lib/userializer/has_many.rb

@@ -8,21 +8,31 @@ module USerializer
       @opts = opts
       @id_key = "#{ActiveSupport::Inflector.singularize(key)}_ids".to_sym
 
+      @embed_key = opts[:embed_key] || :id
       @conditional_block = opts[:if] || proc { true }
     end
 
     def merge_attributes(res, ser, opts)
       return unless @conditional_block.call(ser.object, opts)
 
-      res[@id_key] = (ser.send(@key) || []).compact.map(&:id).compact
+      res[@id_key] = (entities(ser) || []).compact.map do |obj|
+        obj.nil? ? nil : obj.send(@embed_key)
+      end.compact
     end
 
     def merge_root(res, ser, opts)
-      objs = ser.send(@key) || []
+      objs = entities(ser) || []
 
       return if objs.empty? || !@conditional_block.call(ser.object, opts)
 
       ArraySerializer.new(objs, @opts).merge_root(res, opts)
     end
+
+    def entities(ser)
+      obj = ser.send(@key) || []
+      return obj unless @opts[:scope]
+
+      obj.send(@opts[:scope])
+    end
   end
 end

data/lib/userializer/has_one.rb

@@ -6,8 +6,15 @@ module USerializer
       @id_key = "#{key}_id".to_sym
       @root_key = opts[:root]&.to_sym
 
-      @serializer = opts[:serializer]
+      serializer = opts[:serializer]
 
+      @serializer = if serializer&.is_a?(Proc)
+                      @serializer = serializer
+                    elsif serializer
+                      proc { serializer }
+                    end
+
+      @embed_key = opts[:embed_key] || :id
       @conditional_block = opts[:if] || proc { true }
     end
 
@@ -17,7 +24,7 @@ module USerializer
       return unless @conditional_block.call(ser.object, opts)
 
       obj = ser.send(@key)
-      res[@id_key] = obj&.id
+      res[@id_key] = obj.nil? ? nil : obj.send(@embed_key)
     end
 
     def merge_root(res, ser, opts)
@@ -25,13 +32,13 @@ module USerializer
 
       return if obj.nil? || !@conditional_block.call(ser.object, opts)
 
-      serializer(obj).merge_root(res, root_key(obj), false, opts)
+      serializer(obj, opts).merge_root(res, root_key(obj), false, opts)
     end
 
     private
 
-    def serializer(obj)
-      return @serializer.new(obj, @opts) if @serializer
+    def serializer(obj, opts)
+      return @serializer.call(obj, opts).new(obj, @opts) if @serializer
       return obj.serialize if obj.respond_to?(:serialize)
 
       USerializer.infered_serializer_class(obj.class).new(obj, @opts)

data/lib/userializer/version.rb

@@ -1,3 +1,3 @@
 module USerializer
-  VERSION = "0.1.3"
+  VERSION = "0.3.0"
 end

data/userializer.gemspec

@@ -20,8 +20,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.16"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_dependency "oj"
   spec.add_dependency "activesupport"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: userializer
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Alexis Montagne
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-05-10 00:00:00.000000000 Z
+date: 2021-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -87,11 +87,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".circleci/config.yml"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
 - Gemfile
-- Gemfile.lock
 - README.md
 - Rakefile
 - bin/console
@@ -100,6 +100,7 @@ files:
 - lib/userializer/array_serializer.rb
 - lib/userializer/attribute.rb
 - lib/userializer/base_serializer.rb
+- lib/userializer/composite_serializer.rb
 - lib/userializer/has_many.rb
 - lib/userializer/has_one.rb
 - lib/userializer/version.rb
@@ -107,7 +108,7 @@ files:
 homepage: https://github.com/upfluence/userializer
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -122,9 +123,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Write a short summary, because RubyGems requires one.
 test_files: []

data/Gemfile.lock

@@ -1,50 +0,0 @@
-PATH
-  remote: .
-  specs:
-    userializer (0.1.3)
-      activesupport
-      oj
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    activesupport (5.2.3)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-    concurrent-ruby (1.1.5)
-    diff-lcs (1.3)
-    i18n (1.6.0)
-      concurrent-ruby (~> 1.0)
-    minitest (5.11.3)
-    oj (3.7.12)
-    rake (10.4.2)
-    rspec (3.8.0)
-      rspec-core (~> 3.8.0)
-      rspec-expectations (~> 3.8.0)
-      rspec-mocks (~> 3.8.0)
-    rspec-core (3.8.0)
-      rspec-support (~> 3.8.0)
-    rspec-expectations (3.8.3)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-mocks (3.8.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-support (3.8.0)
-    thread_safe (0.3.6)
-    tzinfo (1.2.5)
-      thread_safe (~> 0.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  bundler (~> 1.16)
-  rake (~> 10.0)
-  rspec (~> 3.0)
-  userializer!
-
-BUNDLED WITH
-   1.16.1