alba 1.5.0 → 1.6.0

data/benchmark/collection.rb

@@ -15,7 +15,9 @@ gemfile(true) do
   gem "benchmark-ips"
   gem "benchmark-memory"
   gem "blueprinter"
+  gem "fast_serializer_ruby"
   gem "jbuilder"
+  gem 'turbostreamer'
   gem "jserializer"
   gem "jsonapi-serializer" # successor of fast_jsonapi
   gem "multi_json"
@@ -138,6 +140,27 @@ class PostBlueprint < Blueprinter::Base
   end
 end
 
+# --- Fast Serializer Ruby
+
+require "fast_serializer"
+
+class FastSerializerCommentResource
+  include ::FastSerializer::Schema::Mixin
+  attributes :id, :body
+end
+
+class FastSerializerPostResource
+  include ::FastSerializer::Schema::Mixin
+
+  attributes :id, :body
+
+  attribute :commenter_names do
+    object.commenters.pluck(:name)
+  end
+
+  has_many :comments, serializer: FastSerializerCommentResource
+end
+
 # --- JBuilder serializers ---
 
 require "jbuilder"
@@ -255,7 +278,7 @@ class PankoPostSerializer < Panko::Serializer
   has_many :comments, serializer: PankoCommentSerializer
 
   def commenter_names
-    object.comments.pluck(:name)
+    object.commenters.pluck(:name)
   end
 end
 
@@ -332,6 +355,31 @@ class SimpleAMSPostSerializer
   end
 end
 
+require 'turbostreamer'
+TurboStreamer.set_default_encoder(:json, :oj)
+
+class TurbostreamerSerializer
+  def initialize(posts)
+    @posts = posts
+  end
+
+  def to_json
+    TurboStreamer.encode do |json|
+      json.array! @posts do |post|
+        json.object! do
+          json.extract! post, :id, :body, :commenter_names
+
+          json.comments post.comments do |comment|
+            json.object! do
+              json.extract! comment, :id, :body
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
 # --- Test data creation ---
 
 100.times do |i|
@@ -344,7 +392,7 @@ end
   end
 end
 
-posts = Post.all.to_a
+posts = Post.all.includes(:comments, :commenters)
 
 # --- Store the serializers in procs ---
 
@@ -360,8 +408,9 @@ alba_inline = Proc.new do
     end
   end
 end
-ams = Proc.new { ActiveModelSerializers::SerializableResource.new(posts, {}).as_json }
+ams = Proc.new { ActiveModelSerializers::SerializableResource.new(posts, {each_serializer: AMSPostSerializer}).to_json }
 blueprinter = Proc.new { PostBlueprint.render(posts) }
+fast_serializer = Proc.new { FastSerializerPostResource.new(posts).to_json }
 jbuilder = Proc.new do
   Jbuilder.new do |json|
     json.array!(posts) do |post|
@@ -379,15 +428,17 @@ rails = Proc.new do
 end
 representable = Proc.new { PostsRepresenter.new(posts).to_json }
 simple_ams = Proc.new { SimpleAMS::Renderer::Collection.new(posts, serializer: SimpleAMSPostSerializer).to_json }
+turbostreamer = Proc.new { TurbostreamerSerializer.new(posts).to_json }
 
 # --- Execute the serializers to check their output ---
-
+GC.disable
 puts "Serializer outputs ----------------------------------"
 {
   alba: alba,
   alba_inline: alba_inline,
   ams: ams,
   blueprinter: blueprinter,
+  fast_serializer: fast_serializer,
   jbuilder: jbuilder, # different order
   jserializer: jserializer,
   jsonapi: jsonapi, # nested JSON:API format
@@ -397,6 +448,7 @@ puts "Serializer outputs ----------------------------------"
   rails: rails,
   representable: representable,
   simple_ams: simple_ams,
+  turbostreamer: turbostreamer
 }.each { |name, serializer| puts "#{name.to_s.ljust(24, ' ')} #{serializer.call}" }
 
 # --- Run the benchmarks ---
@@ -407,6 +459,7 @@ Benchmark.ips do |x|
   x.report(:alba_inline, &alba_inline)
   x.report(:ams, &ams)
   x.report(:blueprinter, &blueprinter)
