json_dumper 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79357d5f4525bea45352f2a0a4d12e256099254f
-  data.tar.gz: 3e6a651e6eadd83dbde1c5086580dca624e4cd47
+  metadata.gz: 03696b97e2c460ce88cba10d65eb5bba0110e301
+  data.tar.gz: 968d98f039debe2b33984d7a776fa69fa8d74292
 SHA512:
-  metadata.gz: b67062a0b892a32951eb9b53749b2ffc722829bf6d917ae8ff6944710e42121882f720c99f9820bf6c333a9b6777d7e9ee261994f72f149394f74fdfe0462c2c
-  data.tar.gz: 52290d5cb95766106bf0fbc290b3d13459dec136dc277a1535060cd5240f98d4fccda6fd671f9060102fb6571f53de500845e9a21af0b0947b509e12a86f77b1
+  metadata.gz: d824e295886e4c8aebf0b629e3b7c2955a56ece629adb3dd71e80ba75f90574646eba7443257abc10b065873a71d105573884b85b03e65699bd7bbc0c3f15e28
+  data.tar.gz: 61bc5d9e059167159815d436e781c11f2df87ea37a1160d4af59093c889b494d29f344eaef00ea34e0aa8214c8d12b45c93fb2dbee3b4562216a527e63b08ccb

data/README.md

@@ -1,6 +1,6 @@
 # JsonDumper
 
-Serialize Ruby into JSON.
+Serialize Ruby into JSON. Cleaner. Faster.
 
 This gem is intended to
 * help serialize Ruby objects and ActiveRecord objects into json
@@ -25,7 +25,171 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+Let's say you want to serialize Human object, which has many Cars.
+First define a class that is going to serialize Human:
+```
+class HumanJson < JsonDumper::Base
+  def preview
+    {
+      id: id,
+      first_name: first_name,
+      last_name: last_name,
+      born_at: created_at.strftime('%m/%d/%Y')
+    }
+  end
+end
+```
+you can call it like that:
+```
+john = Human.create(
+  first_name: 'John',
+  last_name: 'Doe',
+  created_at: 20.years.ago
+)
+
+json = HumanJson.preview(john)
+json == {
+  id: 1,
+  first_name: 'John',
+  last_name: 'Doe',
+  born_at: '09/19/1997'
+}
+```
+
+Whenever you invoke a method on a JsonDumper::Base instance and it is missing a similar method is invoked on the object you passed to the serializer.
+For example in the snippet above a method `id` is going to be called on `john` object.
+```
+{
+  id: id,
+  ...
+}
+```
+
+Let's introduce an association into the mix:
+```
+class CarJson < JsonDumper::Base
+  def preview
+    {
+      id: id,
+      name: name,
+    }
+  end
+end
+
+class HumanJson < JsonDumper::Base
+  # ...
+  def details
+    preview.merge(
+      car: CarJson.preview(car)
+    )
+  end
+end
+
+ferrari = Car.create(
+  name: 'Ferrari',
+)
+john.car = ferrari
+
+json = HumanJson.details(john)
+json == {
+  id: 1,
+  first_name: 'John',
+  last_name: 'Doe',
+  born_at: '09/19/1997',
+  car: {
+    id: 1,
+    name: 'Ferrari'
+  }
+}
+```
+
+This structure provides a very clean way to specify dependencies for ActiveRecord preloader:
+```
+class HumanJson < JsonDumper::Base
+  def preview
+    # ...
+  end
+
+  def preview_preload
+    {}
+  end
+
+  def details
+    # ...
+  end
+
+  def details_preload
+    preview_preload.merge(car: [])
+  end
+end
+```
+Furthermore you can omit defining `preview_preload` because JsonDumper returns empty hashes (`{}`) whenever a method does not exist and its name ends with `_preload`.
+
+You can utilize it in the following way:
+```
+preloader = ActiveRecord::Base::Preloader.new
+preloader.preload(john, HumanJson.details_preload)
+json = HumanJson.details(john)
+```
+Another cool feature that you can now do is to do both preloading and serialization in a single command via `fetch_METHOD_NAME`.
+This creates a special JsonDumper::Delayed object which delays its execution until it's time to render. This allows to do preloading at render time.
+
+Since this is a common operation you can include `JsonDumper::Base` in your controller.
+```
+class HumansController < ActionController::Base
+  include JsonDumper::Helper
+
+  def show
+    human = Human.find(params[:id])
+    json = dumper_json(
+      my_human: HumanJson.fetch_details(human)
+    )
+    render json: json
+  end
+
+  # OR
+
+  def show
+    human = Human.find(params[:id])
+    render_dumper_json(
+      my_human: HumanJson.fetch_details(human)
+    )
+  end
+end
+
+# going to render:
+{
+  myHuman: {
+    id: 1,
+    firstName: 'John',
+    lastName: 'Doe',
+    bornAt: '09/19/1997',
+    car: {
+      id: 1,
+      name: 'Ferrari'
+    }
+  }
+}
+```
+Take a note that `dumper_json` also camelizes your keys.
+
+### Usage with [Gon](https://github.com/gazay/gon)
+
+This gem also provides a seamless integration with Gon gem.
+The above example could be rewritten in the following way:
+```
+class HumansController < ActionController::Base
+  def show
+    human = Human.find(params[:id])
+    gon.my_human = HumanJson.fetch_details(human)
+  end
+end
+```
+
+Later in your javascript:
+```
+    console.log(gon.myHuman);
+```
 
 ## Development
 

data/lib/json_dumper/version.rb

@@ -1,3 +1,3 @@
 module JsonDumper
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json_dumper
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - therusskiy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-08-13 00:00:00.000000000 Z
+date: 2017-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord