Allow direct JSON rendering to a string

lib/cache_crispies.rb

@@ -25,6 +25,7 @@ module CacheCrispies
   autoload :Optional,       'cache_crispies/optional'
   autoload :Configuration,  'cache_crispies/configuration'
   autoload :HashBuilder,    'cache_crispies/hash_builder'
+  autoload :JsonBuilder,    'cache_crispies/json_builder'
   autoload :Memoizer,       'cache_crispies/memoizer'
   autoload :Controller,     'cache_crispies/controller'
   autoload :Plan,           'cache_crispies/plan'

lib/cache_crispies/attribute.rb

@@ -63,18 +63,29 @@ def initialize(
     # @raise [InvalidCoercionType] when an invalid argument is passed in the
     #   to: argument
     def value_for(target, options)
-      value =
-        if block?
-          block.call(target, options)
-        elsif through?
-          target.public_send(through)&.public_send(method_name)
-        else
-          target.public_send(method_name)
-        end
+      value = retrieve_value(target, options)
 
       serializer ? serialize(value, options) : coerce(value)
     end
 
+    # Writes a key-value pair of the attribute for the given target object
+    # and options into the given Oj::StringWriter
+    #
+    # @param json_writer [Oj::StringWriter] any Oj::StringWriter instance
+    # @param target [Object] typically ActiveRecord::Base, but could be anything
+    # @param options [Hash] any optional values from the serializer instance
+    # @raise [InvalidCoercionType] when an invalid argument is passed in the
+    #   to: argument
+    def write_to_json(json_writer, target, options)
+      value = retrieve_value(target, options)
+
+      if serializer
+        write_serialized_value(json_writer, value, options)
+      else
+        json_writer.push_value(coerce(value), key.to_s)
+      end
+    end
+
     private
 
     def through?
@@ -85,6 +96,16 @@ def block?
       !block.nil?
     end
 
+    def retrieve_value(target, options)
+      if block?
+        block.call(target, options)
+      elsif through?
+        target.public_send(through)&.public_send(method_name)
+      else
+        target.public_send(method_name)
+      end
+    end
+
     # Here we'll render the attribute with a given serializer and attempt to
     # cache the results for better cache reusability
     def serialize(value, options)
@@ -99,6 +120,20 @@ def serialize(value, options)
       end
     end
 
+    def write_serialized_value(json_writer, value, options)
+      plan = CacheCrispies::Plan.new(
+        serializer, value, collection: collection, **options
+      )
+
+      json_writer.push_key(key.to_s) if key
+
+      if key && plan.collection?
+        Collection.new(value, serializer, options).write_to_json(json_writer)
+      else
+        JsonBuilder.new(serializer.new(value, options)).call(json_writer, flat: !key)
+      end
+    end
+
     def coerce(value)
       return value if coerce_to.nil?
 

lib/cache_crispies/base.rb

@@ -23,7 +23,7 @@ def self.inherited(other)
     class << self
       attr_reader :attributes
     end
-    delegate :attributes, to: :class
+    delegate :attributes, :attributes_by_nesting, to: :class
 
     # Initializes a new instance of CacheCrispies::Base, or really, it should
     # always be a subclass of CacheCrispies::Base.
@@ -43,6 +43,18 @@ def as_json
       HashBuilder.new(self).call
     end
 
+    # Renders the serializer instance to an Oj::StringWriter instance
+    #
+    # @return [Oj::StringWriter] an Oj::StringWriter instance with the
+    #   serialized content
+    def write_to_json(json_writer = nil)
+      json_writer ||= Oj::StringWriter.new(mode: :rails)
+
+      JsonBuilder.new(self).call(json_writer)
+
+      json_writer
+    end
+
     # Get or set whether or not this serializer class should allow caching of
     # results. It returns false by default, but can be overridden in child
     # classes. Calling the method with an argument will set the value, calling
@@ -193,6 +205,12 @@ def self.file_hashes
       ).uniq.sort
     end
 
+    def self.attributes_by_nesting
+      @attributes_by_nesting ||= (
+        attributes.sort_by(&:nesting).group_by(&:nesting)
+      )
+    end
+
     private
 
     def self.file_hash

lib/cache_crispies/collection.rb

@@ -29,6 +29,22 @@ def as_json
       end
     end
 
+    # Renders the collection to an Oj::StringWriter instance without caching
+    #
+    # @return [Oj::StringWriter] an Oj::StringWriter instance with the
+    #   serialized content
+    def write_to_json(json_writer = nil)
+      json_writer ||= Oj::StringWriter.new(mode: :rails)
+      json_writer.push_array
+
+      collection.each do |model|
+        serializer.new(model, options).write_to_json(json_writer)
+      end
+
+      json_writer.pop
+      json_writer
+    end
+
     private
 
     attr_reader :collection, :serializer, :options

