alba 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9018588ddacac0cf7db8dac1d23c8165665c7a93976b581d25ab51357ead7834
-  data.tar.gz: 6bde71c65d8fb6965d46cea2769cd9a97d4f76407136e47de4392cdfa1a58333
+  metadata.gz: 86253dcf425b1a8bf489db53327a4f9a13c1ae046f87a5f558b75b9c1df18964
+  data.tar.gz: de8b3a29bd9b12f8cd6718a04f6140bec7611bedbf654232e9119f541d7f904e
 SHA512:
-  metadata.gz: a7d907446dad8ff8a19814cbf27ba74bfc84a0f00fae8366f561efd5de03e1ac16d66f3b31641e8ec83b5081e6e5fc61074c5a5e47509343fade989ab65e41da
-  data.tar.gz: d81e0055f6899698d70ab1522e71adc8ce9e22e3a8855ad2a3db8b54e551d2ea459a77bc92242bc5c7f8121d150c322f3b99f6d286fd7118f5df2f94d0dc3fdc
+  metadata.gz: dea93b6391ceaab7ec2759758d24df0eb14e8c59c52d8a174aeda79373afac23ca9f909a65aae3c2442106dd9d8dc700668eb6b791002ef0f9cf34833f53099a
+  data.tar.gz: 535c33bd2bea00d3029ab07a0848e37e8a30b8c6d66c3a1f894b51ad9b4aae30fc498dd000086c3e6a851c31069e6ab5d5ce11f8d96b4c687c26ae0174d42e54

data/CHANGELOG.md

@@ -6,6 +6,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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 +36,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/Gemfile

@@ -6,11 +6,10 @@ 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 '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-minitest', '~> 0.24.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

data/README.md

@@ -37,7 +37,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 +57,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.6 and higher and latest JRuby and TruffleRuby.
 
 ## Documentation
 
@@ -68,10 +68,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 +112,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))
 
-For the details, see [Error handling section](#error-handling)
+To disable inference, set the `inflector` to `nil`:
+
+```ruby
+Alba.inflector = nil
+```
+
+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 +170,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 +197,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 +223,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 +381,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 +405,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 +579,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 +619,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`
+
+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.
+
+```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
 
-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)
+foo = Foo.new(1, nil, 'body')
 
-With `transform_keys` DSL, you can transform attribute keys.
+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 +700,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 +729,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 +743,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 +802,7 @@ module CustomInflector
   end
 end
 
-Alba.enable_inference!(with: CustomInflector)
+Alba.inflector = CustomInflector
 ```
 
 ### Conditional attributes
@@ -757,7 +813,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 +846,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 +881,7 @@ end
 class UserResource
   include Alba::Resource
 
-  key!
+  root_key!
 
   attributes :id
 
@@ -843,6 +899,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 +992,7 @@ class UserResource
   include Alba::Resource
 
   on_nil do |object, key|
-    if key == age
+    if key == 'age'
       20
     else
       "User#{object.id}"
@@ -990,7 +1048,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"}}'
 ```
 

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)

data/benchmark/prep.rb

@@ -0,0 +1,82 @@
+# --- 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 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

data/benchmark/single_resource.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 "jbuilder"
-  gem 'turbostreamer'
-  gem "jserializer"
-  gem "jsonapi-serializer" # successor of fast_jsonapi
-  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 ---
 
@@ -177,70 +96,8 @@ class JserializerPostSerializer < Jserializer::Base
   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
-
 # --- Panko serializers ---
-#
+
 require "panko_serializer"
 
 class PankoCommentSerializer < Panko::Serializer
@@ -259,7 +116,7 @@ class PankoPostSerializer < Panko::Serializer
 end
 
 # --- Primalize serializers ---
-#
+
 class PrimalizeCommentResource < Primalize::Single
   attributes id: integer, body: string
 end
@@ -376,8 +233,6 @@ ams = Proc.new { AMSPostSerializer.new(post, {}).to_json }
 blueprinter = Proc.new { PostBlueprint.render(post) }
 jbuilder = Proc.new { post.to_builder.target! }
 jserializer = Proc.new { JserializerPostSerializer.new(post).to_json }
-jsonapi = proc { JsonApiStandardPostSerializer.new(post).to_json }
-jsonapi_same_format = proc { JsonApiSameFormatPostSerializer.new(post).to_json }
 panko = proc { PankoPostSerializer.new.serialize_to_json(post) }
 primalize = proc { PrimalizePostResource.new(post).to_json }
 rails = Proc.new { ActiveSupport::JSON.encode(post.serializable_hash(include: :comments)) }
