alba 3.4.0 → 3.6.0

data/HACKING.md

@@ -1,42 +0,0 @@
-# Hacking document
-
-This document is intended to provide detailed information about the internal design and implementation of Alba. You are recommended to read through it if you want to hack Alba.
-
-## Design
-
-The design of Alba is simple. `Alba::Resource` module is the only interface end users use by `include`ing it. Other classes and modules are referenced by `Alba::Resource`.
-
-When a class `include`s `Alba::Resource` module it defines `ClassMethods` such as `attributes` and `InstanceMethods` such as `serialize`. Instance methods work with information collected by class methods.
-
-## Methods
-
-The main methods users directly use are listed below.
-
-Class methods (DSL):
-
-* `attribute` for block style attribute
-* `attributes` for symbol style attribute
-* `association` and its aliases such as `one` for association
-* `nested` for nested attribute
-
-Instance methods:
-
-* `serializable_hash` and `to_h` for hash from target object
-* `serialize` and `to_json` for serialized JSON string
-
-Other methods are rather trivial. They'll be added to this list when it turned out it's important enough.
-
-## Implementation
-
-In `Alba::Resource` module there are some things to note.
-
-`@object` is an object for serialization. It's either a singular object or a collection.
-
-Attribute object can be either `Symbol`, `Proc`, `Alba::Association` or `Alba::TypedAttribute`.
-
-* `Symbol` attributes come from `attributes` method and are sent to `__send__` as method name
-* `Proc` attributes come from `attribute` method and are `instance_exec`uted
-* `Alba::Association` attributes come from `association` method and `to_h` method on the object is called
-* `Alba::TypedAttribute` attributes come when users specify `type` option and `value` method on the object is called
-
-When users provide `if` option, the attribute object becomes an `Array`. It contains two element, attribute itself and condition.

data/Rakefile

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler/gem_tasks'
-require 'rake/testtask'
-
-if ENV['BUNDLE_GEMFILE'] == File.expand_path('Gemfile') || ENV['BUNDLE_GEMFILE'].empty? || ENV['BUNDLE_GEMFILE'].nil?
-  ENV['BUNDLE_GEMFILE'] = File.expand_path('Gemfile')
-end
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'test'
-  t.libs << 'lib'
-  file_list = ENV['BUNDLE_GEMFILE'] == File.expand_path('Gemfile') ? FileList['test/**/*_test.rb'] : FileList['test/dependencies/test_dependencies.rb']
-  t.test_files = file_list
-end
-
-task default: :test

data/SECURITY.md

@@ -1,12 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-| Version | Supported          |
-| ------- | ------------------ |
-| 1.x.y   | :white_check_mark: |
-| < 1.0   | :x:                |
-
-## Reporting a Vulnerability
-
-If you find a vulnerability of Alba, please contact me (OKURA Masafumi) via [email](masafumi.o1988@gmail.com). I'll report back within a few days.

data/alba.gemspec

@@ -1,33 +0,0 @@
-require_relative 'lib/alba/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = 'alba'
-  spec.version       = Alba::VERSION
-  spec.authors       = ['OKURA Masafumi']
-  spec.email         = ['masafumi.o1988@gmail.com']
-
-  spec.summary       = 'Alba is the fastest JSON serializer for Ruby.'
-  spec.description   = "Alba is the fastest JSON serializer for Ruby. It focuses on performance, flexibility and usability."
-  spec.homepage      = 'https://github.com/okuramasafumi/alba'
-  spec.license       = 'MIT'
-  spec.required_ruby_version = Gem::Requirement.new('>= 3.0.0')
-
-  spec.metadata = {
-    'bug_tracker_uri' => 'https://github.com/okuramasafumi/alba/issues',
-    'changelog_uri' => 'https://github.com/okuramasafumi/alba/blob/main/CHANGELOG.md',
-    'documentation_uri' => 'https://rubydoc.info/github/okuramasafumi/alba',
-    'source_code_uri' => 'https://github.com/okuramasafumi/alba',
-    'rubygems_mfa_required' => 'true'
-  }
-
-  # 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.
-  spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  end
-  spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
-
-  spec.add_dependency "ostruct", "~> 0.6"
-end

data/benchmark/Gemfile

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-source 'https://rubygems.org'
-git_source(:github) { |repo| "https://github.com/#{repo}.git" }
-
-gem 'active_model_serializers'
-gem 'activerecord', '~> 7.1'
-gem 'alba', path: '../'
-gem 'benchmark-ips'
-gem 'benchmark-memory'
-gem 'blueprinter'
-gem 'fast_serializer_ruby'
-gem 'jbuilder'
-gem 'jserializer'
-gem 'multi_json'
-gem 'oj'
-gem 'oj_serializers'
-gem 'panko_serializer'
-gem 'pg'
-gem 'primalize'
-gem 'representable'
-gem 'simple_ams'
-gem 'sqlite3', '~> 1.4'
-gem 'turbostreamer'

data/benchmark/README.md

