json_dumper 0.1.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 79357d5f4525bea45352f2a0a4d12e256099254f
-  data.tar.gz: 3e6a651e6eadd83dbde1c5086580dca624e4cd47
+SHA256:
+  metadata.gz: 45c60574d6e74355f5780187c67dffaa8dbec10c66f7daf3333716a314fb2fd9
+  data.tar.gz: b38572d61598229c78cea6383aaea4b42fecb1881fc93833c088dcbf74a990af
 SHA512:
-  metadata.gz: b67062a0b892a32951eb9b53749b2ffc722829bf6d917ae8ff6944710e42121882f720c99f9820bf6c333a9b6777d7e9ee261994f72f149394f74fdfe0462c2c
-  data.tar.gz: 52290d5cb95766106bf0fbc290b3d13459dec136dc277a1535060cd5240f98d4fccda6fd671f9060102fb6571f53de500845e9a21af0b0947b509e12a86f77b1
+  metadata.gz: 4af873d7fc123e0cf8aa027183a688d2fa555b9f6b709e42504b6da0b1845e3326e5a7e7ce4cedabee4d0f931f8899b11552304154a779d395f4fc11e8e9b7e2
+  data.tar.gz: b2352afdd41c7e496188d1503bc3c32b789683ec76ad577bef34cfb2ac1268ebfaad913bfeba0b9df887dd936ae8ef1cd5e0c365fb95b7635867e4810302ec80

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
 
@@ -42,3 +206,7 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/therus
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
 
