alba 2.0.1 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9018588ddacac0cf7db8dac1d23c8165665c7a93976b581d25ab51357ead7834
-  data.tar.gz: 6bde71c65d8fb6965d46cea2769cd9a97d4f76407136e47de4392cdfa1a58333
+  metadata.gz: c68ec07a949642b11dfd36b3bf748249d0d725178ece9dd331e373fc2339cb8a
+  data.tar.gz: 7704431d69f96b88d9632c114dae90cfceae018c8372c8736c091efd2050b65a
 SHA512:
-  metadata.gz: a7d907446dad8ff8a19814cbf27ba74bfc84a0f00fae8366f561efd5de03e1ac16d66f3b31641e8ec83b5081e6e5fc61074c5a5e47509343fade989ab65e41da
-  data.tar.gz: d81e0055f6899698d70ab1522e71adc8ce9e22e3a8855ad2a3db8b54e551d2ea459a77bc92242bc5c7f8121d150c322f3b99f6d286fd7118f5df2f94d0dc3fdc
+  metadata.gz: 98ca1b6fa7c6851f3a69d6d1cb54cd782a3142fccfb33391eb08cbc093ad691496a8fdb9e93e5ce89543032a0003ab8b60022ca8bbbba81c73de249b571a3fa6
+  data.tar.gz: 3756fe21da92358031a722d83b7169ef81e8749ccf6430bef577dfaac7ab4a80e68c07c6e0205497e54692f74b16e66aabad390db6eda09e486a732387541630

data/.github/workflows/main.yml

@@ -8,7 +8,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
-        ruby: [2.6, 2.7, 3.0, 3.1, head, jruby, truffleruby]
+        ruby: [2.7, 3.0, 3.1, 3.2, head, jruby, truffleruby]
         gemfile: [all, without_active_support, without_oj]
         exclude:
           - os: windows-latest

data/.rubocop.yml

@@ -16,7 +16,7 @@ AllCops:
     - 'script/**/*.rb'
   NewCops: enable
   EnabledByDefault: true
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 2.7
 
 # Items in Gemfile is dev dependencies and we don't have to specify versions.
 Bundler/GemVersion:
@@ -58,6 +58,11 @@ Metrics/ParameterLists:
   Exclude:
     - 'test/**/*.rb'
 
+# Putting extra empty line is not valuable in test
+# We prefer shorter test code
+Minitest/EmptyLineBeforeAssertionMethods:
+  Enabled: false
+
 # We need to eval resource code to test errors on resource classes
 Security/Eval:
   Exclude:

data/CHANGELOG.md