+  x.report(:fast_serializer, &fast_serializer)
   x.report(:jbuilder, &jbuilder)
   x.report(:jserializer, &jserializer)
   x.report(:jsonapi, &jsonapi)
@@ -416,6 +469,7 @@ Benchmark.ips do |x|
   x.report(:rails, &rails)
   x.report(:representable, &representable)
   x.report(:simple_ams, &simple_ams)
+  x.report(:turbostreamer, &turbostreamer)
 
   x.compare!
 end
@@ -427,6 +481,7 @@ Benchmark.memory do |x|
   x.report(:alba_inline, &alba_inline)
   x.report(:ams, &ams)
   x.report(:blueprinter, &blueprinter)
+  x.report(:fast_serializer, &fast_serializer)
   x.report(:jbuilder, &jbuilder)
   x.report(:jserializer, &jserializer)
   x.report(:jsonapi, &jsonapi)
@@ -436,6 +491,7 @@ Benchmark.memory do |x|
   x.report(:rails, &rails)
   x.report(:representable, &representable)
   x.report(:simple_ams, &simple_ams)
+  x.report(:turbostreamer, &turbostreamer)
 
   x.compare!
 end

data/benchmark/single_resource.rb

@@ -16,6 +16,7 @@ gemfile(true) do
   gem "benchmark-memory"
   gem "blueprinter"
   gem "jbuilder"
+  gem 'turbostreamer'
   gem "jserializer"
   gem "jsonapi-serializer" # successor of fast_jsonapi
   gem "multi_json"
@@ -253,7 +254,7 @@ class PankoPostSerializer < Panko::Serializer
   has_many :comments, serializer: PankoCommentSerializer
 
   def commenter_names
-    object.comments.pluck(:name)
+    object.commenters.pluck(:name)
   end
 end
 
@@ -324,6 +325,29 @@ class SimpleAMSPostSerializer
   end
 end
 
+require 'turbostreamer'
+TurboStreamer.set_default_encoder(:json, :oj)
+
+class TurbostreamerSerializer
+  def initialize(post)
+    @post = post
+  end
+
+  def to_json
+    TurboStreamer.encode do |json|
+      json.object! do
+        json.extract! @post, :id, :body, :commenter_names
+
+        json.comments @post.comments do |comment|
+          json.object! do
+            json.extract! comment, :id, :body
+          end
+        end
+      end
+    end
+  end
+end
+
 # --- Test data creation ---
 
 post = Post.create!(body: 'post')
@@ -347,6 +371,7 @@ alba_inline = Proc.new do
     end
   end
 end
+
 ams = Proc.new { AMSPostSerializer.new(post, {}).to_json }
 blueprinter = Proc.new { PostBlueprint.render(post) }
 jbuilder = Proc.new { post.to_builder.target! }
@@ -358,6 +383,7 @@ primalize = proc { PrimalizePostResource.new(post).to_json }
 rails = Proc.new { ActiveSupport::JSON.encode(post.serializable_hash(include: :comments)) }
 representable = Proc.new { PostRepresenter.new(post).to_json }
 simple_ams = Proc.new { SimpleAMS::Renderer.new(post, serializer: SimpleAMSPostSerializer).to_json }
+turbostreamer = Proc.new { TurbostreamerSerializer.new(post).to_json }
 
 # --- Execute the serializers to check their output ---
 
@@ -376,7 +402,10 @@ puts "Serializer outputs ----------------------------------"
   rails: rails,
   representable: representable,
   simple_ams: simple_ams,
-}.each { |name, serializer| puts "#{name.to_s.ljust(24, ' ')} #{serializer.call}" }
+  turbostreamer: turbostreamer
+}.each do |name, serializer|
+  puts "#{name.to_s.ljust(24, ' ')} #{serializer.call}"
+end
 
 # --- Run the benchmarks ---
 
@@ -395,6 +424,7 @@ Benchmark.ips do |x|
   x.report(:rails, &rails)
   x.report(:representable, &representable)
   x.report(:simple_ams, &simple_ams)
+  x.report(:turbostreamer, &turbostreamer)
 
   x.compare!
 end
@@ -415,6 +445,7 @@ Benchmark.memory do |x|
   x.report(:rails, &rails)
   x.report(:representable, &representable)
   x.report(:simple_ams, &simple_ams)