@@ -395,8 +250,6 @@ puts "Serializer outputs ----------------------------------"
   blueprinter: blueprinter,
   jbuilder: jbuilder, # different order
   jserializer: jserializer,
-  jsonapi: jsonapi, # nested JSON:API format
-  jsonapi_same_format: jsonapi_same_format,
   panko: panko,
   primalize: primalize,
   rails: rails,
@@ -417,8 +270,6 @@ Benchmark.ips do |x|
   x.report(:blueprinter, &blueprinter)
   x.report(:jbuilder, &jbuilder)
   x.report(:jserializer, &jserializer)
-  x.report(:jsonapi, &jsonapi)
-  x.report(:jsonapi_same_format, &jsonapi_same_format)
   x.report(:panko, &panko)
   x.report(:primalize, &primalize)
   x.report(:rails, &rails)
@@ -438,8 +289,6 @@ Benchmark.memory do |x|
   x.report(:blueprinter, &blueprinter)
   x.report(:jbuilder, &jbuilder)
   x.report(:jserializer, &jserializer)
-  x.report(:jsonapi, &jsonapi)
-  x.report(:jsonapi_same_format, &jsonapi_same_format)
   x.report(:panko, &panko)
   x.report(:primalize, &primalize)
   x.report(:rails, &rails)

data/docs/migrate_from_active_model_serializers.md

@@ -12,7 +12,7 @@ This guide is aimed at helping ActiveModelSerializers users transition to Alba,
 
 ## Example class
 