@@ -6,6 +6,39 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.2.0] 2023-02-17
+
+### Added
+
+- Rails integration to set default inflector [#298](https://github.com/okuramasafumi/alba/pull/298)
+
+### Fixed
+
+- Fix cascade not working with association and inheritance [#300](https://github.com/okuramasafumi/alba/pull/300)
+
+### Removed
+
+- Drop support of Ruby 2.6
+
+## [2.1.0] 2022-12-03
+
+### Added
+
+- Add `select` method for filtering attributes [#270](https://github.com/okuramasafumi/alba/pull/270)
+- Allow ConditionalAttribute with 2-arity proc to reject nil attributes [#273](https://github.com/okuramasafumi/alba/pull/273)
+
+### Fixed
+
+- Add support for proc resource in one polymorphic associations [#281](https://github.com/okuramasafumi/alba/pull/281)
+
+### Deprecated
+
+- Deprecate `inference` related methods in favor of a unified `inflector` interface.
+  Deprecated methods are: `Alba.enable_inference!`, `Alba.disable_inference!`, and `Alba.inferring`.
+  Use `Alba.inflector = :active_support/:dry` or `Alba.inflector = SomeInflector` to enable.
+  Use `Alba.inflector = nil` to disable.
+  Use `Alba.inflector` to check if enabled.
+
 ## [2.0.1] 2022-11-02
 
 ### Fix
@@ -17,9 +50,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Breaking changes
 
-- All Hash-related methods now return String key instead of Symbol key  
-    This affects all users, but you can use `deep_symbolize_keys` in Rails environment if you prefer Symbol keys
-    Some DSLs that take key argument such as `on_nil` and `on_error`, are also affected
+- All Hash-related methods now return String keys instead of Symbol keys.
+    This affects all users, but you can use `deep_symbolize_keys` in Rails environment if you prefer Symbol keys, or `with_indifferent_access` to support both String and Symbol keys.
+    Some DSLs that take key argument such as `on_nil` and `on_error`, are also affected.
 - Remove deprecated methods: `Resource#to_hash`, `Resource.ignoring`, `Alba.on_nil`, `Alba.on_error`, `Alba.enable_root_key_transformation!` and `Alba.disable_root_key_transformation!`
 - If using `transform_keys`, the default inflector is no longer set by default [d02245c8](https://github.com/okuramasafumi/alba/commit/d02245c87e9df303cb20e354a81e5457ea460bdd#diff-ecd8c835d2390b8cb89e7ff75e599f0c15cdbe18c30981d6090f4a515566686f)
     To retain this functionality in Rails, add an initializer with the following:

data/CONTRIBUTING.md

@@ -27,4 +27,4 @@ You're more than welcomed to submit a Pull Request! You are expected to follow t
 ## Documents
 
 * [code of conduct](https://github.com/okuramasafumi/alba/blob/master/CODE_OF_CONDUCT.md) for all contributors
-* [hacking document](https://github.com/okuramasafumi/alba/blob/master/DESIGN.md) for those who want to know the internal of Alba
+* [hacking document](https://github.com/okuramasafumi/alba/blob/main/HACKING.md) for those who want to know the internal of Alba

data/Gemfile

@@ -6,12 +6,12 @@ gemspec
 gem 'activesupport', require: false # For backend
 gem 'dry-inflector', require: false # For inflection
 gem 'ffaker', require: false # For testing
-gem 'inch', require: false # For inline documents
 gem 'minitest', '~> 5.14' # For test
+gem 'railties', require: false # For Rails integration testing
 gem 'rake', '~> 13.0' # For test and automation
 gem 'rubocop', '>= 0.79.0', require: false # For lint
-gem 'rubocop-minitest', '~> 0.23.0', require: false # For lint
-gem 'rubocop-performance', '~> 1.15.0', require: false # For lint
+gem 'rubocop-minitest', '>= 0.25.0', require: false # For lint
+gem 'rubocop-performance', '>= 1.15.0', 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 'ruby-lsp', require: false # For language server

data/README.md

@@ -23,6 +23,16 @@ If you have feature requests or interesting ideas, join us with [Ideas](https://
 
 If you want to know more about Alba, there's a [screencast](https://hanamimastery.com/episodes/21-serialization-with-alba) created by Sebastian from [Hanami Mastery](https://hanamimastery.com/). It covers basic features of Alba and how to use it in Hanami.
 
+## What users say about Alba
+
+> Alba is a well-maintained JSON serialization engine, for Ruby, JRuby, and TruffleRuby implementations, and what I like in this gem - except of its speed, is the easiness of use, no dependencies and the fact it plays well with any Ruby application!
+
+[Hanami Mastery by Seb Wilgosz](https://hanamimastery.com/episodes/21-serialization-with-alba)
+
+> Alba is more feature-rich and pretty fast, too
+
+[Gemfile of dreams by Evil Martians](https://evilmartians.com/chronicles/gemfile-of-dreams-libraries-we-use-to-build-rails-apps)
+
 ## Why Alba?
 
 Because it's fast, easy and feature rich!
@@ -37,7 +47,7 @@ Alba is easy to use because there are only a few methods to remember. It's also
 
 ### Feature rich
 
-While Alba's core is simple, it provides additional features when you need them, For example, Alba provides [a way to control circular associations](#circular-associations-control), [inferring resource classes, root key and associations](#inference) and [supports layouts](#layout).
+While Alba's core is simple, it provides additional features when you need them, For example, Alba provides [a way to control circular associations](#circular-associations-control), [root key and association resource name inference](#root-key-and-association-resource-name-inference) and [supports layouts](#layout).
 
 ## Installation
 
@@ -57,7 +67,7 @@ Or install it yourself as:
 
 ## Supported Ruby versions
 
-Alba supports CRuby 2.5 and higher and latest JRuby and TruffleRuby.
+Alba supports CRuby 2.7 and higher and latest JRuby and TruffleRuby.
 
 ## Documentation
 
@@ -68,10 +78,9 @@ You can find the documentation on [RubyDoc](https://rubydoc.info/github/okuramas
 * Conditional attributes and associations
 * Selectable backend
 * Key transformation
-* Root key inference
+* Root key and association resource name inference
 * Error handling
 * Nil handling
-* Resource name inflection based on association name
 * Circular associations control
 * [Experimental] Types for validation and conversion
 * Layout
@@ -113,19 +122,33 @@ You can consider setting a backend with Symbol as a shortcut to set encoder.
 
 #### Inference configuration
 
-You can enable inference feature using `enable_inference!` method.
+You can enable the inference feature using the `Alba.inflector = SomeInflector` API. For example, in a Rails initializer:
 
 ```ruby
-Alba.enable_inference!(with: :active_support)
+Alba.inflector = :active_support
 ```
 
-You can choose which inflector Alba uses for inference. Possible value for `with` option are:
+You can choose which inflector Alba uses for inference. Possible options are:
 
 - `:active_support` for `ActiveSupport::Inflector`
 - `:dry` for `Dry::Inflector`
-- any object which responds to some methods (see [below](#custom-inflector))
+- any object which conforms to the protocol (see [below](#custom-inflector))
+
+To disable inference, set the `inflector` to `nil`:
+
+```ruby
+Alba.inflector = nil
+```
 
-For the details, see [Error handling section](#error-handling)
+To check if inference is enabled etc, inspect the return value of `inflector`:
+
+```ruby
+if Alba.inflector == nil
+  puts "inflector not set"
+else
+  puts "inflector is set to #{Alba.inflector}"
+end
+```
 
 ### Simple serialization with root key
 
@@ -157,7 +180,7 @@ end
 
 user = User.new(1, 'Masafumi OKURA', 'masafumi@example.com')
 UserResource.new(user).serialize
-# => "{\"user\":{\"id\":1,\"name\":\"Masafumi OKURA\",\"name_with_email\":\"Masafumi OKURA: masafumi@example.com\"}}"
+# => '{"user":{"id":1,"name":"Masafumi OKURA","name_with_email":"Masafumi OKURA: masafumi@example.com"}}'
 ```
 
 You can define instance methods on resources so that you can use it as attribute name in `attributes`.
@@ -184,7 +207,7 @@ This even works with users collection.
 user1 = User.new(1, 'Masafumi OKURA', 'masafumi@example.com')
 user2 = User.new(2, 'Test User', 'test@example.com')
 UserResource.new([user1, user2]).serialize
-# => "{\"users\":[{\"id\":1,\"name\":\"Masafumi OKURA\",\"name_with_email\":\"Masafumi OKURA: masafumi@example.com\"},{\"id\":2,\"name\":\"Test User\",\"name_with_email\":\"Test User: test@example.com\"}]}"
+# => '{"users":[{"id":1,"name":"Masafumi OKURA","name_with_email":"Masafumi OKURA: masafumi@example.com"},{"id":2,"name":"Test User","name_with_email":"Test User: test@example.com"}]}'
 ```
 
 If you have a simple case where you want to change only the name, you can use the Symbol to Proc shortcut:
@@ -210,8 +233,8 @@ class UserResource
 end
 
 user = User.new(1, 'Masa', 'test@example.com')
-UserResource.new(user).serialize # => "{\"name\":\"foo\"}"
-UserResource.new(user, params: {upcase: true}).serialize # => "{\"name\":\"FOO\"}"
+UserResource.new(user).serialize # => '{"name":"Masa"}'
+UserResource.new(user, params: {upcase: true}).serialize # => '{"name":"MASA"}'
 ```
 
 ### Serialization with associations
@@ -368,9 +391,11 @@ UserResource.new(user).serialize
 # => '{"id":1,"my_articles":[{"title":"Hello World!"}]}'
 ```
 
-You can omit resource option if you enable Alba's inference feature.
+You can omit the resource option if you enable Alba's [inference](#inference-configuration) feature.
 
 ```ruby
+Alba.inflector = :active_support
+
 class UserResource
   include Alba::Resource
 
@@ -390,7 +415,7 @@ class UserResource
 
   attributes :id
 
-  many :articles, ->(article) { article.with_comment? ? ArticleWithCommentResource : ArticleResource }
+  many :articles, resource: ->(article) { article.with_comment? ? ArticleWithCommentResource : ArticleResource }
 end
 ```
 
@@ -564,13 +589,19 @@ end
 Foo = Struct.new(:bar, :baz)
 foo = Foo.new(1, 2)
 FooResource.new(foo).serialize # => '{"foo":{"bar":1}}'
-ExtendedFooResource.new(foo).serialize # => '{"foo":{"bar":1,"baz":2}}'
+ExtendedFooResource.new(foo).serialize # => '{"foofoo":{"bar":1,"baz":2}}'
 ```
 
 In this example we add `baz` attribute and change `root_key`. This way, you can extend existing resource classes just like normal OOP. Don't forget that when your inheritance structure is too deep it'll become difficult to modify existing classes.
 
 ### Filtering attributes
 
+Filtering attributes can be done in two ways - with `attributes` and `select`. They have different semantics and usage.
+
+`select` is a new and more intuitive API, so generally it's recommended to use `select`.
+
+#### Filtering attributes with `attributes`
+
 You can filter out certain attributes by overriding `attributes` instance method. This is useful when you want to customize existing resource with inheritance.
 
 You can access raw attributes via `super` call. It returns a Hash whose keys are the name of the attribute and whose values are the body. Usually you need only keys to filter out, like below.
@@ -598,19 +629,52 @@ class RestrictedFooResource < GenericFooResource
   end
 end
 
+foo = Foo.new(1, 'my foo', 'body')
+
 RestrictedFooResource.new(foo).serialize
 # => '{"name":"my foo"}'
 ```
 
-### Key transformation
+#### Filtering attributes with `select`
 
-If you want to use `transform_keys` DSL and you already have `active_support` installed, key transformation will work out of the box, using `ActiveSupport::Inflector`. If `active_support` is not around, you have 2 possibilities:
-* install it
-* use a [custom inflector](#custom-inflector)
+When you want to filter attributes based on more complex logic, you can use `select` instance method. `select` takes two parameters, the name of an attribute and the value of an attribute. If it returns false that attribute is rejected.
 
-With `transform_keys` DSL, you can transform attribute keys.
+```ruby
+class Foo
+  attr_accessor :id, :name, :body
+
+  def initialize(id, name, body)
+    @id = id
+    @name = name
+    @body = body
+  end
+end
+
+class GenericFooResource
+  include Alba::Resource
+
+  attributes :id, :name, :body
+end
+
+class RestrictedFooResource < GenericFooResource
+  def select(_key, value)
+    !value.nil?
+  end
+end
+
+foo = Foo.new(1, nil, 'body')
+
+RestrictedFooResource.new(foo).serialize
+# => '{"id":1,"body":"body"}'
+```
+
+### Key transformation
+
+If you have [inference](#inference-configuration) enabled, you can use the `transform_keys` DSL to transform attribute keys.
 
 ```ruby
+Alba.inflector = :active_support
+
 class User
   attr_reader :id, :first_name, :last_name
 
@@ -646,12 +710,12 @@ Possible values for `transform_keys` argument are:
 
 You can also transform root key when:
 
-* `Alba.enable_inference!` is called
+* `Alba.inflector` is set
 * `root_key!` is called in Resource class
 * `root` option of `transform_keys` is set to true
 
 ```ruby
-Alba.enable_inference!(with: :active_support) # with :dry also works
+Alba.inflector = :active_support
 
 class BankAccount
   attr_reader :account_number
@@ -675,7 +739,9 @@ BankAccountResource.new(bank_account).serialize
 # => '{"bank-account":{"account-number":123456789}}'
 ```
 
-This behavior to transform root key will become default at version 2.
+This is the default behavior from version 2.
+
+Find more details in the [Inference configuration](#inference-configuration) section.
 
 #### Key transformation cascading
 
@@ -687,7 +753,7 @@ You can also turn it off by setting `cascade: false` option to `transform_keys`.
 
 ```ruby
 class User
-  attr_reader :id, :first_name, :last_name
+  attr_reader :id, :first_name, :last_name, :bank_account
 
   def initialize(id, first_name, last_name)
     @id = id
@@ -746,7 +812,7 @@ module CustomInflector
   end
 end
 
-Alba.enable_inference!(with: CustomInflector)
+Alba.inflector = CustomInflector
 ```
 
 ### Conditional attributes
@@ -757,7 +823,7 @@ In these cases, conditional attributes works well. We can pass `if` option to `a
 
 ```ruby
 class User
-  attr_accessor :id, :name, :email, :created_at, :updated_at
+  attr_accessor :id, :name, :email
 
   def initialize(id, name, email)
     @id = id
@@ -790,12 +856,12 @@ end
 
 We believe this is clearer than using some (not implemented yet) DSL such as `default` because there are some conditions where default values should be applied (`nil`, `blank?`, `empty?` etc.)
 
-### Inference
+### Root key and association resource name inference
 
-After `Alba.enable_inference!` called, Alba tries to infer root key and association resource name.
+If [inference](#inference-configuration) is enabled, Alba tries to infer the root key and association resource names.
 
 ```ruby
-Alba.enable_inference!(with: :active_support) # with :dry also works
+Alba.inflector = :active_support
 
 class User
   attr_reader :id
@@ -825,7 +891,7 @@ end
 class UserResource
   include Alba::Resource
 
-  key!
+  root_key!
 
   attributes :id
 
@@ -843,6 +909,8 @@ This resource automatically sets its root key to either "users" or "user", depen
 
 Also, you don't have to specify which resource class to use with `many`. Alba infers it from association name.
 
+Find more details in the [Inference configuration](#inference-configuration) section.
+
 ### Error handling
 
 You can set error handler globally or per resource using `on_error`.
@@ -934,7 +1002,7 @@ class UserResource
   include Alba::Resource
 
   on_nil do |object, key|
-    if key == age
+    if key == 'age'
       20
     else
       "User#{object.id}"
@@ -990,7 +1058,7 @@ class UserResourceWithoutMeta
   attributes :id, :name
 end
 
-UserResource.new([user]).serialize(meta: {foo: :bar})
+UserResourceWithoutMeta.new([user]).serialize(meta: {foo: :bar})
 # => '{"users":[{"id":1,"name":"Masafumi OKURA"}],"meta":{"foo":"bar"}}'
 ```
 
@@ -1014,7 +1082,7 @@ You can validate and convert input with types.
 class User
   attr_reader :id, :name, :age, :bio, :admin, :created_at
 
-  def initialize(id, name, age, bio = '', admin = false) # rubocop:disable Style/OptionalBooleanParameter
+  def initialize(id, name, age, bio = '', admin = false)
     @id = id
     @name = name
     @age = age

data/alba.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   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('>= 2.6.0')
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.7.0')
 
   spec.metadata = {
     'bug_tracker_uri' => 'https://github.com/okuramasafumi/issues',

data/benchmark/collection.rb

@@ -1,88 +1,7 @@
 # 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 "benchmark-memory"
-  gem "blueprinter"
-  gem "fast_serializer_ruby"
-  gem "jbuilder"
-  gem 'turbostreamer'
-  gem "jserializer"
-  gem "multi_json"
-  gem "panko_serializer"
-  gem "pg"
-  gem "primalize"
-  gem "oj"
-  gem "representable"
-  gem "simple_ams"
-  gem "sqlite3"
-end
-
-# --- Test data model setup ---
-
-require "pg"
-require "active_record"
-require "active_record/connection_adapters/postgresql_adapter"
-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
+require_relative 'prep'
 
 # --- Alba serializers ---
 
@@ -160,30 +79,6 @@ class FastSerializerPostResource
   has_many :comments, serializer: FastSerializerCommentResource
 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
-
 # --- Jserializer serializers ---
 
 require 'jserializer'
@@ -220,31 +115,6 @@ class PankoPostSerializer < Panko::Serializer
   end
 end
 
-# --- Primalize serializers ---
-#
-class PrimalizeCommentResource < Primalize::Single
-  attributes id: integer, body: string
-end
-
-class PrimalizePostResource < Primalize::Single
-  alias post object
-
-  attributes(
-    id: integer,
-    body: string,
-    comments: array(primalize(PrimalizeCommentResource)),
-    commenter_names: array(string),
-  )
-
-  def commenter_names
-    post.commenters.pluck(:name)
-  end
-end
-
-class PrimalizePostsResource < Primalize::Many
-  attributes posts: enumerable(PrimalizePostResource)
-end
-
 # --- Representable serializers ---
 
 require "representable"
@@ -349,13 +219,6 @@ 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 }
-jbuilder = Proc.new do
-  Jbuilder.new do |json|
-    json.array!(posts) do |post|
-      json.post post.to_builder
-    end
-  end.target!
-end
 jserializer = Proc.new { JserializerPostSerializer.new(posts, is_collection: true).to_json }
 panko = proc { Panko::ArraySerializer.new(posts, each_serializer: PankoPostSerializer).to_json }
 primalize = proc { PrimalizePostsResource.new(posts: posts).to_json }
@@ -368,22 +231,25 @@ turbostreamer = Proc.new { TurbostreamerSerializer.new(posts).to_json }
 
 # --- Execute the serializers to check their output ---
 GC.disable
-puts "Serializer outputs ----------------------------------"
+puts "Checking outputs..."
+correct = alba.call
+parsed_correct = JSON.parse(correct)
 {
-  alba: alba,
   alba_inline: alba_inline,
   ams: ams,
   blueprinter: blueprinter,
   fast_serializer: fast_serializer,
-  jbuilder: jbuilder, # different order
   jserializer: jserializer,
   panko: panko,
-  primalize: primalize,
   rails: rails,
   representable: representable,
   simple_ams: simple_ams,
   turbostreamer: turbostreamer
-}.each { |name, serializer| puts "#{name.to_s.ljust(24, ' ')} #{serializer.call}" }
+}.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 ---
 
@@ -394,10 +260,8 @@ Benchmark.ips do |x|
   x.report(:ams, &ams)
   x.report(:blueprinter, &blueprinter)
   x.report(:fast_serializer, &fast_serializer)
-  x.report(:jbuilder, &jbuilder)
   x.report(:jserializer, &jserializer)
   x.report(:panko, &panko)
-  x.report(:primalize, &primalize)
   x.report(:rails, &rails)
   x.report(:representable, &representable)
   x.report(:simple_ams, &simple_ams)
@@ -414,10 +278,8 @@ Benchmark.memory do |x|
   x.report(:ams, &ams)
   x.report(:blueprinter, &blueprinter)
   x.report(:fast_serializer, &fast_serializer)
-  x.report(:jbuilder, &jbuilder)
   x.report(:jserializer, &jserializer)
   x.report(:panko, &panko)
-  x.report(:primalize, &primalize)
   x.report(:rails, &rails)
   x.report(:representable, &representable)
   x.report(:simple_ams, &simple_ams)