+  x.report(:turbostreamer, &turbostreamer)
 
   x.compare!
 end

data/gemfiles/all.gemfile

@@ -1,6 +1,7 @@
 source 'https://rubygems.org'
 
 gem 'activesupport', require: false # For backend
+gem 'dry-inflector', require: false # For inflector
 gem 'ffaker', require: false # For testing
 gem 'minitest', '~> 5.14' # For test
 gem 'rake', '~> 13.0' # For test and automation

data/lib/alba/association.rb

@@ -1,7 +1,11 @@
 module Alba
-  # Base class for `One` and `Many`
-  # Child class should implement `to_hash` method
+  # Representing association
   class Association
+    @const_cache = {}
+    class << self
+      attr_reader :const_cache
+    end
+
     attr_reader :object, :name
 
     # @param name [Symbol, String] name of the method to fetch association
@@ -12,11 +16,25 @@ module Alba
     def initialize(name:, condition: nil, resource: nil, nesting: nil, &block)
       @name = name
       @condition = condition
-      @block = block
       @resource = resource
       return if @resource
 
-      assign_resource(nesting)
+      assign_resource(nesting, block)
+    end
+
+    # Recursively converts an object into a Hash
+    #
+    # @param target [Object] the object having an association method
+    # @param within [Hash] determines what associations to be serialized. If not set, it serializes all associations.
+    # @param params [Hash] user-given Hash for arbitrary data
+    # @return [Hash]
+    def to_h(target, within: nil, params: {})
+      @object = target.public_send(@name)
+      @object = @condition.call(object, params) if @condition
+      return if @object.nil?
+
+      @resource = constantize(@resource)
+      @resource.new(object, params: params, within: within).to_h
     end
 
     private
@@ -26,13 +44,15 @@ module Alba
       when Class
         resource
       when Symbol, String
-        Object.const_get(resource)
+        self.class.const_cache.fetch(resource) do
+          self.class.const_cache[resource] = Object.const_get(resource)
+        end
       end
     end
 
-    def assign_resource(nesting)
-      @resource = if @block
-                    Alba.resource_class(&@block)
+    def assign_resource(nesting, block)
+      @resource = if block
+                    Alba.resource_class(&block)
                   elsif Alba.inferring
                     Alba.infer_resource_class(@name, nesting: nesting)
                   else

data/lib/alba/default_inflector.rb

@@ -1,5 +1,7 @@
 module Alba
-  # This module represents the inflector, which is used by default
+  # This module has two purposes.
+  # One is that we require `active_support/inflector` in this module so that we don't do that all over the place.
+  # Another is that `ActiveSupport::Inflector` doesn't have `camelize_lower` method that we want it to have, so this module works as an adapter.
   module DefaultInflector
     begin
       require 'active_support/inflector'
@@ -32,5 +34,21 @@ module Alba
     def dasherize(key)
       ActiveSupport::Inflector.dasherize(key)
     end
+
+    # Underscore a key
+    #
+    # @param key [String] key to be underscore
+    # @return [String] underscored key
+    def underscore(key)
+      ActiveSupport::Inflector.underscore(key)
+    end
+
+    # Classify a key
+    #
+    # @param key [String] key to be classified
+    # @return [String] classified key
+    def classify(key)
+      ActiveSupport::Inflector.classify(key)
+    end
   end
 end

data/lib/alba/errors.rb

@@ -0,0 +1,10 @@
+module Alba
+  # Base class for Errors
+  class Error < StandardError; end
+
+  # Error class for backend which is not supported
+  class UnsupportedBackend < Error; end
+
+  # Error class for type which is not supported
+  class UnsupportedType < Error; end
+end

data/lib/alba/resource.rb

@@ -1,6 +1,4 @@
-require_relative 'one'
-require_relative 'many'
-require_relative 'key_transform_factory'
+require_relative 'association'
 require_relative 'typed_attribute'
 require_relative 'deprecation'
 
@@ -9,7 +7,7 @@ module Alba
   module Resource
     # @!parse include InstanceMethods
     # @!parse extend ClassMethods
