alba 0.12.0 → 1.1.0

data/Rakefile

@@ -1,10 +1,13 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
 
+ENV["BUNDLE_GEMFILE"] = File.expand_path("gemfiles/all.gemfile") if ENV["BUNDLE_GEMFILE"] == File.expand_path("Gemfile") || ENV["BUNDLE_GEMFILE"].empty? || ENV["BUNDLE_GEMFILE"].nil?
+
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
+  file_list = ENV["BUNDLE_GEMFILE"] == File.expand_path("gemfiles/all.gemfile") ? FileList["test/**/*_test.rb"] : FileList["test/dependencies/test_dependencies.rb"]
+  t.test_files = file_list
 end
 
 task :default => :test

data/alba.gemspec

@@ -10,11 +10,11 @@ Gem::Specification.new do |spec|
   spec.description   = "Alba is designed to be a simple, easy to use and fast alternative to existing JSON serializers. Its performance is better than almost all gems which do similar things. The internal is so simple that it's easy to hack and maintain."
   spec.homepage      = 'https://github.com/okuramasafumi/alba'
   spec.license       = 'MIT'
-  spec.required_ruby_version = Gem::Requirement.new('>= 2.5.7')
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.5.0')
 
   spec.metadata['homepage_uri'] = spec.homepage
   spec.metadata['source_code_uri'] = 'https://github.com/okuramasafumi/alba'
-  spec.metadata['changelog_uri'] = 'https://github.com/okuramasafumi/alba/CHANGELOG.md'
+  spec.metadata['changelog_uri'] = 'https://github.com/okuramasafumi/alba/blob/master/CHANGELOG.md'
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.

data/benchmark/local.rb