@@ -1,119 +0,0 @@
-## Benchmark for json serializers
-
-This directory contains a few different benchmark scripts. They all use inline Bundler definitions so you can run them by `ruby benchmark/collection.rb` for instance.
-
-## Result
-
-As a reference, here's the benchmark result run in my (@okuramasafumi) machine.
-
-Machine spec:
-
-|Key|Value|
-|---|---|
-|OS|macOS 14.7|
-|CPU|Apple M1 Pro|
-|RAM|16GB|
-|Ruby|ruby 3.3.5 (2024-09-03 revision ef084cc8f4) [arm64-darwin23]|
-
-Library versions:
-
-|Library|Version|
-|---|---|
-|alba|3.2.0|
-|blueprinter|1.1.0|
-|fast_serializer_ruby|0.6.9|
-|jserializer|0.2.1|
-|oj|3.16.6|
-|simple_ams|0.2.6|
-|representable|3.2.0|
-|turbostreamer|1.11.0|
-|jbuilder|2.13.0|
-|panko_serializer|0.8.2|
-|active_model_serializers|0.10.14|
-
-`benchmark-ips` with `Oj.optimize_rails`:
-
-```
-Comparison:
-               panko:      447.0 i/s
-         jserializer:      168.9 i/s - 2.65x  slower
-         alba_inline:      149.4 i/s - 2.99x  slower
-                alba:      146.5 i/s - 3.05x  slower
-       turbostreamer:      138.7 i/s - 3.22x  slower
-               rails:      105.6 i/s - 4.23x  slower
-     fast_serializer:       97.6 i/s - 4.58x  slower
-         blueprinter:       66.7 i/s - 6.70x  slower
-       representable:       50.6 i/s - 8.83x  slower
-          simple_ams:       35.5 i/s - 12.57x  slower
-                 ams:       14.8 i/s - 30.25x  slower
-```
-
-`benchmark-ips` without `Oj.optimize_rails`:
-
-```
-Comparison:
-               panko:      457.9 i/s
-         jserializer:      165.9 i/s - 2.76x  slower
-                alba:      160.1 i/s - 2.86x  slower
-         alba_inline:      158.5 i/s - 2.89x  slower
-       turbostreamer:      141.7 i/s - 3.23x  slower
-     fast_serializer:       96.2 i/s - 4.76x  slower
-               rails:       87.2 i/s - 5.25x  slower
-         blueprinter:       67.4 i/s - 6.80x  slower
-       representable:       43.4 i/s - 10.55x  slower
-          simple_ams:       34.7 i/s - 13.20x  slower
-                 ams:       14.2 i/s - 32.28x  slower
-```
-
-`benchmark-ips` with `Oj.optimize_rail` and YJIT:
-
-```
-Comparison:
-               panko:      676.6 i/s
-         jserializer:      285.3 i/s - 2.37x  slower
-       turbostreamer:      264.2 i/s - 2.56x  slower
-                alba:      258.9 i/s - 2.61x  slower
-     fast_serializer:      179.0 i/s - 3.78x  slower
-               rails:      150.7 i/s - 4.49x  slower
-         alba_inline:      131.5 i/s - 5.15x  slower
-         blueprinter:      110.0 i/s - 6.15x  slower
-       representable:       73.5 i/s - 9.21x  slower
-          simple_ams:       62.8 i/s - 10.77x  slower
-                 ams:       20.4 i/s - 33.10x  slower
-```
-
-`benchmark-ips` with YJIT and without `Oj.optimize_rail`:
-
-```
-Comparison:
-               panko:      701.9 i/s
-                alba:      311.1 i/s - 2.26x  slower
-         jserializer:      281.6 i/s - 2.49x  slower
-       turbostreamer:      240.4 i/s - 2.92x  slower
-     fast_serializer:      180.5 i/s - 3.89x  slower
-         alba_inline:      135.6 i/s - 5.18x  slower
-               rails:      131.4 i/s - 5.34x  slower
-         blueprinter:      110.7 i/s - 6.34x  slower
-       representable:       70.5 i/s - 9.96x  slower
-          simple_ams:       57.3 i/s - 12.24x  slower
-                 ams:       20.3 i/s - 34.51x  slower
-```
-
-`benchmark-memory`:
-
-```
-Comparison:
-               panko:     259178 allocated
-       turbostreamer:     817800 allocated - 3.16x more
-         jserializer:     826425 allocated - 3.19x more
-                alba:     846465 allocated - 3.27x more
-         alba_inline:     867361 allocated - 3.35x more
-     fast_serializer:    1474345 allocated - 5.69x more
-               rails:    2265905 allocated - 8.74x more
-         blueprinter:    2469905 allocated - 9.53x more
-       representable:    4994281 allocated - 19.27x more
-                 ams:    5233265 allocated - 20.19x more
-          simple_ams:    9506817 allocated - 36.68x more
-```
-
-Conclusion: panko is extremely fast but it's a C extension gem. As pure Ruby gems, Alba, `turbostreamer` and `jserializer` are notably faster than others, but Alba is slightly slower than other two. With `Oj.optimize_rails`, `jbuilder` and Rails standard serialization are also fast.

data/benchmark/collection.rb