-    DSLS = {_attributes: {}, _key: nil, _key_for_collection: nil, _meta: nil, _transform_key_function: nil, _transforming_root_key: false, _on_error: nil, _on_nil: nil, _layout: nil}.freeze # rubocop:disable Layout/LineLength
+    DSLS = {_attributes: {}, _key: nil, _key_for_collection: nil, _meta: nil, _transform_type: :none, _transforming_root_key: false, _on_error: nil, _on_nil: nil, _layout: nil}.freeze # rubocop:disable Layout/LineLength
     private_constant :DSLS
 
     WITHIN_DEFAULT = Object.new.freeze
@@ -39,6 +37,7 @@ module Alba
         @object = object
         @params = params.freeze
         @within = within
+        @method_existence = {} # Cache for `respond_to?` result
         DSLS.each_key { |name| instance_variable_set("@#{name}", self.class.public_send(name)) }
       end
 
@@ -67,7 +66,13 @@ module Alba
       def serializable_hash
         collection? ? @object.map(&converter) : converter.call(@object)
       end
-      alias to_hash serializable_hash
+      alias to_h serializable_hash
+
+      # @deprecated Use {#serializable_hash} instead
+      def to_hash
+        warn '[DEPRECATION] `to_hash` is deprecated, use `serializable_hash` instead.'
+        serializable_hash
+      end
 
       private
 
@@ -78,22 +83,33 @@ module Alba
       end
 
       def serialize_with(hash)
-        @serialized_json = encode(hash)
-        case @_layout
-        when String # file
+        serialized_json = encode(hash)
+        return serialized_json unless @_layout
+
+        @serialized_json = serialized_json
+        if @_layout.is_a?(String) # file
           ERB.new(File.read(@_layout)).result(binding)
-        when Proc # inline
-          inline = instance_eval(&@_layout)
-          inline.is_a?(Hash) ? encode(inline) : inline
-        else # no layout
-          @serialized_json
+
+        else # inline
+          serialize_within_inline_layout
+        end
+      end
+
+      def serialize_within_inline_layout
+        inline = instance_eval(&@_layout)
+        case inline
+        when Hash then encode(inline)
+        when String then inline
+        else
+          raise Alba::Error, 'Inline layout must be a Proc returning a Hash or a String'
         end
       end
 
       def hash_with_metadata(hash, meta)
-        base = @_meta ? instance_eval(&@_meta) : {}
-        metadata = base.merge(meta)
-        hash[:meta] = metadata unless metadata.empty?
+        return hash if meta.empty? && @_meta.nil?
+
+        metadata = @_meta ? instance_eval(&@_meta).merge(meta) : meta
+        hash[:meta] = metadata
         hash
       end
 
@@ -116,25 +132,34 @@ module Alba
       end
 
       def resource_name
-        self.class.name.demodulize.delete_suffix('Resource').underscore
+        @resource_name ||= self.class.name.demodulize.delete_suffix('Resource').underscore
       end
 
       def transforming_root_key?
         @_transforming_root_key.nil? ? Alba.transforming_root_key : @_transforming_root_key
       end
 
+      # rubocop:disable Metrics/MethodLength
       def converter
         lambda do |object|
-          arrays = @_attributes.map do |key, attribute|
+          arrays = attributes.map do |key, attribute|
             key_and_attribute_body_from(object, key, attribute)
           rescue ::Alba::Error, FrozenError, TypeError
             raise
           rescue StandardError => e
             handle_error(e, object, key, attribute)
           end
-          arrays.reject(&:empty?).to_h
+          arrays.compact!
+          arrays.to_h
         end
       end
+      # rubocop:enable Metrics/MethodLength
+
+      # This is default behavior for getting attributes for serialization
+      # Override this method to filter certain attributes
+      def attributes
+        @_attributes
+      end
 
       def key_and_attribute_body_from(object, key, attribute)
         key = transform_key(key)
@@ -158,17 +183,17 @@ module Alba
       def conditional_attribute_with_proc(object, key, attribute, condition)
         arity = condition.arity
         # We can return early to skip fetch_attribute
-        return [] if arity <= 1 && !instance_exec(object, &condition)
+        return if arity <= 1 && !instance_exec(object, &condition)
 
         fetched_attribute = fetch_attribute(object, key, attribute)
         attr = attribute.is_a?(Alba::Association) ? attribute.object : fetched_attribute
