pursuit 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48b4becb7e8e0e0d39335cd5172fd4870989a9e26033a882e082480431330285
-  data.tar.gz: 33265eafe36113d7e4f263a6f9a2dc9fd7d12cfda95073c29ea0866f627e4566
+  metadata.gz: 70e763ac9fa96f98268f46e1824852e5908874fd7b667a8e5e8df5049ad14cd1
+  data.tar.gz: a375cf25c07d547f4bf8321796de8537881a05c740a198269ab6b4dac6c90ad9
 SHA512:
-  metadata.gz: 01fba1c0d143f914d3a040620f618538f8e77396e7e9fa17f503a06ef6b419c2b9eb0a55950e60b16608d944535eb9a3bf70888615709d08f525938d25850bf6
-  data.tar.gz: b2d0106bc8ceea194d87f62dd8831c3cb4477c831c951f638038d6d94384ee91c64039891203783ee50a3bedf76672245641ba5206191b5350f72d46e1e462f3
+  metadata.gz: 317ec03777606abbc9c800b728a99305855ae7e4702a64eba53c68ba402e7645de7c21d91ac2d41c8cfd953c3f9a9f1ff9878776c058ab6f39a303d216858c4c
+  data.tar.gz: ca1240b3907b70541a9a26fd54a9c97088deef1d227eb26694085ed99f8c84782cb65b7a22ee9c97d2854b9329ceb30bf6a98ab7900d077fb99047961d0b72b9

data/README.md

