alba 1.5.0 → 2.0.0

data/Rakefile

@@ -1,12 +1,12 @@
 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?
+ENV["BUNDLE_GEMFILE"] = File.expand_path("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"
-  file_list = ENV["BUNDLE_GEMFILE"] == File.expand_path("gemfiles/all.gemfile") ? FileList["test/**/*_test.rb"] : FileList["test/dependencies/test_dependencies.rb"]
+  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
 

data/alba.gemspec

@@ -10,11 +10,15 @@ 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.5.0')
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.6.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/blob/main/CHANGELOG.md'
+  spec.metadata = {
+    'bug_tracker_uri' => 'https://github.com/okuramasafumi/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.

data/benchmark/README.md

@@ -0,0 +1,81 @@
+## 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 12.2.1|
+|CPU|Intel Corei7 Quad Core 2.3Ghz|
+|RAM|32GB|
+|Ruby|ruby 3.0.2p107 (2021-07-07 revision 0db68f0233) [x86_64-darwin19]|
+
+`benchmark-ips` with `Oj.optimize_rails`:
+
+```
+Comparison:
+               panko:      267.6 i/s
+               rails:      111.2 i/s - 2.41x  (± 0.00) slower
+         jserializer:      106.2 i/s - 2.52x  (± 0.00) slower
+                alba:      102.8 i/s - 2.60x  (± 0.00) slower
+       turbostreamer:       99.9 i/s - 2.68x  (± 0.00) slower
+            jbuilder:       90.7 i/s - 2.95x  (± 0.00) slower
+         alba_inline:       90.0 i/s - 2.97x  (± 0.00) slower
+           primalize:       82.1 i/s - 3.26x  (± 0.00) slower
+     fast_serializer:       62.7 i/s - 4.27x  (± 0.00) slower
+ jsonapi_same_format:       59.5 i/s - 4.50x  (± 0.00) slower
+             jsonapi:       55.3 i/s - 4.84x  (± 0.00) slower
+         blueprinter:       54.1 i/s - 4.95x  (± 0.00) slower
+       representable:       35.9 i/s - 7.46x  (± 0.00) slower
+          simple_ams:       25.4 i/s - 10.53x  (± 0.00) slower
+                 ams:        9.1 i/s - 29.39x  (± 0.00) slower
+```
+
+`benchmark-ips` without `Oj.optimize_rails`:
+
+```
+Comparison:
+               panko:      283.8 i/s
+       turbostreamer:      102.9 i/s - 2.76x  (± 0.00) slower
+                alba:      102.4 i/s - 2.77x  (± 0.00) slower
+         alba_inline:       98.7 i/s - 2.87x  (± 0.00) slower
+         jserializer:       93.3 i/s - 3.04x  (± 0.00) slower
+     fast_serializer:       60.1 i/s - 4.73x  (± 0.00) slower
+         blueprinter:       53.8 i/s - 5.28x  (± 0.00) slower
+               rails:       37.1 i/s - 7.65x  (± 0.00) slower
+            jbuilder:       37.1 i/s - 7.66x  (± 0.00) slower
+           primalize:       31.2 i/s - 9.08x  (± 0.00) slower
+ jsonapi_same_format:       28.3 i/s - 10.03x  (± 0.00) slower
+       representable:       27.8 i/s - 10.23x  (± 0.00) slower
+             jsonapi:       27.5 i/s - 10.34x  (± 0.00) slower
+          simple_ams:       16.9 i/s - 16.75x  (± 0.00) slower
+                 ams:        8.3 i/s - 34.36x  (± 0.00) slower
+```
+
+`benchmark-memory`:
+
+```
+Comparison:
+               panko:     230418 allocated
+                alba:     733217 allocated - 3.18x more
+         alba_inline:     748297 allocated - 3.25x more
+       turbostreamer:     781008 allocated - 3.39x more
+         jserializer:     819705 allocated - 3.56x more
+           primalize:    1195163 allocated - 5.19x more
+     fast_serializer:    1232385 allocated - 5.35x more
+               rails:    1236761 allocated - 5.37x more
+         blueprinter:    1588937 allocated - 6.90x more
+            jbuilder:    1774157 allocated - 7.70x more
+ jsonapi_same_format:    2132489 allocated - 9.25x more
+             jsonapi:    2279958 allocated - 9.89x more
+       representable:    2869166 allocated - 12.45x more
+                 ams:    4473161 allocated - 19.41x more
+          simple_ams:    7868345 allocated - 34.15x 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. With `Oj.optimize_rails` jbuilder and Rails standard serialization are also fast.

data/benchmark/collection.rb

@@ -15,9 +15,10 @@ gemfile(true) do
   gem "benchmark-ips"
   gem "benchmark-memory"
   gem "blueprinter"
+  gem "fast_serializer_ruby"
   gem "jbuilder"
+  gem 'turbostreamer'
   gem "jserializer"
-  gem "jsonapi-serializer" # successor of fast_jsonapi
   gem "multi_json"
   gem "panko_serializer"
   gem "pg"
@@ -138,6 +139,27 @@ class PostBlueprint < Blueprinter::Base
   end
 end
 
+# --- Fast Serializer Ruby
+
+require "fast_serializer"
+
+class FastSerializerCommentResource
+  include ::FastSerializer::Schema::Mixin
+  attributes :id, :body
+end
+
+class FastSerializerPostResource
+  include ::FastSerializer::Schema::Mixin
+
+  attributes :id, :body
+
+  attribute :commenter_names do
+    object.commenters.pluck(:name)
+  end
+
+  has_many :comments, serializer: FastSerializerCommentResource
+end
+
 # --- JBuilder serializers ---
 
 require "jbuilder"
@@ -178,67 +200,6 @@ 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 ---
 #
 
@@ -255,7 +216,7 @@ class PankoPostSerializer < Panko::Serializer
   has_many :comments, serializer: PankoCommentSerializer
 
   def commenter_names
-    object.comments.pluck(:name)
+    object.commenters.pluck(:name)
   end
 end
 
@@ -332,6 +293,31 @@ class SimpleAMSPostSerializer
   end
 end
 
+require 'turbostreamer'
+TurboStreamer.set_default_encoder(:json, :oj)
+
+class TurbostreamerSerializer
+  def initialize(posts)
+    @posts = posts
+  end
+
+  def to_json
+    TurboStreamer.encode do |json|
+      json.array! @posts do |post|
+        json.object! do
+          json.extract! post, :id, :body, :commenter_names
+
+          json.comments post.comments do |comment|
+            json.object! do
+              json.extract! comment, :id, :body
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
 # --- Test data creation ---
 
 100.times do |i|
@@ -344,7 +330,7 @@ end
   end
 end
 
-posts = Post.all.to_a
+posts = Post.all.includes(:comments, :commenters)
 
 # --- Store the serializers in procs ---
 
@@ -360,8 +346,9 @@ alba_inline = Proc.new do
     end
   end
 end
-ams = Proc.new { ActiveModelSerializers::SerializableResource.new(posts, {}).as_json }
+ams = Proc.new { ActiveModelSerializers::SerializableResource.new(posts, {each_serializer: AMSPostSerializer}).to_json }
 blueprinter = Proc.new { PostBlueprint.render(posts) }
+fast_serializer = Proc.new { FastSerializerPostResource.new(posts).to_json }
 jbuilder = Proc.new do
   Jbuilder.new do |json|
     json.array!(posts) do |post|
@@ -370,8 +357,6 @@ jbuilder = Proc.new do
   end.target!
 end
 jserializer = Proc.new { JserializerPostSerializer.new(posts, is_collection: true).to_json }
-jsonapi = proc { JsonApiStandardPostSerializer.new(posts).to_json }
-jsonapi_same_format = proc { JsonApiSameFormatPostSerializer.new(posts).to_json }
 panko = proc { Panko::ArraySerializer.new(posts, each_serializer: PankoPostSerializer).to_json }
 primalize = proc { PrimalizePostsResource.new(posts: posts).to_json }
 rails = Proc.new do
@@ -379,24 +364,25 @@ rails = Proc.new do
 end
 representable = Proc.new { PostsRepresenter.new(posts).to_json }
 simple_ams = Proc.new { SimpleAMS::Renderer::Collection.new(posts, serializer: SimpleAMSPostSerializer).to_json }
+turbostreamer = Proc.new { TurbostreamerSerializer.new(posts).to_json }
 
 # --- Execute the serializers to check their output ---
-
+GC.disable
 puts "Serializer outputs ----------------------------------"
 {
   alba: alba,
   alba_inline: alba_inline,
   ams: ams,
   blueprinter: blueprinter,
+  fast_serializer: fast_serializer,
   jbuilder: jbuilder, # different order
   jserializer: jserializer,
-  jsonapi: jsonapi, # nested JSON:API format
-  jsonapi_same_format: jsonapi_same_format,
   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}" }
 
 # --- Run the benchmarks ---
@@ -407,15 +393,15 @@ Benchmark.ips do |x|
   x.report(:alba_inline, &alba_inline)
   x.report(:ams, &ams)
   x.report(:blueprinter, &blueprinter)
+  x.report(:fast_serializer, &fast_serializer)
   x.report(:jbuilder, &jbuilder)
   x.report(:jserializer, &jserializer)
-  x.report(:jsonapi, &jsonapi)
-  x.report(:jsonapi_same_format, &jsonapi_same_format)
   x.report(:panko, &panko)
   x.report(:primalize, &primalize)
   x.report(:rails, &rails)
   x.report(:representable, &representable)
   x.report(:simple_ams, &simple_ams)
+  x.report(:turbostreamer, &turbostreamer)
 
   x.compare!
 end
@@ -427,15 +413,15 @@ Benchmark.memory do |x|
   x.report(:alba_inline, &alba_inline)
   x.report(:ams, &ams)
   x.report(:blueprinter, &blueprinter)
+  x.report(:fast_serializer, &fast_serializer)
   x.report(:jbuilder, &jbuilder)
   x.report(:jserializer, &jserializer)
-  x.report(:jsonapi, &jsonapi)
-  x.report(:jsonapi_same_format, &jsonapi_same_format)
   x.report(:panko, &panko)
   x.report(:primalize, &primalize)
   x.report(:rails, &rails)
   x.report(:representable, &representable)
   x.report(:simple_ams, &simple_ams)
+  x.report(:turbostreamer, &turbostreamer)
 
   x.compare!
 end

data/benchmark/single_resource.rb

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

data/docs/migrate_from_jbuilder.md

@@ -4,11 +4,12 @@ title: Upgrading from Jbuilder
 
 <!-- @format -->
 
-This guide is aimed at helping Jbuilder users transition to Alba, and it consists of three parts:
+This guide is aimed at helping Jbuilder users transition to Alba, and it consists of four parts:
 
 1. Basic serialization
 2. Complex serialization
-3. Unsupported features
+3. Key transformation
+4. Unsupported features
 
 ## Example class
 
@@ -216,8 +217,21 @@ UserResource.new(user).serialize
 # => '{"user":{"id":id, "created_at": created_at, "updated_at": updated_at, "profile": {"email": email}, articles: [{"title": title, "body": body}]}'
 ```
 
-## 3. Unsupported features
+## 3. Key transformation
+
+See the README for more information, but it's possible to migrate the `Jbuilder.key_format!` behavior with the `transform_keys` macro.
+
+```rb
+class UserResource
+  include Alba::Resource
+  root_key :user
+  attributes :id, :created_at, :updated_at
+
+  transform_keys :lower_camel
+end
+```
+
+## 4. Unsupported features
 
 - Jbuilder#ignore_nil!
 - Jbuilder#cache!
-- Jbuilder.key_format! and Jbuilder.deep_format_keys!

data/docs/rails.md

@@ -0,0 +1,44 @@
+---
+title: Alba for Rails
+author: OKURA Masafumi
+---
+
+# Alba for Rails
+
+While Alba is NOT designed for Rails specifically, you can definitely use Alba with Rails. This document describes in detail how to use Alba with Rails to be more productive.
+
+## Initializer
+
+You might want to add some configurations to initializer file such as `alba.rb` with something like below:
+
+```ruby
+# alba.rb
+Alba.backend = :active_support
+Alba.enable_inference!(:active_support)
+```
+
+You can also use `:oj_rails` for backend if you prefer using Oj.
+
+## Rendering JSON
+
+You can render JSON with Rails in two ways. One way is to pass JSON String.
+
+```ruby
+render json: FooResource.new(foo).serialize
+```
+
+But you can also render JSON passing `Alba::Resource` object. Rails automatically calls `to_json` on a resource.
+
+```ruby
+render json: FooResource.new(foo)
+```
+
+Note that almost all options given to this `render` are ignored. The only exceptions are `layout`, `prefixes`, `template` and `status`.
+
+```ruby
+# This `only` option is ignored
+render json: FooResource.new(foo), only: [:id]
+
+# This is OK
+render json: FooResource.new(foo), status: 200
+```

data/lib/alba/association.rb

@@ -1,22 +1,48 @@
 module Alba
-  # Base class for `One` and `Many`
-  # Child class should implement `to_hash` method
+  # Representing association
   class Association
+    @const_cache = {}
+    class << self
+      attr_reader :const_cache
+    end
+
     attr_reader :object, :name
 
     # @param name [Symbol, String] name of the method to fetch association
     # @param condition [Proc, nil] a proc filtering data
     # @param resource [Class<Alba::Resource>, nil] a resource class for the association
+    # @param params [Hash] params override for the association
     # @param nesting [String] a namespace where source class is inferred with
+    # @param key_transformation [Symbol] key transformation type
     # @param block [Block] used to define resource when resource arg is absent
-    def initialize(name:, condition: nil, resource: nil, nesting: nil, &block)
+    def initialize(name:, condition: nil, resource: nil, params: {}, nesting: nil, key_transformation: :none, &block)
       @name = name
       @condition = condition
-      @block = block
       @resource = resource
+      @params = params
+      @key_transformation = key_transformation
       return if @resource
 
-      assign_resource(nesting)
+      assign_resource(nesting, block)
+    end
+
+    # Recursively converts an object into a Hash
+    #
+    # @param target [Object] the object having an association method
+    # @param within [Hash] determines what associations to be serialized. If not set, it serializes all associations.
+    # @param params [Hash] user-given Hash for arbitrary data
+    # @return [Hash]
+    def to_h(target, within: nil, params: {})
+      params = params.merge(@params) unless @params.empty?
+      @object = target.__send__(@name)
+      @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)
+      else
+        to_h_with_constantize_resource(within, params)
+      end
     end
 
     private
@@ -26,18 +52,32 @@ module Alba
       when Class
         resource
       when Symbol, String
-        Object.const_get(resource)
+        self.class.const_cache.fetch(resource) do
+          self.class.const_cache[resource] = Object.const_get(resource)
+        end
       end
     end
 
-    def assign_resource(nesting)
-      @resource = if @block
-                    Alba.resource_class(&@block)
+    def assign_resource(nesting, block)
+      @resource = if block
+                    Alba.resource_class(&block)
                   elsif Alba.inferring
                     Alba.infer_resource_class(@name, nesting: nesting)
                   else
                     raise ArgumentError, 'When Alba.inferring is false, either resource or block is required'
                   end
     end
+
+    def to_h_with_each_resource(within, params)
+      @object.map do |item|
+        @resource.call(item).new(item, within: within, params: params).to_h
+      end
+    end
+
+    def to_h_with_constantize_resource(within, params)
+      @resource = constantize(@resource)
+      @resource.transform_keys(@key_transformation)
+      @resource.new(object, params: params, within: within).to_h
+    end
   end
 end

data/lib/alba/conditional_attribute.rb

@@ -0,0 +1,54 @@
+module Alba
+  # Represents attribute with `if` option
+  class ConditionalAttribute
+    CONDITION_UNMET = Object.new.freeze
+    public_constant :CONDITION_UNMET # It's public for use in `Alba::Resource`
+
+    # @param body [Symbol, Proc, Alba::Association, Alba::TypedAttribute] real attribute wrapped with condition
+    # @param condition [Symbol, Proc] condition to check
+    def initialize(body:, condition:)
+      @body = body
+      @condition = condition
+    end
+
+    # Returns attribute body if condition passes
+    #
+    # @param resource [Alba::Resource]
+    # @param object [Object] needed for collection, each object from collection
+    # @return [ConditionalAttribute::CONDITION_UNMET, Object] CONDITION_UNMET if condition is unmet, fetched attribute otherwise
+    def with_passing_condition(resource:, object: nil)
+      return CONDITION_UNMET unless condition_passes?(resource, object)
+
+      fetched_attribute = yield(@body)
+      return fetched_attribute if fetched_attribute.nil? || !with_two_arity_proc_condition
+
+      return CONDITION_UNMET unless resource.instance_exec(object, attribute_from_association_body_or(fetched_attribute), &@condition)
+
+      fetched_attribute
+    end
+
+    private
+
+    def condition_passes?(resource, object)
+      if @condition.is_a?(Proc)
+        arity = @condition.arity
+        # We can return early to skip fetch_attribute if arity is 1
+        # When arity is 2, we check the condition later
+        return true if arity >= 2
+        return false if arity <= 1 && !resource.instance_exec(object, &@condition)
+
+        true
+      else # Symbol
+        resource.__send__(@condition)
+      end
+    end
+
+    def with_two_arity_proc_condition
+      @condition.is_a?(Proc) && @condition.arity >= 2
+    end
+
+    def attribute_from_association_body_or(fetched_attribute)
+      @body.is_a?(Alba::Association) ? @body.object : fetched_attribute
+    end
+  end
+end