-        return [] if arity >= 2 && !instance_exec(object, attr, &condition)
+        return if arity >= 2 && !instance_exec(object, attr, &condition)
 
         [key, fetched_attribute]
       end
 
       def conditional_attribute_with_symbol(object, key, attribute, condition)
-        return [] unless __send__(condition)
+        return unless __send__(condition)
 
         [key, fetch_attribute(object, key, attribute)]
       end
@@ -178,25 +203,39 @@ module Alba
         case on_error
         when :raise, nil then raise
         when :nullify then [key, nil]
-        when :ignore then []
+        when :ignore then nil
         when Proc then on_error.call(error, object, key, attribute, self.class)
         else
           raise ::Alba::Error, "Unknown on_error: #{on_error.inspect}"
         end
       end
 
-      # Override this method to supply custom key transform method
+      # rubocop:disable Metrics/MethodLength
+      # @return [Symbol]
       def transform_key(key)
-        return key if @_transform_key_function.nil?
-
-        @_transform_key_function.call(key.to_s)
+        return key if @_transform_type == :none
+
+        key = key.to_s
+        # TODO: Using default inflector here is for backward compatibility
+        # From 2.0 it'll raise error when inflector is nil
+        inflector = Alba.inflector || begin
+          require_relative 'default_inflector'
+          Alba::DefaultInflector
+        end
+        case @_transform_type # rubocop:disable Style/MissingElse
+        when :camel then inflector.camelize(key)
+        when :lower_camel then inflector.camelize_lower(key)
+        when :dash then inflector.dasherize(key)
+        when :snake then inflector.underscore(key)
+        end.to_sym
       end
+      # rubocop:enable Metrics/MethodLength
 
       def fetch_attribute(object, key, attribute)
         value = case attribute
-                when Symbol then object.public_send attribute
+                when Symbol then fetch_attribute_from_object_and_resource(object, attribute)
                 when Proc then instance_exec(object, &attribute)
-                when Alba::One, Alba::Many then yield_if_within(attribute.name.to_sym) { |within| attribute.to_hash(object, params: params, within: within) }
+                when Alba::Association then yield_if_within(attribute.name.to_sym) { |within| attribute.to_h(object, params: params, within: within) }
                 when TypedAttribute then attribute.value(object)
                 else
                   raise ::Alba::Error, "Unsupported type of attribute: #{attribute.class}"
@@ -204,6 +243,12 @@ module Alba
         value.nil? && nil_handler ? instance_exec(object, key, attribute, &nil_handler) : value
       end
 
+      def fetch_attribute_from_object_and_resource(object, attribute)
+        has_method = @method_existence[attribute]
+        has_method = @method_existence[attribute] = object.respond_to?(attribute) if has_method.nil?
+        has_method ? object.public_send(attribute) : __send__(attribute, object)
+      end
+
       def nil_handler
         @nil_handler ||= (@_on_nil || Alba._on_nil)
       end
@@ -225,8 +270,10 @@ module Alba
         end
       end
 
+      # Detect if object is a collection or not.
+      # When object is a Struct, it's Enumerable but not a collection
       def collection?
-        @object.is_a?(Enumerable)
+        @object.is_a?(Enumerable) && !@object.is_a?(Struct)
       end
     end
 
@@ -241,7 +288,6 @@ module Alba
       end
 
       # Defining methods for DSLs and disable parameter number check since for users' benefits increasing params is fine
-      # rubocop:disable Metrics/ParameterLists
 
       # Set multiple attributes at once
       #
@@ -289,7 +335,7 @@ module Alba
         @_attributes[name.to_sym] = options[:if] ? [block, options[:if]] : block
       end
 
-      # Set One association
+      # Set association
       #
       # @param name [String, Symbol] name of the association, used as key when `key` param doesn't exist
       # @param condition [Proc, nil] a Proc to modify the association
@@ -299,31 +345,16 @@ module Alba
       # @option options [Proc] if a condition to decide if this association should be serialized
       # @param block [Block]
       # @return [void]