@@ -28,10 +28,10 @@ Simple takes the entire query and generates a SQL `LIKE` (or `ILIKE` for *Postgr
 added to the search instance. Here's an example of how you might use simple to search a hypothetical `Product` record:
 
 ```ruby
-search = Pursuit::SimpleSearch.new(Product.all)
+search = Pursuit::SimpleSearch.new(default_table: Product.arel_table)
 search.search_attribute(:title)
 search.search_attribute(:subtitle)
-search.apply('Green Shirt')
+search.apply('Green Shirt', Product.all)
 ```
 
 Which results in the following SQL query:
@@ -50,25 +50,23 @@ The initializer method also accepts a block, which is evaluated within the insta
 when declaring the searchable attributes:
 
 ```ruby
-search = Pursuit::SimpleSearch.new(Product.all) do
+search = Pursuit::SimpleSearch.new(default_table: Product.arel_table) do
   search_attribute :title
   search_attribute :subtitle
 end
 
-search.apply('Green Shirt')
+search.apply('Green Shirt', Product.all)
 ```
 
 You can also pass custom `Arel::Attribute::Attribute` objects, which are especially useful when using joins:
 
 ```ruby
-search = Pursuit::SimpleSearch.new(
-  Product.left_outer_joins(:variations).group(:id)
-) do
+search = Pursuit::SimpleSearch.new(default_table: Product.arel_table) do
   search_attribute :title
   search_attribute ProductVariation.arel_table[:title]
 end
 
-search.apply('Green Shirt')
+search.apply('Green Shirt', Product.left_outer_joins(:variations).group(:id))
 ```
 
 Which results in the following SQL query:
@@ -92,12 +90,12 @@ Term searches break a query into individual terms on spaces, while providing dou
 means to include spaces. Here's an example of using term searches on the same `Product` record from earlier:
 
 ```ruby
-search = Pursuit::TermSearch.new(Product.all) do
+search = Pursuit::TermSearch.new(default_table: Product.arel_table) do
   search_attribute :title
   search_attribute :subtitle
 end
 
-search.apply('Green "Luxury Shirt"')
+search.apply('Green "Luxury Shirt"', Product.all)
 ```
 
 Which results in a SQL query similar to the following:
@@ -128,9 +126,7 @@ You can also rename attributes, and add attributes for joined records.
 Here's a more complex example of using predicate-based searches with joins on the `Product` record from earlier:
 
 ```ruby
-search = Pursuit::PredicateSearch.new(
-  Product.left_outer_join(:category, :variations).group(:id)
-) do
+search = Pursuit::PredicateSearch.new(default_table: Product.arel_table) do
   # Product Attributes
   permit_attribute :title
 
@@ -143,7 +139,10 @@ search = Pursuit::PredicateSearch.new(
   permit_attribute :variation_amount, ProductVariation.arel_table[:amount]
 end
 
-search.apply('title = "Luxury Shirt" & (variation_amount = 0 | variation_amount > 1000)')
+search.apply(
+  'title = "Luxury Shirt" & (variation_amount = 0 | variation_amount > 1000)',
+  Product.left_outer_join(:category, :variations).group(:id)
+)
 ```
 
 This translates to "a product whose title is 'Luxury Shirt' and has at least one variation with either an amount of 0,
@@ -181,9 +180,7 @@ Predicate searches also support "aggregate modifiers" which enable the use of ag
 must be explicitly enabled and requires you to use a `GROUP BY` clause:
 
 ```ruby
-search = Pursuit::PredicateSearch.new(
-  Product.left_outer_join(:category, :variations).group(:id)
-) do
+search = Pursuit::PredicateSearch.new(default_table: Product.arel_table, permit_aggregate_modifiers: true) do
   # Product Attributes
   permit_attribute :title
 
@@ -198,7 +195,10 @@ search = Pursuit::PredicateSearch.new(
   permit_attribute :variation_amount, ProductVariation.arel_table[:amount]
 end
 
-search.apply('title = "Luxury Shirt" & #variation > 5')
+search.apply(
+  'title = "Luxury Shirt" & #variation > 5',
+  Product.left_outer_join(:category, :variations).group(:id)
+)
 ```
 
 And the resulting SQL from this query:

data/lib/pursuit/constants.rb

@@ -3,5 +3,5 @@
 module Pursuit
   # @return [String] The gem's semantic version number.
   #
-  VERSION = '1.0.1'
+  VERSION = '1.1.0'
 end

data/lib/pursuit/predicate_parser.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 module Pursuit
-  # Parser for predicate-based queries.
+  # Parser for predicate queries.
   #
-  # Predicate-based queries take an attribute to compare the value of, an operator (such as the equal sign), and the
-  # value to compare with.
+  # Predicate queries take an attribute, an operator (such as the equal sign), and a value to compare with.
   #
   # For example, to search for records where the `first_name` attribute is equal to "John" and the `last_name`
-  # attribute contains either "Doe" or "Smith", you would enter:
+  # attribute contains either "Doe" or "Smith", you might use:
+  #
   # => "first_name = John & (last_name ~ Doe | last_name ~ Smith)"
   #
   class PredicateParser < Parslet::Parser

data/lib/pursuit/predicate_search.rb

@@ -1,29 +1,33 @@
 # frozen_string_literal: true
 
 module Pursuit
-  # :nodoc:
+  # Provides an interface for declaring which attributes can be used in a predicate query, and a method for applying
+  # a predicate query to an `ActiveRecord::Relation` instance.
+  #
+  # @see Pursuit::PredicateParser
+  # @see Pursuit::PredicateTransform
   #
   class PredicateSearch
-    # @return [Boolean] `true` when aggregate modifiers can be used in queries, `false` otherwise.
+    # @return [Arel::Table] The default table to retrieve attributes from.
     #
-    attr_accessor :permit_aggregate_modifiers
+    attr_accessor :default_table
 
-    # @return [Hash<Symbol, Arel::Attributes::Attribute>] The attributes permitted for use in queries.
+    # @return [Boolean] `true` when aggregate modifiers can be used, `false` otherwise.
     #
-    attr_reader :permitted_attributes
+    attr_accessor :permit_aggregate_modifiers
 
-    # @return [ActiveRecord::Relation] The relation to which the predicate clauses are added.
+    # @return [Hash<Symbol, Arel::Attributes::Attribute>] The attributes permitted for use in queries.
     #
-    attr_reader :relation
+    attr_accessor :permitted_attributes
 
     # Creates a new predicate search instance.
     #
-    # @param relation                   [ActiveRecord::Relation] The relation to which the predicate clauses are added.
-    # @param permit_aggregate_modifiers [Boolean]                Whether aggregate modifiers can be used or not.
-    # @param block                      [Proc]                   The proc to invoke in the search instance (optional).
+    # @param default_table              [Arel::Table] The default table to retrieve attributes from.
+    # @param permit_aggregate_modifiers [Boolean]     `true` when aggregate modifiers can be used, `false` otherwise.
+    # @param block                      [Proc]        The proc to invoke in the search instance (optional).
     #
-    def initialize(relation, permit_aggregate_modifiers: false, &block)
-      @relation = relation
+    def initialize(default_table: nil, permit_aggregate_modifiers: false, &block)
+      @default_table = default_table
       @permit_aggregate_modifiers = permit_aggregate_modifiers
       @permitted_attributes = HashWithIndifferentAccess.new
 
@@ -49,8 +53,8 @@ module Pursuit
     # @return           [Arel::Attributes::Attribute]         The underlying attribute to query.
     #
     def permit_attribute(name, attribute = nil)
-      attribute = relation.klass.arel_table[attribute] if attribute.is_a?(Symbol)
-      permitted_attributes[name] = attribute || relation.klass.arel_table[name]
+      attribute = default_table[attribute] if attribute.is_a?(Symbol)
+      permitted_attributes[name] = attribute || default_table[name]
     end
 
     # Parse a predicate query into ARel nodes.
@@ -59,22 +63,21 @@ module Pursuit
     # @return       [Hash<Symbol, Arel::Nodes::Node>] The ARel nodes representing the predicate query.
     #
     def parse(query)
-      tree = parser.parse(query)
       transform.apply(
-        tree,
-        permitted_attributes: permitted_attributes,
-        permit_aggregate_modifiers: permit_aggregate_modifiers
+        parser.parse(query),
+        permit_aggregate_modifiers: permit_aggregate_modifiers,
+        permitted_attributes: permitted_attributes
       )
     end
 
-    # Returns #relation filtered by the predicate query.
+    # Applies the predicate clauses derived from `query` to `relation`.
     #
-    # @param  query [String]                 The predicate query.
-    # @return       [ActiveRecord::Relation] The updated relation with the predicate clauses added.
+    # @param  query    [String]                 The predicate query.
+    # @param  relation [ActiveRecord::Relation] The base relation to apply the predicate clauses to.
+    # @return          [ActiveRecord::Relation] The base relation with the predicate clauses applied.
     #
-    def apply(query)
+    def apply(query, relation)
       nodes = parse(query)
-      relation = self.relation
       relation = relation.where(nodes[:where]) if nodes[:where]
       relation = relation.having(nodes[:having]) if nodes[:having]
       relation

data/lib/pursuit/simple_search.rb

@@ -1,25 +1,26 @@
 # frozen_string_literal: true
 
 module Pursuit
-  # :nodoc:
+  # Provides an interface for declaring which attributes should be searched in a simple query, and a method for applying
+  # a simple query to an `ActiveRecord::Relation` instance.
   #
   class SimpleSearch
     # @return [Set<Arel::Attributes::Attribute>] The attributes to match against.
     #
-    attr_reader :attributes
+    attr_accessor :attributes
 
-    # @return [ActiveRecord::Relation] The relation to which the clauses are added.
+    # @return [Arel::Table] The default table to retrieve attributes from.
     #
-    attr_reader :relation
+    attr_accessor :default_table
 
     # Creates a new simple search instance.
     #
-    # @param relation [ActiveRecord::Relation] The relation to which the clauses are added.
-    # @param block    [Proc]                   The proc to invoke in the search instance (optional).
+    # @param default_table [Arel::Table] The default table to retrieve attributes from.
+    # @param block         [Proc]        The proc to invoke in the search instance (optional).
     #
-    def initialize(relation, &block)
+    def initialize(default_table: nil, &block)
       @attributes = Set.new
-      @relation = relation
+      @default_table = default_table
 
       instance_eval(&block) if block
     end
@@ -30,7 +31,7 @@ module Pursuit
     # @return           [Arel::Attributes::Attribute]         The underlying attribute to query.
     #
     def search_attribute(attribute)
-      attribute = relation.klass.arel_table[attribute] if attribute.is_a?(Symbol)
+      attribute = default_table[attribute] if attribute.is_a?(Symbol)
       attributes.add(attribute)
     end
 
@@ -51,12 +52,13 @@ module Pursuit
       end
     end
 
-    # Returns #relation filtered by the query.
+    # Applies the simple clauses derived from `query` to `relation`.
     #
-    # @param  query [String]                 The simple query.
-    # @return       [ActiveRecord::Relation] The updated relation with the clauses added.
+    # @param  query    [String]                 The simple query.
+    # @param  relation [ActiveRecord::Relation] The base relation to apply the simple clauses to.
+    # @return          [ActiveRecord::Relation] The base relation with the simple clauses applied.
     #
-    def apply(query)
+    def apply(query, relation)
       node = parse(query)
       node ? relation.where(node) : relation.none
     end

data/lib/pursuit/term_search.rb

@@ -1,25 +1,29 @@
 # frozen_string_literal: true
 
 module Pursuit
-  # :nodoc:
+  # Provides an interface for declaring which attributes should be searched in a term query, and a method for applying
+  # a term query to an `ActiveRecord::Relation` instance.
+  #
+  # @see Pursuit::TermParser
+  # @see Pursuit::TermTransform
   #
   class TermSearch
     # @return [Set<Arel::Attributes::Attribute>] The attributes to match against.
     #
-    attr_reader :attributes
+    attr_accessor :attributes
 
-    # @return [ActiveRecord::Relation] The relation to which the term clauses are added.
+    # @return [Arel::Table] The default table to retrieve attributes from.
     #
-    attr_reader :relation
+    attr_accessor :default_table
 
     # Creates a new term search instance.
     #
-    # @param relation [ActiveRecord::Relation] The relation to which the term clauses are added.
-    # @param block    [Proc]                   The proc to invoke in the search instance (optional).
+    # @param default_table [Arel::Table] The default table to retrieve attributes from.
+    # @param block         [Proc]        The proc to invoke in the search instance (optional).
     #
-    def initialize(relation, &block)
+    def initialize(default_table: nil, &block)
       @attributes = Set.new
-      @relation = relation
+      @default_table = default_table
 
       instance_eval(&block) if block
     end
@@ -42,7 +46,7 @@ module Pursuit
     # @return           [Arel::Attributes::Attribute]         The underlying attribute to query.
     #
     def search_attribute(attribute)
-      attribute = relation.klass.arel_table[attribute] if attribute.is_a?(Symbol)
+      attribute = default_table[attribute] if attribute.is_a?(Symbol)
       attributes.add(attribute)
     end
 
@@ -56,12 +60,13 @@ module Pursuit
       transform.apply(tree, attributes: attributes)
     end
 
-    # Returns #relation filtered by the term query.
+    # Applies the term clauses derived from `query` to `relation`.
     #
-    # @param  query [String]                 The term query.
-    # @return       [ActiveRecord::Relation] The updated relation with the term clauses added.
+    # @param  query    [String]                 The term query.
+    # @param  relation [ActiveRecord::Relation] The base relation to apply the term clauses to.
+    # @return          [ActiveRecord::Relation] The base relation with the term clauses applied.
     #
-    def apply(query)
+    def apply(query, relation)
       node = parse(query)
       node ? relation.where(node) : relation.none
     end

data/spec/internal/app/models/product.rb

@@ -1,38 +1,11 @@
 # frozen_string_literal: true
 
 class Product < ApplicationRecord
+  include ProductSearch
+
   belongs_to :category, class_name: 'ProductCategory', inverse_of: :products, optional: true
 
   has_many :variations, class_name: 'ProductVariation', inverse_of: :product
 
   validates :title, presence: true
-
-  def self.predicate_search
-    @predicate_search ||= Pursuit::PredicateSearch.new(
-      left_outer_joins(:category, :variations).group(:id).order(:title)
-    ) do
-      permit_attribute :title
-      permit_attribute :category, ProductCategory.arel_table[:id]
-      permit_attribute :category_name, ProductCategory.arel_table[:name]
-      permit_attribute :variation, ProductVariation.arel_table[:id]
-      permit_attribute :variation_title, ProductVariation.arel_table[:title]
-      permit_attribute :variation_currency, ProductVariation.arel_table[:currency]
-      permit_attribute :variation_amount, ProductVariation.arel_table[:amount]
-    end
-  end
-
-  def self.term_search
-    @term_search ||= Pursuit::TermSearch.new(
-      left_outer_joins(:category).group(:id).order(:title)
-    ) do
-      search_attribute :title
-      search_attribute ProductCategory.arel_table[:name]
-    end
-  end
-
-  def self.search(query)
-    predicate_search.apply(query)
-  rescue Parslet::ParseFailed
-    term_search.apply(query)
-  end
 end

data/spec/internal/app/models/product_category.rb

@@ -1,29 +1,9 @@
 # frozen_string_literal: true
 
 class ProductCategory < ApplicationRecord
+  include ProductCategorySearch
+
   has_many :products, class_name: 'Product', foreign_key: :category_id, inverse_of: :category, dependent: :nullify
 
   validates :name, presence: true
-
-  def self.predicate_search
-    @predicate_search ||= Pursuit::PredicateSearch.new(
-      left_outer_joins(:products).group(:id)
-    ) do
-      permit_attribute :name
-      permit_attribute :product, Product.arel_table[:id]
-      permit_attribute :product_title, Product.arel_table[:title]
-    end
-  end
-
-  def self.term_search
-    @term_search ||= Pursuit::TermSearch.new(all) do
-      search_attribute :name
-    end
-  end
-
-  def self.search(query)
-    predicate_search.apply(query)
-  rescue Parslet::ParseFailed
-    term_search.apply(query)
-  end
 end

data/spec/internal/app/models/product_variation.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 class ProductVariation < ApplicationRecord
+  include ProductVariationSearch
+
   belongs_to :product
 
   enum stock_status: { in_stock: 1, low_stock: 2, out_of_stock: 3 }
@@ -9,29 +11,4 @@ class ProductVariation < ApplicationRecord
 
   validates :currency, presence: true
   validates :amount, presence: true, numericality: true
-
-  def self.predicate_search
-    @predicate_search ||= Pursuit::PredicateSearch.new(
-      left_outer_joins(:product).group(:id)
-    ) do
-      permit_attribute :title
-      permit_attribute :stock_status
-      permit_attribute :currency
-      permit_attribute :amount
-      permit_attribute :product, Product.arel_table[:id]
-      permit_attribute :product_title, Product.arel_table[:title]
-    end
-  end
-
-  def self.term_search
-    @term_search ||= Pursuit::TermSearch.new(all) do
-      search_attribute :title
-    end
-  end
-
-  def self.search(query)
-    predicate_search.apply(query)
-  rescue Parslet::ParseFailed
-    term_search.apply(query)
-  end
 end

data/spec/internal/app/searches/product_category_search.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ProductCategorySearch
+  extend ActiveSupport::Concern
+
+  class_methods do
+    # Search for records matching the specified predicate.
+    #
+    # @param  query [String]                 The query with a predicate.
+    # @return       [ActiveRecord::Relation] The current relation filtered by the predicate.
+    #
+    def predicate_search(query)
+      @predicate_search ||= Pursuit::PredicateSearch.new(default_table: arel_table) do
+        permit_attribute :name
+        permit_attribute :product, Product.arel_table[:id]
+        permit_attribute :product_title, Product.arel_table[:title]
+      end
+
+      @predicate_search.apply(query, left_outer_joins(:products).group(:id))
+    end
+
+    # Search for records matching the specified terms.
+    #
+    # @param  query [String]                 The query with one or more terms.
+    # @return       [ActiveRecord::Relation] The current relation filtered by the terms.
+    #
+    def term_search(query)
+      @term_search ||= Pursuit::TermSearch.new(default_table: arel_table) do
+        search_attribute :name
+      end
+
+      # Note that we're using `all` here, but this still works when used in a chain:
+      # => ProductVariation.where(stock_status: :in_stock).search('Green')
+      @term_search.apply(query, all)
+    end
+
+    # Search for records matching the specified query.
+    #
+    # @param  query [String]                 The query.
+    # @return       [ActiveRecord::Relation] The current relation filtered by the query.
+    #
+    def search(query)
+      return none if query.blank?
+
+      predicate_search(query)
+    rescue Parslet::ParseFailed
+      term_search(query)
+    end
+  end
+end

data/spec/internal/app/searches/product_search.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ProductSearch
+  extend ActiveSupport::Concern
+
+  class_methods do
+    # Search for records matching the specified predicate.
+    #
+    # @param  query [String]                 The query with a predicate.
+    # @return       [ActiveRecord::Relation] The current relation filtered by the predicate.
+    #
+    def predicate_search(query)
+      @predicate_search ||= Pursuit::PredicateSearch.new(default_table: arel_table) do
+        permit_attribute :title
+        permit_attribute :category, ProductCategory.arel_table[:id]
+        permit_attribute :category_name, ProductCategory.arel_table[:name]
+        permit_attribute :variation, ProductVariation.arel_table[:id]
+        permit_attribute :variation_title, ProductVariation.arel_table[:title]
+        permit_attribute :variation_currency, ProductVariation.arel_table[:currency]
+        permit_attribute :variation_amount, ProductVariation.arel_table[:amount]
+      end
+
+      @predicate_search.apply(query, left_outer_joins(:category, :variations).group(:id).order(:title))
+    end
+
+    # Search for records matching the specified terms.
+    #
+    # @param  query [String]                 The query with one or more terms.
+    # @return       [ActiveRecord::Relation] The current relation filtered by the terms.
+    #
+    def term_search(query)
+      @term_search ||= Pursuit::TermSearch.new(default_table: arel_table) do
+        search_attribute :title
+        search_attribute ProductCategory.arel_table[:name]
+      end
+
+      @term_search.apply(query, left_outer_joins(:category).group(:id).order(:title))
+    end
+
+    # Search for records matching the specified query.
+    #
+    # @param  query [String]                 The query.
+    # @return       [ActiveRecord::Relation] The current relation filtered by the query.
+    #
+    def search(query)
+      return none if query.blank?
+
+      predicate_search(query)
+    rescue Parslet::ParseFailed
+      term_search(query)
+    end
+  end
+end

data/spec/internal/app/searches/product_variation_search.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ProductVariationSearch
+  extend ActiveSupport::Concern
+
+  class_methods do
+    # Search for records matching the specified predicate.
+    #
+    # @param  query [String]                 The query with a predicate.
+    # @return       [ActiveRecord::Relation] The current relation filtered by the predicate.
+    #
+    def predicate_search(query)
+      @predicate_search ||= Pursuit::PredicateSearch.new(default_table: arel_table) do
+        permit_attribute :title
+        permit_attribute :stock_status
+        permit_attribute :currency
+        permit_attribute :amount
+        permit_attribute :product, Product.arel_table[:id]
+        permit_attribute :product_title, Product.arel_table[:title]
+      end
+
+      @predicate_search.apply(query, left_outer_joins(:product).group(:id))
+    end
+
+    # Search for records matching the specified terms.
+    #
+    # @param  query [String]                 The query with one or more terms.
+    # @return       [ActiveRecord::Relation] The current relation filtered by the terms.
+    #
+    def term_search(query)
+      @term_search ||= Pursuit::TermSearch.new(default_table: arel_table) do
+        search_attribute :title
+      end
+
+      # Note that we're using `all` here, but this still works when used in a chain:
+      # => ProductVariation.where(stock_status: :in_stock).search('Green')
+      @term_search.apply(query, all)
+    end
+
+    # Search for records matching the specified query.
+    #
+    # @param  query [String]                 The query.
+    # @return       [ActiveRecord::Relation] The current relation filtered by the query.
+    #
+    def search(query)
+      return none if query.blank?
+
+      predicate_search(query)
+    rescue Parslet::ParseFailed
+      term_search(query)
+    end
+  end
+end

data/spec/lib/pursuit/predicate_search_spec.rb

@@ -2,27 +2,66 @@
 
 RSpec.describe Pursuit::PredicateSearch do
   subject(:predicate_search) do
-    described_class.new(
-      Product.left_outer_joins(:variations).group(:id),
-      permit_aggregate_modifiers: true
-    ) do
-      permit_attribute :title
-      permit_attribute :variation, ProductVariation.arel_table[:id]
-      permit_attribute :variation_title, ProductVariation.arel_table[:title]
-    end
+    described_class.new(default_table: Product.arel_table, permit_aggregate_modifiers: true)
   end
 
   describe '#initialize' do
-    it 'is expected to set #relation eq `relation`' do
-      expect(predicate_search).to have_attributes(relation: Product.left_outer_joins(:variations).group(:id))
+    it 'is expected to set #default_table eq `default_table`' do
+      expect(predicate_search).to have_attributes(default_table: Product.arel_table)
     end
 
     it 'is expected to set #permit_aggregate_modifiers eq `permit_aggregate_modifiers`' do
       expect(predicate_search).to have_attributes(permit_aggregate_modifiers: true)
     end
 
-    it 'is expected to evaluate the passed block' do
-      expect(predicate_search.permitted_attributes).to be_present
+    it 'is expected to invoke the passed block' do
+      expect { |block| described_class.new(&block) }.to yield_control
+    end
+  end
+
+  describe '#permit_attribute' do
+    subject(:permit_attribute) { predicate_search.permit_attribute(name, attribute) }
+
+    context 'when `attribute` is nil' do
+      let(:name)      { :title }
+      let(:attribute) { nil }
+
+      it 'is expected to add the attribute from #default_table to #permitted_attributes' do
+        permit_attribute
+        expect(predicate_search.permitted_attributes).to match(
+          hash_including(
+            title: Product.arel_table[:title]
+          )
+        )
+      end
+    end
+
+    context 'when `attribute` is a Symbol' do
+      let(:name)      { :name }
+      let(:attribute) { :title }
+
+      it 'is expected to add the attribute from #default_table to #permitted_attributes' do
+        permit_attribute
+        expect(predicate_search.permitted_attributes).to match(
+          hash_including(
+            name: Product.arel_table[:title]
+          )
+        )
+      end
+    end
+
+    context 'when `attribute` is an Arel::Attributes::Attribute' do
+      let(:name)      { :variation_currency }
+      let(:attribute) { ProductVariation.arel_table[:currency] }
+
+      it 'is expected to add the attribute to #permitted_attributes' do
+        permit_attribute
+        expect(predicate_search.permitted_attributes).to match(
+          hash_including(
+            variation_currency: ProductVariation.arel_table[:currency]
+          )
+        )
+      end
     end
   end
 
@@ -38,24 +77,15 @@ RSpec.describe Pursuit::PredicateSearch do
     it { is_expected.to be_a(Pursuit::PredicateTransform) }
   end
 
-  describe '#permit_attribute' do
-    subject(:permit_attribute) do
-      predicate_search.permit_attribute(:variation_currency, ProductVariation.arel_table[:currency])
-    end
-
-    it 'is expected to add the attribute to #permitted_attributes' do
-      permit_attribute
-      expect(predicate_search.permitted_attributes).to match(
-        hash_including(
-          variation_currency: ProductVariation.arel_table[:currency]
-        )
-      )
-    end
-  end
-
   describe '#parse' do
     subject(:parse) { predicate_search.parse('title ~ Shirt & #variation > 0') }
 
+    before do
+      predicate_search.permitted_attributes[:title] = Product.arel_table[:title]
+      predicate_search.permitted_attributes[:variation] = ProductVariation.arel_table[:id]
+      predicate_search.permitted_attributes[:variation_title] = ProductVariation.arel_table[:title]
+    end
+
     it 'is expected to equal a Hash containing the ARel nodes' do
       expect(parse).to eq(
         {
@@ -67,9 +97,15 @@ RSpec.describe Pursuit::PredicateSearch do
   end
 
   describe '#apply' do
-    subject(:apply) { predicate_search.apply('title ~ Shirt') }
+    subject(:apply) { predicate_search.apply('title ~ Shirt', Product.left_outer_joins(:variations).group(:id)) }
+
+    before do
+      predicate_search.permitted_attributes[:title] = Product.arel_table[:title]
+      predicate_search.permitted_attributes[:variation] = ProductVariation.arel_table[:id]
+      predicate_search.permitted_attributes[:variation_title] = ProductVariation.arel_table[:title]
+    end
 
-    it 'is expected to equal #relation with predicate clauses applied' do
+    it 'is expected to equal `relation` with predicate clauses applied' do
       expect(apply).to eq(
         Product.left_outer_joins(:variations).group(:id).where(
           Product.arel_table[:title].matches('%Shirt%')

data/spec/lib/pursuit/simple_search_spec.rb

@@ -1,39 +1,48 @@
 # frozen_string_literal: true
 
 RSpec.describe Pursuit::SimpleSearch do
-  subject(:simple_search) do
-    described_class.new(
-      Product.left_outer_joins(:variations).group(:id)
-    ) do
-      search_attribute :title
-      search_attribute ProductVariation.arel_table[:title]
-    end
-  end
+  subject(:simple_search) { described_class.new(default_table: Product.arel_table) }
 
   describe '#initialize' do
-    it 'is expected to set #relation eq `relation`' do
-      expect(simple_search).to have_attributes(relation: Product.left_outer_joins(:variations).group(:id))
+    it 'is expected to set #default_table eq `default_table`' do
+      expect(simple_search).to have_attributes(default_table: Product.arel_table)
     end
 
-    it 'is expected to evaluate the passed block' do
-      expect(simple_search.attributes).to be_present
+    it 'is expected to invoke the passed block' do
+      expect { |block| described_class.new(&block) }.to yield_control
     end
   end
 
   describe '#search_attribute' do
-    subject(:search_attribute) do
-      simple_search.search_attribute(ProductVariation.arel_table[:currency])
+    subject(:search_attribute) { simple_search.search_attribute(attribute) }
+
+    context 'when `attribute` is a Symbol' do
+      let(:attribute) { :title }
+
+      it 'is expected to add the attribute from #default_table to #attributes' do
+        search_attribute
+        expect(simple_search.attributes).to include(Product.arel_table[:title])
+      end
     end
 
-    it 'is expected to add the attribute to #attributes' do
-      search_attribute
-      expect(simple_search.attributes).to include(ProductVariation.arel_table[:currency])
+    context 'when `attribute` is an Arel::Attributes::Attribute' do
+      let(:attribute) { ProductVariation.arel_table[:currency] }
+
+      it 'is expected to add the attribute to #attributes' do
+        search_attribute
+        expect(simple_search.attributes).to include(ProductVariation.arel_table[:currency])
+      end
     end
   end
 
   describe '#parse' do
     subject(:parse) { simple_search.parse('Shirt') }
 
+    before do
+      simple_search.attributes << Product.arel_table[:title]
+      simple_search.attributes << ProductVariation.arel_table[:title]
+    end
+
     it 'is expected to equal the ARel node' do
       expect(parse).to eq(
         Product.arel_table[:title].matches('%Shirt%').or(
@@ -44,9 +53,14 @@ RSpec.describe Pursuit::SimpleSearch do
   end
 
   describe '#apply' do
-    subject(:apply) { simple_search.apply('Shirt') }
+    subject(:apply) { simple_search.apply('Shirt', Product.left_outer_joins(:variations).group(:id)) }
+
+    before do
+      simple_search.attributes << Product.arel_table[:title]
+      simple_search.attributes << ProductVariation.arel_table[:title]
+    end
 
-    it 'is expected to equal #relation with clauses applied' do
+    it 'is expected to equal `relation` with simple clauses applied' do
       expect(apply).to eq(
         Product.left_outer_joins(:variations).group(:id).where(
           Product.arel_table[:title].matches('%Shirt%').or(

data/spec/lib/pursuit/term_search_spec.rb

@@ -1,22 +1,15 @@
 # frozen_string_literal: true
 
 RSpec.describe Pursuit::TermSearch do
-  subject(:term_search) do
-    described_class.new(
-      Product.left_outer_joins(:variations).group(:id)
-    ) do
-      search_attribute :title
-      search_attribute ProductVariation.arel_table[:title]
-    end
-  end
+  subject(:term_search) { described_class.new(default_table: Product.arel_table) }
 
   describe '#initialize' do
-    it 'is expected to set #relation eq `relation`' do
-      expect(term_search).to have_attributes(relation: Product.left_outer_joins(:variations).group(:id))
+    it 'is expected to set #default_table eq `default_table`' do
+      expect(term_search).to have_attributes(default_table: Product.arel_table)
     end
 
-    it 'is expected to evaluate the passed block' do
-      expect(term_search.attributes).to be_present
+    it 'is expected to invoke the passed block' do
+      expect { |block| described_class.new(&block) }.to yield_control
     end
   end
 
@@ -33,19 +26,35 @@ RSpec.describe Pursuit::TermSearch do
   end
 
   describe '#search_attribute' do
-    subject(:search_attribute) do
-      term_search.search_attribute(ProductVariation.arel_table[:currency])
+    subject(:search_attribute) { term_search.search_attribute(attribute) }
+
+    context 'when `attribute` is a Symbol' do
+      let(:attribute) { :title }
+
+      it 'is expected to add the attribute from #default_table to #attributes' do
+        search_attribute
+        expect(term_search.attributes).to include(Product.arel_table[:title])
+      end
     end
 
-    it 'is expected to add the attribute to #attributes' do
-      search_attribute
-      expect(term_search.attributes).to include(ProductVariation.arel_table[:currency])
+    context 'when `attribute` is an Arel::Attributes::Attribute' do
+      let(:attribute) { ProductVariation.arel_table[:currency] }
+
+      it 'is expected to add the attribute to #attributes' do
+        search_attribute
+        expect(term_search.attributes).to include(ProductVariation.arel_table[:currency])
+      end
     end
   end
 
   describe '#parse' do
     subject(:parse) { term_search.parse('Shirt') }
 
+    before do
+      term_search.attributes << Product.arel_table[:title]
+      term_search.attributes << ProductVariation.arel_table[:title]
+    end
+
     it 'is expected to equal the ARel node' do
       expect(parse).to eq(
         Product.arel_table[:title].matches('%Shirt%').or(
@@ -56,9 +65,14 @@ RSpec.describe Pursuit::TermSearch do
   end
 
   describe '#apply' do
-    subject(:apply) { term_search.apply('Shirt') }
+    subject(:apply) { term_search.apply('Shirt', Product.left_outer_joins(:variations).group(:id)) }
+
+    before do
+      term_search.attributes << Product.arel_table[:title]
+      term_search.attributes << ProductVariation.arel_table[:title]
+    end
 
-    it 'is expected to equal #relation with term clauses applied' do
+    it 'is expected to equal `relation` with term clauses applied' do
       expect(apply).to eq(
         Product.left_outer_joins(:variations).group(:id).where(
           Product.arel_table[:title].matches('%Shirt%').or(

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pursuit
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Nialto Services
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-02 00:00:00.000000000 Z
+date: 2023-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -106,6 +106,9 @@ files:
 - spec/internal/app/models/product.rb
 - spec/internal/app/models/product_category.rb
 - spec/internal/app/models/product_variation.rb
+- spec/internal/app/searches/product_category_search.rb
+- spec/internal/app/searches/product_search.rb
+- spec/internal/app/searches/product_variation_search.rb
 - spec/internal/config/database.yml
 - spec/internal/db/schema.rb
 - spec/internal/log/.keep