@@ -0,0 +1,315 @@
+# Benchmark script to run varieties of JSON serializers
+# Fetch Alba from local, otherwise fetch latest from RubyGems
+
+# --- Bundle dependencies ---
+
+require "bundler/inline"
+
+gemfile(true) do
+  source "https://rubygems.org"
+  git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+  gem "active_model_serializers"
+  gem "activerecord", "6.1.3"
+  gem "alba", path: '../'
+  gem "benchmark-ips"
+  gem "blueprinter"
+  gem "jbuilder"
+  gem "jsonapi-serializer" # successor of fast_jsonapi
+  gem "multi_json"
+  gem "oj"
+  gem "representable"
+  gem "sqlite3"
+end
+
+# --- Test data model setup ---
+
+require "active_record"
+require "logger"
+require "oj"
+require "sqlite3"
+Oj.optimize_rails
+
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+# ActiveRecord::Base.logger = Logger.new($stdout)
+
+ActiveRecord::Schema.define do
+  create_table :posts, force: true do |t|
+    t.string :body
+  end
+
+  create_table :comments, force: true do |t|
+    t.integer :post_id
+    t.string :body
+    t.integer :commenter_id
+  end
+
+  create_table :users, force: true do |t|
+    t.string :name
+  end
+end
+
+class Post < ActiveRecord::Base
+  has_many :comments
+  has_many :commenters, through: :comments, class_name: 'User', source: :commenter
+
+  def attributes
+    {id: nil, body: nil, commenter_names: commenter_names}
+  end
+
+  def commenter_names
+    commenters.pluck(:name)
+  end
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :post
+  belongs_to :commenter, class_name: 'User'
+
+  def attributes
+    {id: nil, body: nil}
+  end
+end
+
+class User < ActiveRecord::Base
+  has_many :comments
+end
+
+# --- Alba serializers ---
+
+require "alba"
+
+class AlbaCommentResource
+  include ::Alba::Resource
+  attributes :id, :body
+end
+
+class AlbaPostResource
+  include ::Alba::Resource
+  attributes :id, :body
+  attribute :commenter_names do |post|
+    post.commenters.pluck(:name)
+  end
+  many :comments, resource: AlbaCommentResource
+end
+
+# --- ActiveModelSerializer serializers ---
+
+require "active_model_serializers"
+
+class AMSCommentSerializer < ActiveModel::Serializer
+  attributes :id, :body
+end
+
+class AMSPostSerializer < ActiveModel::Serializer
+  attributes :id, :body
+  attribute :commenter_names
+  has_many :comments, serializer: AMSCommentSerializer
+
+  def commenter_names
+    object.commenters.pluck(:name)
+  end
+end
+
+# --- Blueprint serializers ---
+
+require "blueprinter"
+
+class CommentBlueprint < Blueprinter::Base
+  fields :id, :body
+end
+
+class PostBlueprint < Blueprinter::Base
+  fields :id, :body, :commenter_names
+  association :comments, blueprint: CommentBlueprint
+
+  def commenter_names
+    commenters.pluck(:name)
+  end
+end
+
+# --- JBuilder serializers ---
+
+require "jbuilder"
+
+class Post
+  def to_builder
+    Jbuilder.new do |post|
+      post.call(self, :id, :body, :commenter_names, :comments)
+    end
+  end
+
+  def commenter_names
+    commenters.pluck(:name)
+  end
+end
+
+class Comment
+  def to_builder
+    Jbuilder.new do |comment|
+      comment.call(self, :id, :body)
+    end
+  end
+end
+
+# --- JSONAPI:Serializer serializers / (successor of fast_jsonapi) ---
+
+class JsonApiStandardCommentSerializer
+  include JSONAPI::Serializer
+
+  attribute :id
+  attribute :body
+end
+
+class JsonApiStandardPostSerializer
+  include JSONAPI::Serializer
+
+  # set_type :post  # optional
+  attribute :id
+  attribute :body
+  attribute :commenter_names
+
+  attribute :comments do |post|
+    post.comments.map { |comment| JsonApiSameFormatCommentSerializer.new(comment) }
+  end
+end
+
+# --- JSONAPI:Serializer serializers that format the code the same flat way as the other gems here ---
+
+# code to convert from JSON:API output to "flat" JSON, like the other serializers build
+class JsonApiSameFormatSerializer
+  include JSONAPI::Serializer
+
+  def as_json(*_options)
+    hash = serializable_hash
+
+    if hash[:data].is_a? Hash
+      hash[:data][:attributes]
+
+    elsif hash[:data].is_a? Array
+      hash[:data].pluck(:attributes)
+
+    elsif hash[:data].nil?
+      { }
+
+    else
+      raise "unexpected data type #{hash[:data].class}"
+    end
+  end
+end
+
+class JsonApiSameFormatCommentSerializer < JsonApiSameFormatSerializer
+  attribute :id
+  attribute :body
+end
+
+class JsonApiSameFormatPostSerializer < JsonApiSameFormatSerializer
+  attribute :id
+  attribute :body
+  attribute :commenter_names
+
+  attribute :comments do |post|
+    post.comments.map { |comment| JsonApiSameFormatCommentSerializer.new(comment) }
+  end
+end
+
+# --- Representable serializers ---
+
+require "representable"
+
+class CommentRepresenter < Representable::Decorator
+  include Representable::JSON
+
+  property :id
+  property :body
+end
+
+class PostRepresenter < Representable::Decorator
+  include Representable::JSON
+
+  property :id
+  property :body
+  property :commenter_names
+  collection :comments
+
+  def commenter_names
+    commenters.pluck(:name)
+  end
+end
+
+# --- Test data creation ---
+
+post = Post.create!(body: 'post')
+user1 = User.create!(name: 'John')
+user2 = User.create!(name: 'Jane')
+post.comments.create!(commenter: user1, body: 'Comment1')
+post.comments.create!(commenter: user2, body: 'Comment2')
+post.reload
+
+# --- Store the serializers in procs ---
+
+alba = Proc.new { AlbaPostResource.new(post).serialize }
+alba_inline = Proc.new do
+  Alba.serialize(post) do
+    attributes :id, :body
+    attribute :commenter_names do |post|
+      post.commenters.pluck(:name)
+    end
+    many :comments do
+      attributes :id, :body
+    end
+  end
+end
+ams = Proc.new { AMSPostSerializer.new(post, {}).to_json }
+blueprinter = Proc.new { PostBlueprint.render(post) }
+jbuilder = Proc.new { post.to_builder.target! }
+jsonapi = proc { JsonApiStandardPostSerializer.new(post).to_json }
+jsonapi_same_format = proc { JsonApiSameFormatPostSerializer.new(post).to_json }
+rails = Proc.new { ActiveSupport::JSON.encode(post.serializable_hash(include: :comments)) }
+representable = Proc.new { PostRepresenter.new(post).to_json }
+
+# --- Execute the serializers to check their output ---
+
+puts "Serializer outputs ----------------------------------"
+{
+  alba: alba,
+  alba_inline: alba_inline,
+  ams: ams,
+  blueprinter: blueprinter,
+  jbuilder: jbuilder, # different order
+  jsonapi: jsonapi, # nested JSON:API format
+  jsonapi_same_format: jsonapi_same_format,
+  rails: rails,
+  representable: representable
+}.each { |name, serializer| puts "#{name.to_s.ljust(24, ' ')} #{serializer.call}" }
+
+# --- Run the benchmarks ---
+
+require 'benchmark'
+time = 1000
+Benchmark.bmbm do |x|
+  x.report(:alba) { time.times(&alba) }
+  x.report(:alba_inline) { time.times(&alba_inline) }
+  x.report(:ams) { time.times(&ams) }
+  x.report(:blueprinter) { time.times(&blueprinter) }
+  x.report(:jbuilder) { time.times(&jbuilder) }
+  x.report(:jsonapi) { time.times(&jsonapi) }
+  x.report(:jsonapi_same_format) { time.times(&jsonapi_same_format) }
+  x.report(:rails) { time.times(&rails) }
+  x.report(:representable) { time.times(&representable) }
+end
+
+require 'benchmark/ips'
+Benchmark.ips do |x|
+  x.report(:alba, &alba)
+  x.report(:alba_inline, &alba_inline)
+  x.report(:ams, &ams)
+  x.report(:blueprinter, &blueprinter)
+  x.report(:jbuilder, &jbuilder)
+  x.report(:jsonapi, &jsonapi)
+  x.report(:jsonapi_same_format, &jsonapi_same_format)
+  x.report(:rails, &rails)
+  x.report(:representable, &representable)
+
+  x.compare!
+end