-Example clsss is inherited `ActiveRecord::Base`, because [serializing PORO with AMS is pretty hard](https://github.com/rails-api/active_model_serializers/blob/0-10-stable/docs/howto/serialize_poro.md).
+Example class is inherited `ActiveRecord::Base`, because [serializing PORO with AMS is pretty hard](https://github.com/rails-api/active_model_serializers/blob/0-10-stable/docs/howto/serialize_poro.md).
 
 ```rb
 class User < ActiveRecord::Base
@@ -175,7 +175,7 @@ class UserSerializer < ActiveModel::Serializer
   has_many :articles, serializer: ArticleSerializer # For has_many relation
 end
 user = User.create!
-user.craete_profile! email: email
+user.create_profile! email: email
 user.articles.create! title: title, body: body
 ActiveModelSerializers::SerializableResource.new(
   user

data/docs/rails.md

@@ -14,7 +14,7 @@ You might want to add some configurations to initializer file such as `alba.rb`
 ```ruby
 # alba.rb
 Alba.backend = :active_support
-Alba.enable_inference!(:active_support)
+Alba.enable_inference!(with: :active_support)
 ```
 
 You can also use `:oj_rails` for backend if you prefer using Oj.

data/lib/alba/association.rb

@@ -37,8 +37,10 @@ module Alba
       @object = @condition.call(object, params, target) if @condition
       return if @object.nil?
 
-      if @resource.is_a?(Proc) && @object.is_a?(Enumerable)
-        to_h_with_each_resource(within, params)
+      if @resource.is_a?(Proc)
+        return to_h_with_each_resource(within, params) if @object.is_a?(Enumerable)
+
+        @resource.call(@object).new(@object, within: within, params: params).to_h
       else
         to_h_with_constantize_resource(within, params)
       end
@@ -63,10 +65,10 @@ module Alba
                     klass.transform_keys(key_transformation)
                     klass.class_eval(&block)
                     klass
-                  elsif Alba.inferring
+                  elsif Alba.inflector
                     Alba.infer_resource_class(@name, nesting: nesting)
                   else
-                    raise ArgumentError, 'When Alba.inferring is false, either resource or block is required'
+                    raise ArgumentError, 'When Alba.inflector is nil, either resource or block is required'
                   end
     end
 

data/lib/alba/conditional_attribute.rb

@@ -20,7 +20,7 @@ module Alba
       return Alba::REMOVE_KEY unless condition_passes?(resource, object)
 
       fetched_attribute = yield(@body)
-      return fetched_attribute if fetched_attribute.nil? || !with_two_arity_proc_condition
+      return fetched_attribute if !with_two_arity_proc_condition
 
       return Alba::REMOVE_KEY unless resource.instance_exec(object, attribute_from_association_body_or(fetched_attribute), &@condition)
 

data/lib/alba/resource.rb

@@ -41,7 +41,6 @@ module Alba
         @object = object
         @params = params
         @within = within
-        @method_existence = {} # Cache for `respond_to?` result
         DSLS.each_key { |name| instance_variable_set("@#{name}", self.class.__send__(name)) }
       end
 
@@ -149,7 +148,7 @@ module Alba
       end
 
       def _key_for_collection
-        if Alba.inferring
+        if Alba.inflector
           @_key_for_collection == true ? resource_name(pluralized: true) : @_key_for_collection.to_s
         else
           @_key_for_collection == true ? raise_root_key_inference_error : @_key_for_collection.to_s
@@ -158,7 +157,7 @@ module Alba
 
       # @return [String]
       def _key
-        if Alba.inferring
+        if Alba.inflector
           @_key == true ? resource_name(pluralized: false) : @_key.to_s
         else
           @_key == true ? raise_root_key_inference_error : @_key.to_s
@@ -174,7 +173,7 @@ module Alba
       end
 
       def raise_root_key_inference_error
-        raise Alba::Error, 'You must call Alba.enable_inference! to set root_key to true for inferring root key.'
+        raise Alba::Error, 'You must set inflector when setting root key as true.'
       end
 
       def transforming_root_key?
@@ -182,27 +181,27 @@ module Alba
       end
 
       def converter
-        lambda do |object|
-          attributes_to_hash(object, {})
+        lambda do |obj|
+          attributes_to_hash(obj, {})
         end
       end
 
       def collection_converter
-        lambda do |object, a|
+        lambda do |obj, a|
           a << {}
           h = a.last
-          attributes_to_hash(object, h)
+          attributes_to_hash(obj, h)
           a
         end
       end
 
-      def attributes_to_hash(object, hash)
+      def attributes_to_hash(obj, hash)
         attributes.each do |key, attribute|
-          set_key_and_attribute_body_from(object, key, attribute, hash)
+          set_key_and_attribute_body_from(obj, key, attribute, hash)
         rescue ::Alba::Error, FrozenError, TypeError
           raise
         rescue StandardError => e
-          handle_error(e, object, key, attribute, hash)
+          handle_error(e, obj, key, attribute, hash)
         end
         hash
       end
@@ -213,20 +212,28 @@ module Alba
         @_attributes
       end
 
-      def set_key_and_attribute_body_from(object, key, attribute, hash)
+      # Default implementation for selecting attributes
+      # Override this method to filter attributes based on key and value
+      def select(_key, _value)
+        true
+      end
+
+      def set_key_and_attribute_body_from(obj, key, attribute, hash)
         key = transform_key(key)
-        value = fetch_attribute(object, key, attribute)
+        value = fetch_attribute(obj, key, attribute)
+        return unless select(key, value)
+
         hash[key] = value unless value == Alba::REMOVE_KEY
       end
 
-      def handle_error(error, object, key, attribute, hash)
+      def handle_error(error, obj, key, attribute, hash)
         on_error = @_on_error || :raise
         case on_error # rubocop:disable Style/MissingElse
         when :raise, nil then raise(error)
         when :nullify then hash[key] = nil
         when :ignore then nil
         when Proc
-          key, value = on_error.call(error, object, key, attribute, self.class)
+          key, value = on_error.call(error, obj, key, attribute, self.class)
           hash[key] = value
         end
       end
@@ -237,7 +244,7 @@ module Alba
         return key if @_transform_type == :none || key.empty? # We can skip transformation
 
         inflector = Alba.inflector
-        raise Alba::Error, 'Inflector is nil. You can set inflector with `Alba.enable_inference!(with: :active_support)` for example.' unless inflector
+        raise Alba::Error, 'Inflector is nil. You must set inflector before transforming keys.' unless inflector
 
         case @_transform_type # rubocop:disable Style/MissingElse
         when :camel then inflector.camelize(key)
@@ -247,23 +254,23 @@ module Alba
         end
       end
 
-      def fetch_attribute(object, key, attribute) # rubocop:disable Metrics/CyclomaticComplexity
+      def fetch_attribute(obj, key, attribute) # rubocop:disable Metrics/CyclomaticComplexity
         value = case attribute
-                when Symbol then fetch_attribute_from_object_and_resource(object, attribute)
-                when Proc then instance_exec(object, &attribute)
-                when Alba::Association then yield_if_within(attribute.name.to_sym) { |within| attribute.to_h(object, params: params, within: within) }
-                when TypedAttribute, NestedAttribute then attribute.value(object)
-                when ConditionalAttribute then attribute.with_passing_condition(resource: self, object: object) { |attr| fetch_attribute(object, key, attr) }
+                when Symbol then fetch_attribute_from_object_and_resource(obj, attribute)
+                when Proc then instance_exec(obj, &attribute)
+                when Alba::Association then yield_if_within(attribute.name.to_sym) { |within| attribute.to_h(obj, params: params, within: within) }
+                when TypedAttribute, NestedAttribute then attribute.value(obj)
+                when ConditionalAttribute then attribute.with_passing_condition(resource: self, object: obj) { |attr| fetch_attribute(obj, key, attr) }
                 else
                   raise ::Alba::Error, "Unsupported type of attribute: #{attribute.class}"
                 end
-        value.nil? && nil_handler ? instance_exec(object, key, attribute, &nil_handler) : value
+        value.nil? && nil_handler ? instance_exec(obj, 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.__send__(attribute) : __send__(attribute, object)
+      def fetch_attribute_from_object_and_resource(obj, attribute)
+        obj.__send__(attribute)
+      rescue NoMethodError
+        __send__(attribute, obj)
       end
 
       def nil_handler
@@ -313,7 +320,7 @@ module Alba
       # @param attrs_with_types [Hash<[Symbol, String], [Array<Symbol, Proc>, Symbol]>]
       #   attributes with name in its key and type and optional type converter in its value
       # @return [void]
-      def attributes(*attrs, if: nil, **attrs_with_types) # rubocop:disable Naming/MethodParameterName
+      def attributes(*attrs, if: nil, **attrs_with_types)
         if_value = binding.local_variable_get(:if)
         assign_attributes(attrs, if_value)
         assign_attributes_with_types(attrs_with_types, if_value)

data/lib/alba/version.rb

@@ -1,3 +1,3 @@
 module Alba
-  VERSION = '2.0.1'.freeze
+  VERSION = '2.1.0'.freeze
 end

data/lib/alba.rb

@@ -7,10 +7,10 @@ require_relative 'alba/deprecation'
 # Core module
 module Alba
   class << self
-    attr_reader :backend, :encoder, :inferring
+    attr_reader :backend, :encoder
 
-    # Accessor for inflector, a module responsible for inflecting strings
-    attr_accessor :inflector
+    # Getter for inflector, a module responsible for inflecting strings
+    attr_reader :inflector
 
     # Set the backend, which actually serializes object into JSON
     #
@@ -54,14 +54,36 @@ module Alba
     # @param with [Symbol, Class, Module] inflector
     #   When it's a Symbol, it sets inflector with given name
     #   When it's a Class or a Module, it sets given object to inflector
+    # @deprecated Use {#inflector=} instead
     def enable_inference!(with:)
+      Alba::Deprecation.warn('Alba.enable_inference! is deprecated. Use `Alba.inflector=` instead.')
       @inflector = inflector_from(with)
       @inferring = true
     end
 
     # Disable inference for key and resource name
+    #
+    # @deprecated Use {#inflector=} instead
     def disable_inference!
+      Alba::Deprecation.warn('Alba.disable_inference! is deprecated. Use `Alba.inflector = nil` instead.')
       @inferring = false
+      @inflector = nil
+    end
+
+    # @deprecated Use {#inflector} instead
+    # @return [Boolean] whether inference is enabled or not
+    def inferring
+      Alba::Deprecation.warn('Alba.inferring is deprecated. Use `Alba.inflector` instead.')
+      @inferring
+    end
+
+    # Set an inflector
+    #
+    # @param inflector [Symbol, Class, Module] inflector
+    #   When it's a Symbol, it accepts `:default`, `:active_support` or `:dry`
+    #   When it's a Class or a Module, it should have some methods, see {Alba::DefaultInflector}
+    def inflector=(inflector)
+      @inflector = inflector_from(inflector)
     end
 
     # @param block [Block] resource body
@@ -77,7 +99,7 @@ module Alba
     # @param nesting [String, nil] namespace Alba tries to find resource class in
     # @return [Class<Alba::Resource>] resource class
     def infer_resource_class(name, nesting: nil)
-      raise Alba::Error, 'Inference is disabled so Alba cannot infer resource name. Use `Alba.enable_inference!` before use.' unless Alba.inferring
+      raise Alba::Error, 'Inference is disabled so Alba cannot infer resource name. Set inflector before use.' unless Alba.inflector
 
       const_parent = nesting.nil? ? Object : Object.const_get(nesting)
       const_parent.const_get("#{inflector.classify(name)}Resource")
@@ -95,6 +117,7 @@ module Alba
 
     def inflector_from(name_or_module)
       case name_or_module
+      when nil then nil
       when :default, :active_support
         require_relative 'alba/default_inflector'
         Alba::DefaultInflector

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: alba
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - OKURA Masafumi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-11-02 00:00:00.000000000 Z
+date: 2022-12-03 00:00:00.000000000 Z
 dependencies: []
 description: Alba is the fastest JSON serializer for Ruby. It focuses on performance,
   flexibility and usability.
@@ -40,6 +40,7 @@ files:
 - alba.gemspec
 - benchmark/README.md
 - benchmark/collection.rb
+- benchmark/prep.rb
 - benchmark/single_resource.rb
 - bin/console
 - bin/setup