lib/cache_crispies/hash_builder.rb

@@ -16,7 +16,7 @@ def initialize(serializer)
     #
     # @return [Hash]
     def call
-      return unless @serializer.model
+      return if @serializer.model.nil?
 
       hash = {}
 
@@ -42,7 +42,7 @@ def call
       hash
     end
 
-    private
+    protected
 
     attr_reader :serializer, :condition_results
 
@@ -56,18 +56,19 @@ def show?(attribute)
       end
     end
 
-    def value_for(attribute)
+    def target_for(attribute)
       meth = attribute.method_name
 
-      target =
-        if meth != :itself && serializer.respond_to?(meth)
-          serializer
-        else
-          serializer.model
-        end
+      if serializer.respond_to?(meth) && meth != :itself
+        serializer
+      else
+        serializer.model
+      end
+    end
 
+    def value_for(attribute)
       # TODO: rescue NoMethodErrors here with something more telling
-      attribute.value_for(target, serializer.options)
+      attribute.value_for(target_for(attribute), serializer.options)
     end
   end
 end

lib/cache_crispies/json_builder.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module CacheCrispies
+  # Builds out a JSON string directly with Oj::StringWriter
+  class JsonBuilder < HashBuilder
+    # Builds the JSON string with Oj::StringWriter
+    #
+    # @return [Oj::StringWriter]
+    def call(json_writer, flat: false)
+      if @serializer.model.nil?
+        json_writer.push_value(nil)
+        return
+      end
+
+      json_writer.push_object unless flat
+
+      last_nesting = []
+
+      serializer.attributes_by_nesting.each do |nesting, attributes|
+        prefix_length = common_prefix_length(last_nesting, nesting)
+
+        (last_nesting.length - prefix_length).times do
+          json_writer.pop
+        end
+
+        nesting[prefix_length..-1].each do |key|
+          json_writer.push_object(key.to_s)
+        end
+
+        attributes.each do |attrib|
+          write_attribute(json_writer, attrib) if show?(attrib)
+        end
+
+        last_nesting = nesting
+      end
+
+      last_nesting.each do
+        json_writer.pop
+      end
+
+      json_writer.pop unless flat
+
+      json_writer
+    end
+
+    protected
+
+    def write_attribute(json_writer, attribute)
+      # TODO: rescue NoMethodErrors here with something more telling
+      attribute.write_to_json(
+        json_writer,
+        target_for(attribute),
+        serializer.options
+      )
+    end
+
+    private
+
+    def common_prefix_length(array1, array2)
+      (0...[array1.length, array2.length].min).each do |i|
+        return i if array1[i] != array2[i]
+      end
+
+      array1.length
+    end
+  end
+end

spec/cache_crispies/base_spec.rb

@@ -105,6 +105,50 @@ class CacheCrispiesEngineTestSerializer < CacheCrispiesTestSerializer
     end
   end
 
+  describe '#write_to_json' do
+    let(:recovered_hash) { Oj.compat_load(subject.write_to_json.to_s, symbol_keys: true) }
+
+    it 'serializes to an Oj::StringWriter' do
+      expect(subject.write_to_json).to be_kind_of(Oj::StringWriter)
+
+      expect(recovered_hash).to eq(
+        id: '42',
+        name: 'Cookie Crisp',
+        company: 'General Mills',
+        nested: {
+          nested_again: {
+            deeply_nested: 'TRUE'
+          }
+        },
+        nutrition_info: {
+          calories: 1000
+        },
+        organic: true,
+        parent_company: 'Disney probably'
+      )
+    end
+
+    context 'when nutrition_info is nil' do
+      before { model.nutrition_info = nil }
+
+      it 'serializes to an Oj::StringWriter' do
+        expect(recovered_hash).to eq(
+          id: '42',
+          name: 'Cookie Crisp',
+          company: 'General Mills',
+          nested: {
+            nested_again: {
+              deeply_nested: 'TRUE'
+            }
+          },
+          nutrition_info: nil,
+          organic: true,
+          parent_company: 'Disney probably'
+        )
+      end
+    end
+  end
+
   describe '.key' do
     it 'underscores the demodulized class name by default' do
       expect(serializer.key).to eq :cache_crispies_test

spec/cache_crispies/collection_spec.rb

@@ -80,4 +80,12 @@ def models.cache_key() end
       end
     end
   end
+
+  describe '#write_to_json' do
+    let(:recovered_hash) { Oj.compat_load(subject.write_to_json.to_s, symbol_keys: true) }
+
+    it 'serializes to an Oj::StringWriter' do
+      expect(recovered_hash).to eq [{ name: name1 }, { name: name2 }]
+    end
+  end
 end