data/codecov.yml

@@ -0,0 +1,5 @@
+coverage:
+  status:
+    project:
+      default:
+        informational: true

data/gemfiles/all.gemfile

@@ -0,0 +1,19 @@
+source 'https://rubygems.org'
+
+gem 'activesupport', require: false # For backend
+gem 'ffaker', require: false # For testing
+gem 'minitest', '~> 5.14' # For test
+gem 'rake', '~> 13.0' # For test and automation
+gem 'rubocop', '>= 0.79.0', require: false # For lint
+gem 'rubocop-minitest', '~> 0.11.0', require: false # For lint
+gem 'rubocop-performance', '~> 1.10.1', require: false # For lint
+gem 'rubocop-rake', '>= 0.5.1', require: false # For lint
+gem 'rubocop-sensible', '~> 0.3.0', require: false # For lint
+gem 'simplecov', '~> 0.21.0', require: false # For test coverage
+gem 'simplecov-cobertura', require: false # For test coverage
+gem 'yard', require: false
+
+platforms :ruby do
+  gem 'oj', '~> 3.11', require: false # For backend
+  gem 'ruby-prof', require: false # For performance profiling
+end

data/gemfiles/without_active_support.gemfile

@@ -0,0 +1,17 @@
+source 'https://rubygems.org'
+
+gem 'minitest', '~> 5.14' # For test
+gem 'rake', '~> 13.0' # For test and automation
+gem 'rubocop', '>= 0.79.0', require: false # For lint
+gem 'rubocop-minitest', '~> 0.11.0', require: false # For lint
+gem 'rubocop-performance', '~> 1.10.1', require: false # For lint
+gem 'rubocop-rake', '>= 0.5.1', require: false # For lint
+gem 'rubocop-sensible', '~> 0.3.0', require: false # For lint
+gem 'simplecov', '~> 0.21.0', require: false # For test coverage
+gem 'simplecov-cobertura', require: false # For test coverage
+gem 'yard', require: false
+
+platforms :ruby do
+  gem 'oj', '~> 3.11', require: false # For backend
+  gem 'ruby-prof', require: false # For performance profiling
+end

data/gemfiles/without_oj.gemfile