@@ -1,275 +0,0 @@
-# Benchmark script to run varieties of JSON serializers
-# Fetch Alba from local, otherwise fetch latest from RubyGems
-
-require_relative 'prep'
-
-# --- 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"
-
-ActiveModelSerializers.logger = Logger.new(nil)
-
-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
-
-# --- 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
-
-# --- Jserializer serializers ---
-
-require 'jserializer'
-
-class JserializerCommentSerializer < Jserializer::Base
-  attributes :id, :body
-end
-
-class JserializerPostSerializer < Jserializer::Base
-  attributes :id, :body, :commenter_names
-  has_many :comments, serializer: JserializerCommentSerializer
-  def commenter_names
-    object.commenters.pluck(:name)
-  end
-end
-
-# --- Panko serializers ---
-#
-
-require "panko_serializer"
-
-class PankoCommentSerializer < Panko::Serializer
-  attributes :id, :body
-end
-
-
-class PankoPostSerializer < Panko::Serializer
-  attributes :id, :body, :commenter_names
-
-  has_many :comments, serializer: PankoCommentSerializer
-
-  def commenter_names
-    object.commenters.pluck(:name)
-  end
-end
-
-# --- Representable serializers ---
-
-require "representable"
-
-class CommentRepresenter < Representable::Decorator
-  include Representable::JSON
-
-  property :id
-  property :body
-end
-
-class PostsRepresenter < Representable::Decorator
-  include Representable::JSON::Collection
-
-  items class: Post do
-    property :id
-    property :body
-    property :commenter_names
-    collection :comments
-  end
-
-  def commenter_names
-    commenters.pluck(:name)
-  end
-end
-
-# --- SimpleAMS serializers ---
-
-require "simple_ams"
-
-class SimpleAMSCommentSerializer
-  include SimpleAMS::DSL
-
-  attributes :id, :body
-end
-
-class SimpleAMSPostSerializer
-  include SimpleAMS::DSL
-
-  attributes :id, :body
-  attribute :commenter_names
-  has_many :comments, serializer: SimpleAMSCommentSerializer
-
-  def commenter_names
-    object.commenters.pluck(:name)
-  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|
-  post = Post.create!(body: "post#{i}")
-  user1 = User.create!(name: "John#{i}")
-  user2 = User.create!(name: "Jane#{i}")
-  10.times do |n|
-    post.comments.create!(commenter: user1, body: "Comment1_#{i}_#{n}")
-    post.comments.create!(commenter: user2, body: "Comment2_#{i}_#{n}")
-  end
-end
-
-posts = Post.all.includes(:comments, :commenters)
-
-# --- Store the serializers in procs ---
-
-alba = Proc.new { AlbaPostResource.new(posts).serialize }
-alba_inline = Proc.new do
-  Alba.serialize(posts) 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 { ActiveModelSerializers::SerializableResource.new(posts, {each_serializer: AMSPostSerializer}).to_json }
-blueprinter = Proc.new { PostBlueprint.render(posts) }
-fast_serializer = Proc.new { FastSerializerPostResource.new(posts).to_json }
-jserializer = Proc.new { JserializerPostSerializer.new(posts, is_collection: true).to_json }
-panko = proc { Panko::ArraySerializer.new(posts, each_serializer: PankoPostSerializer).to_json }
-rails = Proc.new do
-  ActiveSupport::JSON.encode(posts.map{ |post| post.serializable_hash(include: :comments) })
-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 "Checking outputs..."
-correct = alba.call
-parsed_correct = JSON.parse(correct)
-{
-  alba_inline: alba_inline,
-  ams: ams,
-  blueprinter: blueprinter,
-  fast_serializer: fast_serializer,
-  jserializer: jserializer,
-  panko: panko,
-  rails: rails,
-  representable: representable,
-  simple_ams: simple_ams,
-  turbostreamer: turbostreamer
-}.each do |name, serializer|
-  result = serializer.call
-  parsed_result = JSON.parse(result)
-  puts "#{name} yields wrong output: #{parsed_result}" unless parsed_result == parsed_correct
-end
-
-# --- Run the benchmarks ---
-
-benchmark_body = lambda do |x|
-  x.report(:alba, &alba)
-  x.report(:alba_inline, &alba_inline)
-  x.report(:ams, &ams)
-  x.report(:blueprinter, &blueprinter)
-  x.report(:fast_serializer, &fast_serializer)
-  x.report(:jserializer, &jserializer)
-  x.report(:panko, &panko)
-  x.report(:rails, &rails)
-  x.report(:representable, &representable)
-  x.report(:simple_ams, &simple_ams)
-  x.report(:turbostreamer, &turbostreamer)
-
-  x.compare!
-end
-
-require 'benchmark/ips'
-Benchmark.ips(&benchmark_body)
-
-require 'benchmark/memory'
-Benchmark.memory(&benchmark_body)

data/benchmark/prep.rb

@@ -1,56 +0,0 @@
-# --- Test data model setup ---
-
-RubyVM::YJIT.enable if ENV["YJIT"]
-require "csv"
-require "pg"
-require "active_record"
-require "active_record/connection_adapters/postgresql_adapter"
-require "logger"
-require "oj"
-require "sqlite3"
-Oj.optimize_rails unless ENV['NO_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