json_serializers 2.0.3

data/lib/json_serializers/compat.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'active_model_serializers'
+
+# Extensions: To ensure JsonStringEncoder can process ActiveModel::Serializer
+# as well.
+class ActiveModel::Serializer
+  # JsonStringEncoder: Used internally to write a single object to JSON.
+  def self.one(object, options = nil)
+    new(object, options)
+  end
+
+  # JsonStringEncoder: Used internally to write an array of objects to JSON.
+  def self.many(array, options = nil)
+    array.map { |object| new(object, options) }
+  end
+
+  # JsonSerializer: Used internally to write a single object association in :hash mode.
+  #
+  # Returns nothing.
+  def self.one_as_hash(object)
+    new(object)
+  end
+
+  # JsonSerializer: Used internally to write an association in :hash mode.
+  #
+  # Returns nothing.
+  def self.many_as_hash(array)
+    array.map { |object| new(object) }
+  end
+
+  # JsonSerializer: Used internally to write a single object association in :json mode.
+  #
+  # Returns nothing.
+  def self.write_one(writer, object)
+    writer.push_value(new(object))
+  end
+
+  # JsonSerializer: Used internally to write an association in :json mode.
+  #
+  # Returns nothing.
+  def self.write_many(writer, array)
+    writer.push_array
+    array.each do |object|
+      write_one(writer, object)
+    end
+    writer.pop
+  end
+
+  module JsonSerializerOptionsCompat
+    def add_attribute(value_from, key: nil, **options)
+      options[:as] ||= key if key
+
+      if (unless_proc = options.delete(:unless))
+        options[:if] = -> { !instance_exec(&unless_proc) }
+      end
+
+      super(value_from, **options)
+    end
+  end
+end
+
+require 'json_serializers'
+require 'json_serializers/sugar'
+
+JsonSerializer.singleton_class.prepend(ActiveModel::Serializer::JsonSerializerOptionsCompat)

data/lib/json_serializers/controller_serialization.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'json_serializers/json_string_encoder'
+
+# Internal: Allows to pass JSON serializers as options in `render`.
+module JsonSerializers::ControllerSerialization
+  extend ActiveSupport::Concern
+  include ActionController::Renderers
+
+  # Internal: Allows to use JsonSerializer as `serializer` and `each_serializer`
+  # as with ActiveModelSerializers.
+  #
+  #   render json: items, each_serializer: ItemSerializer
+  #   render json: item, serializer: ItemSerializer
+  #
+  # NOTE: In practice, it should be preferable to simply do:
+  #
+  #   render json: ItemSerializer.many(items)
+  #   render json: ItemSerializer.one(item)
+  #
+  # which is more performant.
+  %i[_render_option_json _render_with_renderer_json].each do |renderer_method|
+    define_method renderer_method do |resource, options = {}|
+      serializer_class = options[:serializer] || options[:each_serializer]
+      if serializer_class && serializer_class < JsonSerializers::Serializer
+        super(JsonSerializers::JsonStringEncoder.encode_to_json(resource, **options), options.except(:root, :serializer, :each_serializer))
+      else
+        super(resource, **options)
+      end
+    end
+  end
+end

data/lib/json_serializers/json_string_encoder.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# Public: Contains utility functions to render objects to JSON.
+#
+# Useful to instantiate a single `JsonWriter` when rendering new serializers.
+module JsonSerializers::JsonStringEncoder
+  class << self
+    # Public: Allows to use JsonSerializer in `serializer` and `each_serializer`
+    # as with ActiveModelSerializers.
+    #   render json: items, each_serializer: ItemSerializer
+    #   render json: item, serializer: ItemSerializer
+    #
+    # NOTE: Unlike the default encoder, this one will use the `root` option
+    # regardless of whether a serializer is specified or not.
+    #
+    # Returns a JSON string.
+    def encode_to_json(object, root: nil, serializer: nil, each_serializer: nil, **options)
+      result = if serializer
+        serializer.one(object, options)
+      elsif each_serializer
+        each_serializer.many(object, options)
+      elsif object.is_a?(String)
+        JsonSerializers::JsonValue.new(object)
+      else
+        object
+      end
+      Oj.dump(root ? { root => result } : result)
+    end
+
+    if JsonSerializers::Serializer::DEV_MODE
+      alias actual_encode_to_json encode_to_json
+      # Internal: Allows to detect misusage of the options during development.
+      def encode_to_json(object, root: nil, serializer: nil, each_serializer: nil, **options)
+        raise ArgumentError, 'You must use `each_serializer` when serializing collections' if serializer && serializer < JsonSerializers::Serializer && object.respond_to?(:map)
+        raise ArgumentError, 'You must use `serializer` when serializing a single object' if each_serializer && each_serializer < JsonSerializers::Serializer && !object.respond_to?(:map)
+
+        actual_encode_to_json(object, root: root, serializer: serializer, each_serializer: each_serializer, **options)
+      end
+    end
+  end
+end

data/lib/json_serializers/json_value.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Public: Allows to prevent double encoding an existing JSON string.
+#
+# NOTE: Oj's raw_json option means there's no performance overhead, as it would
+# occur with the previous alternative of parsing the JSON string.
+class JsonSerializers::JsonValue
+  # Public: Expects json to be a JSON-encoded string.
+  def initialize(json)
+    @json = json
+  end
+
+  # Public: Expects an Array of JSON-encoded strings and wraps them in a JSON array.
+  #
+  # Returns a JsonValue representing a JSON-encoded array.
+  def self.array(json_rows)
+    new("[#{json_rows.join(',')}]")
+  end
+
+  # Public: Return the internal json when using string interpolation.
+  def to_s
+    @json
+  end
+
+  # Internal: Used by Oj::Rails::Encoder because we use the `raw_json` option.
+  def raw_json(*)
+    @json
+  end
+
+  # Internal: Used by Oj::Rails::Encoder when found inside a Hash or Array.
+  def as_json(_options = nil)
+    self
+  end
+end

data/lib/json_serializers/memo.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Internal: Provides a simple API on top of Hash for memoization purposes.
+class JsonSerializers::Memo
+  def initialize
+    @cache = {}
+  end
+
+  # Internal: Allows to clear the cache when binding the serializer to a
+  # different object.
+  def clear
+    @cache.clear
+  end
+
+  # Public: Allows to use a simple memoization pattern that also works for
+  # falsey values.
+  def fetch(key)
+    @cache.fetch(key) { @cache[key] = yield }
+  end
+end