@@ -0,0 +1,17 @@
+source 'https://rubygems.org'
+
+gem 'activesupport', require: false # For backend
+gem 'minitest', '~> 5.14' # For test
+gem 'rake', '~> 13.0' # For test and automation
+gem 'rubocop', '>= 0.79.0', require: false # For lint
+gem 'rubocop-minitest', '~> 0.11.0', require: false # For lint
+gem 'rubocop-performance', '~> 1.10.1', require: false # For lint
+gem 'rubocop-rake', '>= 0.5.1', require: false # For lint
+gem 'rubocop-sensible', '~> 0.3.0', require: false # For lint
+gem 'simplecov', '~> 0.21.0', require: false # For test coverage
+gem 'simplecov-cobertura', require: false # For test coverage
+gem 'yard', require: false
+
+platforms :ruby do
+  gem 'ruby-prof', require: false # For performance profiling
+end

data/lib/alba.rb

@@ -1,5 +1,4 @@
 require_relative 'alba/version'
-require_relative 'alba/serializer'
 require_relative 'alba/resource'
 
 # Core module
@@ -11,8 +10,7 @@ module Alba
   class UnsupportedBackend < Error; end
 
   class << self
-    attr_reader :backend, :encoder
-    attr_accessor :default_serializer
+    attr_reader :backend, :encoder, :inferring, :_on_error
 
     # Set the backend, which actually serializes object into JSON
     #
@@ -28,25 +26,54 @@ module Alba
     # Serialize the object with inline definitions
     #
     # @param object [Object] the object to be serialized
-    # @param with [nil, Proc, Alba::Serializer] selializer
+    # @param key [Symbol]
     # @param block [Block] resource block
     # @return [String] serialized JSON string
     # @raise [ArgumentError] if block is absent or `with` argument's type is wrong
-    def serialize(object, with: nil, &block)
+    def serialize(object, key: nil, &block)
       raise ArgumentError, 'Block required' unless block
 
-      resource_class.class_eval(&block)
-      resource = resource_class.new(object)
-      with ||= @default_serializer
-      resource.serialize(with: with)
+      klass = Class.new
+      klass.include(Alba::Resource)
+      klass.class_eval(&block)
+      resource = klass.new(object)
+      resource.serialize(key: key)
+    end
+
+    # Enable inference for key and resource name
+    def enable_inference!
+      begin
+        require 'active_support/inflector'
+      rescue LoadError
+        raise ::Alba::Error, 'To enable inference, please install `ActiveSupport` gem.'
+      end
+      @inferring = true
+    end
+
+    # Disable inference for key and resource name
+    def disable_inference!
+      @inferring = false
+    end
+
+    # Set error handler
+    #
+    # @param [Symbol] handler
+    # @param [Block]
+    def on_error(handler = nil, &block)
+      raise ArgumentError, 'You cannot specify error handler with both Symbol and block' if handler && block
+      raise ArgumentError, 'You must specify error handler with either Symbol or block' unless handler || block
+
+      @_on_error = handler || block
     end
 
     private
 
     def set_encoder
       @encoder = case @backend
-                 when :oj
+                 when :oj, :oj_strict
                    try_oj
+                 when :oj_rails
+                   try_oj(mode: :rails)
                  when :active_support
                    try_active_support
                  when nil, :default, :json
@@ -56,10 +83,11 @@ module Alba
                  end
     end
 
-    def try_oj
+    def try_oj(mode: :strict)
       require 'oj'
-      ->(hash) { Oj.dump(hash, mode: :strict) }
+      ->(hash) { Oj.dump(hash, mode: mode) }
     rescue LoadError
+      Kernel.warn '`Oj` is not installed, falling back to default JSON encoder.'
       default_encoder
     end
 
@@ -67,6 +95,7 @@ module Alba
       require 'active_support/json'
       ->(hash) { ActiveSupport::JSON.encode(hash) }
     rescue LoadError
+      Kernel.warn '`ActiveSupport` is not installed, falling back to default JSON encoder.'
       default_encoder
     end
 
@@ -76,14 +105,8 @@ module Alba
         JSON.dump(hash)
       end
     end
-
-    def resource_class
-      @resource_class ||= begin
-        klass = Class.new
-        klass.include(Alba::Resource)
-      end
-    end
   end
 
   @encoder = default_encoder
+  @_on_error = :raise
 end