-      # @see Alba::One#initialize
-      def one(name, condition = nil, resource: nil, key: nil, **options, &block)
+      # @see Alba::Association#initialize
+      def association(name, condition = nil, resource: nil, key: nil, **options, &block)
         nesting = self.name&.rpartition('::')&.first
-        one = One.new(name: name, condition: condition, resource: resource, nesting: nesting, &block)
-        @_attributes[key&.to_sym || name.to_sym] = options[:if] ? [one, options[:if]] : one
+        assoc = Association.new(name: name, condition: condition, resource: resource, nesting: nesting, &block)
+        @_attributes[key&.to_sym || name.to_sym] = options[:if] ? [assoc, options[:if]] : assoc
       end
-      alias has_one one
-
-      # Set Many association
-      #
-      # @param name [String, Symbol] name of the association, used as key when `key` param doesn't exist
-      # @param condition [Proc, nil] a Proc to filter the collection
-      # @param resource [Class<Alba::Resource>, String, nil] representing resource for this association
-      # @param key [String, Symbol, nil] used as key when given
-      # @param options [Hash<Symbol, Proc>]
-      # @option options [Proc] if a condition to decide if this association should be serialized
-      # @param block [Block]
-      # @return [void]
-      # @see Alba::Many#initialize
-      def many(name, condition = nil, resource: nil, key: nil, **options, &block)
-        nesting = self.name&.rpartition('::')&.first
-        many = Many.new(name: name, condition: condition, resource: resource, nesting: nesting, &block)
-        @_attributes[key&.to_sym || name.to_sym] = options[:if] ? [many, options[:if]] : many
-      end
-      alias has_many many
+      alias one association
+      alias many association
+      alias has_one association
+      alias has_many association
 
       # Set key
       #
@@ -369,14 +400,33 @@ module Alba
       # @params file [String] name of the layout file
       # @params inline [Proc] a proc returning JSON string or a Hash representing JSON
       def layout(file: nil, inline: nil)
-        @_layout = file || inline
+        @_layout = validated_file_layout(file) || validated_inline_layout(inline)
+      end
+
+      def validated_file_layout(filename)
+        case filename
+        when String, nil then filename
+        else
+          raise ArgumentError, 'File layout must be a String representing filename'
+        end
       end
+      private :validated_file_layout
+
+      def validated_inline_layout(inline_layout)
+        case inline_layout
+        when Proc, nil then inline_layout
+        else
+          raise ArgumentError, 'Inline layout must be a Proc returning a Hash or a String'
+        end
+      end
+      private :validated_inline_layout
 
       # Delete attributes
       # Use this DSL in child class to ignore certain attributes
       #
       # @param attributes [Array<String, Symbol>]
       def ignoring(*attributes)
+        Alba::Deprecation.warn '`ignoring` is deprecated now. Instead please use `attributes` instance method to filter out attributes.'
         attributes.each do |attr_name|
           @_attributes.delete(attr_name.to_sym)
         end
@@ -384,10 +434,18 @@ module Alba
 
       # Transform keys as specified type
       #
-      # @param type [String, Symbol]
-      # @param root [Boolean] decides if root key also should be transformed
+      # @param type [String, Symbol] one of `snake`, `:camel`, `:lower_camel`, `:dash` and `none`
+      # @param root [Boolean, nil] decides if root key also should be transformed
+      #   When it's `nil`, Alba's default setting will be applied
+      # @raise [Alba::Error] when type is not supported
       def transform_keys(type, root: nil)
-        @_transform_key_function = KeyTransformFactory.create(type.to_sym)
+        type = type.to_sym
+        unless %i[none snake camel lower_camel dash].include?(type)
+          # This should be `ArgumentError` but for backward compatibility it raises `Alba::Error`
+          raise ::Alba::Error, "Unknown transform type: #{type}. Supported type are :camel, :lower_camel and :dash."
+        end
+
+        @_transform_type = type
         @_transforming_root_key = root
       end
 
@@ -409,8 +467,6 @@ module Alba
       def on_nil(&block)
         @_on_nil = block
       end
-
-      # rubocop:enable Metrics/ParameterLists
     end
   end
 end

data/lib/alba/version.rb

@@ -1,3 +1,3 @@
 module Alba
-  VERSION = '1.5.0'.freeze
+  VERSION = '1.6.0'.freeze
 end