+## Related blogpost
+
+Check it out [here](http://www.dmitry-ishkov.com/2017/08/better-ruby-serialization-into-json.html)
+

data/lib/json_dumper.rb

@@ -1,6 +1,7 @@
 require "json_dumper/version"
 require "json_dumper/key_transformer"
 require "json_dumper/dumper_hash"
+require "json_dumper/dumper_array"
 require "json_dumper/delayed"
 require "json_dumper/base"
 require "json_dumper/helper"

data/lib/json_dumper/base.rb

@@ -7,12 +7,12 @@ module JsonDumper
       self.entity = entity
     end
 
-    def self.method_missing(name, *args, &block)
+    def self.method_missing(name, *args1, **args2, &block)
       name_sym = name
       name = name.to_s
-      value = args[0]
+      value = args1[0]
       if name.start_with?('fetch_')
-        return Delayed.new(name.gsub('fetch_', ''), value, args[1..-1], self)
+        return Delayed.new(name.gsub('fetch_', ''), value, args1[1..-1], args2, self)
       end
       if instance.respond_to?(name)
         if value.respond_to?(:each) && !value.respond_to?(:each_pair)
@@ -21,7 +21,16 @@ module JsonDumper
             if new_dumper.return_nils
               return nil
             end
-            result = DumperHash.new(new_dumper.send(name, *(args[1..-1]), &block))
+            result = if args2.empty?
+                       new_dumper.send(name, *(args1[1..-1]), &block)
+                     else
+                       new_dumper.send(name, *(args1[1..-1]), **args2, &block)
+                     end
+            if result.respond_to?(:each) && !result.respond_to?(:each_pair)
+              result = DumperArray.new(result)
+            else
+              result = DumperHash.new(result)
+            end
             preload_method_name = "#{name}_preload"
             result.preload = instance.respond_to?(preload_method_name) ? instance.send(preload_method_name) : {}
             result
@@ -33,7 +42,17 @@ module JsonDumper
           if new_dumper.return_nils
             return nil
           end
-          result = DumperHash.new(new_dumper.send(name, *(args[1..-1]), &block))
+          result = if args2.empty?
+                     new_dumper.send(name, *(args1[1..-1]), &block)
+                   else
+                     new_dumper.send(name, *(args1[1..-1]), **args2, &block)
+                   end
+          if result.respond_to?(:each) && !result.respond_to?(:each_pair)
+            result = DumperArray.new(result)
+          else
+            result = DumperHash.new(result)
+          end
+
           preload_method_name = "#{name}_preload"
           result.preload = instance.respond_to?(preload_method_name) ? instance.send(preload_method_name) : {}
           result
@@ -41,7 +60,11 @@ module JsonDumper
       elsif name.end_with?('_preload') && instance.respond_to?(name.gsub('_preload', ''))
         return {}
       else
-        super name_sym, *args, &block
+        if args2.empty?
+          super name_sym, *args1, &block
+        else
+          super name_sym, *args1, *args2, &block
+        end
       end
     end
 
@@ -49,11 +72,15 @@ module JsonDumper
       new.respond_to? method_name
     end
 
-    def method_missing(name, *args, &block)
+    def method_missing(name, *args1, **args2, &block)
       if entity.respond_to? name
-        entity.send(name, *args, &block)
+        if args2.empty?
+          entity.send(name, *args1, &block)
+        else
+          entity.send(name, *args1, **args2, &block)
+        end
       else
-        super name, *args, &block
+        super
       end
     end
 

data/lib/json_dumper/delayed.rb

@@ -1,12 +1,13 @@
 module JsonDumper
   class Delayed
-    attr_accessor :method_name, :entity, :args, :klass
+    attr_accessor :method_name, :entity, :positional_args, :named_args, :klass
 
-    def initialize(method_name, entity, args, klass)
+    def initialize(method_name, entity, positional_args, named_args, klass)
       self.method_name = method_name
       self.entity = entity
-      self.args = args
+      self.positional_args = positional_args
+      self.named_args = named_args
       self.klass = klass
     end
   end
-end
+end

data/lib/json_dumper/dumper_array.rb

@@ -0,0 +1,9 @@
+module JsonDumper
+  class DumperArray < Array
+    attr_accessor :preload
+
+    def camel
+      JsonDumper::KeyTransformer.keys_to_camelcase_array(self)
+    end
+  end
+end

data/lib/json_dumper/helper.rb

@@ -18,7 +18,11 @@ module JsonDumper
     def dumper_fetch(delayed, camelcase: true)
       preload_hash = delayed.klass.send("#{delayed.method_name}_preload")
       preloader.preload(delayed.entity,preload_hash)
-      result = delayed.klass.send(delayed.method_name, delayed.entity, *delayed.args)
+      result = if delayed.named_args.empty?
+                 delayed.klass.send(delayed.method_name, delayed.entity, *delayed.positional_args)
+               else
+                 delayed.klass.send(delayed.method_name, delayed.entity, *delayed.positional_args, **delayed.named_args)
+               end
       if camelcase
         result = KeyTransformer.keys_to_camelcase(result)
       end
@@ -32,4 +36,4 @@ module JsonDumper
       ActiveRecord::Base::Preloader.new
     end
   end
-end
+end

data/lib/json_dumper/key_transformer.rb

@@ -1,6 +1,7 @@
 module JsonDumper
   class KeyTransformer
     def self.keys_to_camelcase(obj)
+      return nil if obj.nil?
       if array_like?(obj)
         return keys_to_camelcase_array(obj)
       end

data/lib/json_dumper/patches/gon.rb

@@ -5,6 +5,8 @@ if defined?(Gon)
       def set_variable(name, value)
         if value.is_a?(::JsonDumper::Delayed)
           value = Class.new.extend(::JsonDumper::Helper).dumper_fetch(value)
+        elsif value.respond_to?(:each)
+          value = ::JsonDumper::KeyTransformer.keys_to_camelcase(value)
         end
         current_gon.gon[::JsonDumper::KeyTransformer.camelize(name)] = value
       end

data/lib/json_dumper/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json_dumper
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.5.0
 platform: ruby
 authors:
 - therusskiy
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2017-08-13 00:00:00.000000000 Z
+date: 2021-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -80,7 +80,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - dimanrussian@gmail.com
 executables: []
@@ -101,6 +101,7 @@ files:
 - lib/json_dumper.rb
 - lib/json_dumper/base.rb
 - lib/json_dumper/delayed.rb
+- lib/json_dumper/dumper_array.rb
 - lib/json_dumper/dumper_hash.rb
 - lib/json_dumper/helper.rb
 - lib/json_dumper/key_transformer.rb
@@ -110,7 +111,7 @@ homepage: https://www.github.com/therusskiy/json_dumper
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -125,9 +126,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.10
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Serialize ruby objects for javascript consumption
 test_files: []