userializer 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 176f64904bdd2aebe075ad93bb12ff1f900bdf5624b2a8a1c86001d7e9de497d
-  data.tar.gz: e7ca4ff8d4436e8880772f4e8c526137669b9993fdce4e87f23674d92ab071fd
+  metadata.gz: ffef1e179dd3b2b19e6a55f24edc24c691a0885aa6bcc0585e5600296d6697f8
+  data.tar.gz: 9f6bfe4b0203808dc37ba579ade7386b0025d6593721fb1a330298e79ee76f75
 SHA512:
-  metadata.gz: 51e1b63bcd632e558169f670fef2c83a5360fc8c0cce079504088b0574c972050f523ffcc93b5f6fd3ce970e0bb7c20d9d9873a47ad7587051012b7b96853052
-  data.tar.gz: b9d61df410bf4d35d7f91d66fa439999c424164acf159990ca8105ed9795889e5619f3fa22b6cde3d8018a846dd9cd917caf6131334c257dd3027c3c0dd61873
+  metadata.gz: 2f3e01d2b9dbd0324c21d8917b4e1f4bf2909ea73b7f6233ccbff2b3b61e35849b398dbed0bb3b82e140ce38934905c62213b492ee21856b2cc4551996035fad
+  data.tar.gz: 587444031cec4029296277202efa952b3785b9d3127908205fe0237d115b7fc0ecbd80b6f56533f282d99ec0b9f98bdca3012974377355dd0a9b0a1da6882e4a

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    userializer (0.1.3)
+    userializer (0.1.4)
       activesupport
       oj
 

data/README.md

@@ -20,7 +20,152 @@ 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]
+  }
+}
+```
 
 ## Development
 

data/lib/userializer/has_many.rb

@@ -8,13 +8,16 @@ 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] = (ser.send(@key) || []).compact.map do |obj|
+        obj.nil? ? nil : obj.send(@embed_key)
+      end.compact
     end
 
     def merge_root(res, ser, opts)

data/lib/userializer/has_one.rb

@@ -7,7 +7,7 @@ module USerializer
       @root_key = opts[:root]&.to_sym
 
       @serializer = opts[:serializer]
-
+      @embed_key = opts[:embed_key] || :id
       @conditional_block = opts[:if] || proc { true }
     end
 
@@ -17,7 +17,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)

data/lib/userializer/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: userializer
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Alexis Montagne
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-10 00:00:00.000000000 Z
+date: 2019-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler