如何实现带参数的动态Scope链式调用？

Got it, let's fix this issue! The original send_chain method works great for parameter-less scopes, but it can't handle scopes that need arguments. Here's how to adjust it to support both cases smoothly.

Updated send_chain Method #

Instead of passing an array of just method names, we'll use an array of scope specifications. Each spec is an array where the first element is the scope name, followed by any arguments it requires. This lets you mix scopes with and without parameters effortlessly:

def self.send_chain(scope_specs)
  scope_specs.inject(self) do |current_relation, spec|
    # Pull the scope name and its arguments from the spec
    scope_name, *args = spec
    current_relation.send(scope_name, *args)
  end
end

Example Usage #

First, let's assume you have scopes like these (some with parameters, some without):

class Article < ApplicationRecord
  # Parameter-less scopes
  scope :pending_review, -> { where(status: "pending") }
  scope :draft, -> { where(status: "draft") }
  scope :with_meta_title, -> { where.not(meta_title: nil) }

  # Scopes with parameters
  scope :with_author, ->(author_id) { where(author_id: author_id) }
  scope :published_after, ->(date) { where("published_at >= ?", date) }
  scope :with_tag, ->(tag_name) { joins(:tags).where(tags: { name: tag_name }) }
end

Now build your scope chain specifications and call the method:

# Mix of parameter-less and parameterized scopes
scope_chain = [
  ["with_author", 42], # Pass author ID 42 to the scope
  ["pending_review"],  # No arguments needed
  ["published_after", Date.new(2024, 1, 1)], # Pass a date argument
  ["with_tag", "ruby"], # Pass tag name "ruby"
  ["with_meta_title"]   # No arguments
]

# Execute the dynamic chain
Article.send_chain(scope_chain)

Alternative: Hash-Based Syntax for Readability #

If you prefer a more intuitive structure, use a hash where keys are scope names and values are their arguments (wrap single arguments in an array if needed, or pass nil for parameter-less scopes):

def self.send_chain(scope_hash)
  scope_hash.inject(self) do |current_relation, (scope_name, args)|
    # Ensure args is always an array to handle single/multiple arguments
    args = [args].compact unless args.is_a?(Array)
    current_relation.send(scope_name, *args)
  end
end

# Usage
scope_chain = {
  with_author: 42,
  pending_review: nil,
  published_after: Date.new(2024, 1, 1),
  with_tag: ["ruby", "rails"], # Pass multiple arguments if your scope accepts them
  with_meta_title: nil
}

Article.send_chain(scope_chain)

Why This Works #

• The updated method uses inject to build the relation incrementally, just like the original, but adds support for arguments.
• By destructuring each spec into the scope name and its arguments, we can dynamically pass whatever parameters each scope needs.
• It’s fully backward-compatible with parameter-less scopes—just pass a single-element array (or nil in the hash version) for those.

内容的提问来源于stack exchange，提问作者ss_matches