pursuit 0.4.3 → 1.0.1

data/lib/pursuit/predicate_transform.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+module Pursuit
+  # Transform for the tree produced by `Pursuit::PredicateParser`.
+  #
+  # @see Pursuit::PredicateParser
+  #
+  class PredicateTransform < Parslet::Transform
+    # @return [Hash<String, Symbol>] The list of supported aggregate modifiers, and the method name to invoke on the
+    #                                attribute node in order to obtain the function node.
+    #
+    AGGREGATE_MODIFIERS = {
+      '#' => :count,
+      '*' => :sum,
+      '+' => :maximum,
+      '-' => :minimum,
+      '~' => :average
+    }.freeze
+
+    # Boolean Types
+
+    rule(truthy: simple(:_)) { true }
+    rule(falsey: simple(:_)) { false }
+
+    # Numeric Types
+
+    rule(integer: simple(:value)) { Integer(value) }
+    rule(decimal: simple(:value)) { BigDecimal(value) }
+
+    # String Types
+
+    rule(string_double_quotes: [])             { '' }
+    rule(string_double_quotes: simple(:value)) { value.to_s.gsub(/\\(.)/, '\1') }
+
+    rule(string_single_quotes: [])             { '' }
+    rule(string_single_quotes: simple(:value)) { value.to_s.gsub(/\\(.)/, '\1') }
+
+    rule(string_no_quotes: simple(:value)) { value.to_s }
+
+    # Comparisons
+
+    rule(attribute: simple(:attribute), comparator: '=', value: simple(:value)) do |context|
+      eq_node(attribute(context), context[:value])
+    end
+
+    rule(attribute: simple(:attribute), comparator: '!=', value: simple(:value)) do |context|
+      not_eq_node(attribute(context), context[:value])
+    end
+
+    rule(attribute: simple(:attribute), comparator: '<', value: simple(:value)) do |context|
+      lt_node(attribute(context), context[:value])
+    end
+
+    rule(attribute: simple(:attribute), comparator: '>', value: simple(:value)) do |context|
+      gt_node(attribute(context), context[:value])
+    end
+
+    rule(attribute: simple(:attribute), comparator: '<=', value: simple(:value)) do |context|
+      lteq_node(attribute(context), context[:value])
+    end
+
+    rule(attribute: simple(:attribute), comparator: '>=', value: simple(:value)) do |context|
+      gteq_node(attribute(context), context[:value])
+    end
+
+    rule(attribute: simple(:attribute), comparator: '~', value: simple(:value)) do |context|
+      match_node(attribute(context), context[:value])
+    end
+
+    rule(attribute: simple(:attribute), comparator: '!~', value: simple(:value)) do |context|
+      does_not_match_node(attribute(context), context[:value])
+    end
+
+    # Aggregate Comparisons
+
+    rule(
+      aggregate_modifier: simple(:aggregate_modifier),
+      attribute: simple(:attribute),
+      comparator: '=',
+      value: simple(:value)
+    ) do |context|
+      eq_node(aggregate_attribute(context), context[:value])
+    end
+
+    rule(
+      aggregate_modifier: simple(:aggregate_modifier),
+      attribute: simple(:attribute),
+      comparator: '!=',
+      value: simple(:value)
+    ) do |context|
+      not_eq_node(aggregate_attribute(context), context[:value])
+    end
+
+    rule(
+      aggregate_modifier: simple(:aggregate_modifier),
+      attribute: simple(:attribute),
+      comparator: '<',
+      value: simple(:value)
+    ) do |context|
+      lt_node(aggregate_attribute(context), context[:value])
+    end
+
+    rule(
+      aggregate_modifier: simple(:aggregate_modifier),
+      attribute: simple(:attribute),
+      comparator: '>',
+      value: simple(:value)
+    ) do |context|
+      gt_node(aggregate_attribute(context), context[:value])
+    end
+
+    rule(
+      aggregate_modifier: simple(:aggregate_modifier),
+      attribute: simple(:attribute),
+      comparator: '<=',
+      value: simple(:value)
+    ) do |context|
+      lteq_node(aggregate_attribute(context), context[:value])
+    end
+
+    rule(
+      aggregate_modifier: simple(:aggregate_modifier),
+      attribute: simple(:attribute),
+      comparator: '>=',
+      value: simple(:value)
+    ) do |context|
+      gteq_node(aggregate_attribute(context), context[:value])
+    end
+
+    rule(
+      aggregate_modifier: simple(:aggregate_modifier),
+      attribute: simple(:attribute),
+      comparator: '~',
+      value: simple(:value)
+    ) do |context|
+      match_node(aggregate_attribute(context), context[:value])
+    end
+
+    rule(
+      aggregate_modifier: simple(:aggregate_modifier),
+      attribute: simple(:attribute),
+      comparator: '!~',
+      value: simple(:value)
+    ) do |context|
+      does_not_match_node(aggregate_attribute(context), context[:value])
+    end
+
+    # Joins
+
+    rule(left: simple(:left), joiner: '&', right: simple(:right)) do
+      left.and(right)
+    end
+
+    rule(left: simple(:left), joiner: '|', right: simple(:right)) do
+      left.or(right)
+    end
+
+    # Helpers
+
+    class << self
+      def attribute(context)
+        attribute_name = context[:attribute].to_sym
+        attribute = context.dig(:permitted_attributes, attribute_name)
+        raise AttributeNotFound, attribute_name if attribute.blank?
+        raise AggregateModifierRequired, attribute_name if attribute.name == Arel.star
+
+        attribute
+      end
+
+      def aggregate_attribute(context)
+        raise AggregateModifiersNotAvailable unless context[:permit_aggregate_modifiers]
+
+        attribute_name = context[:attribute].to_sym
+        attribute = context.dig(:permitted_attributes, attribute_name)
+        raise AttributeNotFound, attribute_name if attribute.blank?
+
+        aggregate_modifier_name = context[:aggregate_modifier].to_s
+        aggregate_modifier = AGGREGATE_MODIFIERS[aggregate_modifier_name]
+        raise AggregateModifierNotFound, aggregate_modifier_name unless aggregate_modifier
+
+        attribute.public_send(aggregate_modifier)
+      end
+
+      def eq_node(attribute, value)
+        value = ActiveRecord::Base.sanitize_sql(value) if value.is_a?(String)
+        return attribute.eq(value) if value.present?
+
+        attribute.eq(nil).or(attribute.matches_regexp('^\s*$'))
+      end
+
+      def not_eq_node(attribute, value)
+        value = ActiveRecord::Base.sanitize_sql(value) if value.is_a?(String)
+        return attribute.not_eq(value) if value.present?
+
+        attribute.not_eq(nil).and(attribute.does_not_match_regexp('^\s*$'))
+      end
+
+      def gt_node(attribute, value)
+        value = ActiveRecord::Base.sanitize_sql(value) if value.is_a?(String)
+        attribute.gt(value)
+      end
+
+      def gteq_node(attribute, value)
+        value = ActiveRecord::Base.sanitize_sql(value) if value.is_a?(String)
+        attribute.gteq(value)
+      end
+
+      def lt_node(attribute, value)
+        value = ActiveRecord::Base.sanitize_sql(value) if value.is_a?(String)
+        attribute.lt(value)
+      end
+
+      def lteq_node(attribute, value)
+        value = ActiveRecord::Base.sanitize_sql(value) if value.is_a?(String)
+        attribute.lteq(value)
+      end
+
+      def match_node(attribute, value)
+        value = ActiveRecord::Base.sanitize_sql_like(value) if value.is_a?(String)
+        value = value.blank? ? '%' : "%#{value}%"
+        attribute.matches(value)
+      end
+
+      def does_not_match_node(attribute, value)
+        value = ActiveRecord::Base.sanitize_sql_like(value) if value.is_a?(String)
+        value = value.blank? ? '%' : "%#{value}%"
+        attribute.does_not_match(value)
+      end
+    end
+  end
+end

data/lib/pursuit/query_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Pursuit
+  # Base error class for all query related errors.
+  #
+  class QueryError < Error; end
+end

data/lib/pursuit/simple_search.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Pursuit
+  # :nodoc:
+  #
+  class SimpleSearch
+    # @return [Set<Arel::Attributes::Attribute>] The attributes to match against.
+    #
+    attr_reader :attributes
+
+    # @return [ActiveRecord::Relation] The relation to which the clauses are added.
+    #
+    attr_reader :relation
+
+    # 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).
+    #
+    def initialize(relation, &block)
+      @attributes = Set.new
+      @relation = relation
+
+      instance_eval(&block) if block
+    end
+
+    # Adds an attribute to match against in queries.
+    #
+    # @param  attribute [Arel::Attributes::Attribute, Symbol] The underlying attribute to query.
+    # @return           [Arel::Attributes::Attribute]         The underlying attribute to query.
+    #
+    def search_attribute(attribute)
+      attribute = relation.klass.arel_table[attribute] if attribute.is_a?(Symbol)
+      attributes.add(attribute)
+    end
+
+    # Parse a simple query into an ARel node.
+    #
+    # @param  query [String]            The simple query.
+    # @return       [Arel::Nodes::Node] The ARel node representing the simple query.
+    #
+    def parse(query)
+      value = ActiveRecord::Base.sanitize_sql_like(query)
+      value = "%#{value}%"
+
+      attributes.inject(nil) do |previous_node, attribute|
+        node = attribute.matches(value)
+        next node unless previous_node
+
+        previous_node.or(node)
+      end
+    end
+
+    # Returns #relation filtered by the query.
+    #
+    # @param  query [String]                 The simple query.
+    # @return       [ActiveRecord::Relation] The updated relation with the clauses added.
+    #
+    def apply(query)
+      node = parse(query)
+      node ? relation.where(node) : relation.none
+    end
+  end
+end

data/lib/pursuit/term_parser.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Pursuit
+  # Parser for a list of terms.
+  #
+  class TermParser < Parslet::Parser
+    # Whitespace
+
+    rule(:space)  { match('\s').repeat(1) }
+    rule(:space?) { match('\s').repeat(0) }
+
+    # Character Types
+
+    rule(:escaped_character) do
+      str('\\') >> match('.')
+    end
+
+    # String Types
+
+    rule(:string_double_quotes) do
+      str('"') >> (escaped_character | match('[^"]')).repeat(0).as(:string_double_quotes) >> str('"')
+    end
+
+    rule(:string_single_quotes) do
+      str("'") >> (escaped_character | match("[^']")).repeat(0).as(:string_single_quotes) >> str("'")
+    end
+
+    rule(:string_no_quotes) do
+      match('[^\s]').repeat(1).as(:string_no_quotes)
+    end
+
+    rule(:string) do
+      string_double_quotes | string_single_quotes | string_no_quotes
+    end
+
+    # Terms
+
+    rule(:term)      { string.as(:term) }
+    rule(:term_pair) { term.as(:left) >> space >> term_node.as(:right) }
+    rule(:term_node) { term_pair | term }
+    rule(:terms)     { space? >> term_node >> space? }
+    root(:terms)
+  end
+end

data/lib/pursuit/term_search.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Pursuit
+  # :nodoc:
+  #
+  class TermSearch
+    # @return [Set<Arel::Attributes::Attribute>] The attributes to match against.
+    #
+    attr_reader :attributes
+
+    # @return [ActiveRecord::Relation] The relation to which the term clauses are added.
+    #
+    attr_reader :relation
+
+    # 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).
+    #
+    def initialize(relation, &block)
+      @attributes = Set.new
+      @relation = relation
+
+      instance_eval(&block) if block
+    end
+
+    # @return [Pursuit::TermParser] The parser which converts queries into trees.
+    #
+    def parser
+      @parser ||= TermParser.new
+    end
+
+    # @return [Pursuit::TermTransform] The transform which converts trees into ARel nodes.
+    #
+    def transform
+      @transform ||= TermTransform.new
+    end
+
+    # Adds an attribute to match against in term queries.
+    #
+    # @param  attribute [Arel::Attributes::Attribute, Symbol] The underlying attribute to query.
+    # @return           [Arel::Attributes::Attribute]         The underlying attribute to query.
+    #
+    def search_attribute(attribute)
+      attribute = relation.klass.arel_table[attribute] if attribute.is_a?(Symbol)
+      attributes.add(attribute)
+    end
+
+    # Parse a term query into an ARel node.
+    #
+    # @param  query [String]            The term query.
+    # @return       [Arel::Nodes::Node] The ARel node representing the term query.
+    #
+    def parse(query)
+      tree = parser.parse(query)
+      transform.apply(tree, attributes: attributes)
+    end
+
+    # Returns #relation filtered by the term query.
+    #
+    # @param  query [String]                 The term query.
+    # @return       [ActiveRecord::Relation] The updated relation with the term clauses added.
+    #
+    def apply(query)
+      node = parse(query)
+      node ? relation.where(node) : relation.none
+    end
+  end
+end

data/lib/pursuit/term_transform.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Pursuit
+  # Transform for a list of terms.
+  #
+  class TermTransform < Parslet::Transform
+    # String Types
+
+    rule(string_double_quotes: [])             { '' }
+    rule(string_double_quotes: simple(:value)) { value.to_s.gsub(/\\(.)/, '\1') }
+
+    rule(string_single_quotes: [])             { '' }
+    rule(string_single_quotes: simple(:value)) { value.to_s.gsub(/\\(.)/, '\1') }
+
+    rule(string_no_quotes: simple(:value)) { value.to_s }
+
+    # Terms
+
+    rule(term: simple(:term)) do |context|
+      value = ActiveRecord::Base.sanitize_sql_like(context[:term])
+      value = "%#{value}%"
+
+      context[:attributes].inject(nil) do |previous_node, attribute|
+        node = attribute.matches(value)
+        next node unless previous_node
+
+        previous_node.or(node)
+      end
+    end
+
+    # Joins
+
+    rule(left: simple(:left), right: simple(:right)) { left.and(right) }
+  end
+end

data/lib/pursuit.rb

@@ -1,7 +1,21 @@
 # frozen_string_literal: true
 
-require 'pursuit/constants'
-require 'pursuit/search_options'
-require 'pursuit/search_term_parser'
-require 'pursuit/search'
-require 'pursuit/railtie' if defined?(Rails::Railtie)
+require 'active_record'
+require 'active_support'
+require 'bigdecimal'
+require 'parslet'
+
+require_relative 'pursuit/constants'
+require_relative 'pursuit/error'
+require_relative 'pursuit/query_error'
+require_relative 'pursuit/aggregate_modifier_not_found'
+require_relative 'pursuit/aggregate_modifier_required'
+require_relative 'pursuit/aggregate_modifiers_not_available'
+require_relative 'pursuit/attribute_not_found'
+require_relative 'pursuit/predicate_parser'
+require_relative 'pursuit/predicate_transform'
+require_relative 'pursuit/predicate_search'
+require_relative 'pursuit/term_parser'
+require_relative 'pursuit/term_transform'
+require_relative 'pursuit/term_search'
+require_relative 'pursuit/simple_search'

data/pursuit.gemspec

@@ -12,8 +12,8 @@ Gem::Specification.new do |spec|
   spec.email         = ['support@nialtoservices.co.uk']
 
   spec.summary       = 'Advanced key-based searching for ActiveRecord objects.'
-  spec.homepage      = 'https://github.com/nialtoservices/pursuit'
-  spec.license       = 'MIT'
+  spec.homepage      = 'https://github.com/NialtoServices/pursuit'
+  spec.license       = 'Apache-2.0'
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.require_paths = ['lib']
@@ -23,20 +23,7 @@ Gem::Specification.new do |spec|
   spec.metadata['rubygems_mfa_required'] = 'true'
   spec.metadata['yard.run'] = 'yri'
 
-  spec.add_runtime_dependency 'activerecord',  '>= 5.2.0', '< 7.1.0'
-  spec.add_runtime_dependency 'activesupport', '>= 5.2.0', '< 7.1.0'
-
-  spec.add_development_dependency 'bundler',       '~> 2.0'
-  spec.add_development_dependency 'combustion',    '~> 1.3'
-  spec.add_development_dependency 'guard',         '~> 2.18'
-  spec.add_development_dependency 'guard-rspec',   '~> 4.7'
-  spec.add_development_dependency 'pry',           '~> 0.14'
-  spec.add_development_dependency 'rake',          '~> 13.0'
-  spec.add_development_dependency 'rspec',         '~> 3.12'
-  spec.add_development_dependency 'rspec-rails',   '~> 6.0'
-  spec.add_development_dependency 'rubocop',       '~> 1.44'
-  spec.add_development_dependency 'rubocop-rake',  '~> 0.6'
-  spec.add_development_dependency 'rubocop-rspec', '~> 2.18'
-  spec.add_development_dependency 'sqlite3',       '~> 1.6'
-  spec.add_development_dependency 'yard',          '~> 0.9'
+  spec.add_runtime_dependency 'activerecord',  '>= 5.2.0', '<= 8.0.0'
+  spec.add_runtime_dependency 'activesupport', '>= 5.2.0', '<= 8.0.0'
+  spec.add_runtime_dependency 'parslet',       '~> 2.0'
 end

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end

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

@@ -1,22 +1,38 @@
 # frozen_string_literal: true
 
-class Product < ActiveRecord::Base
+class Product < ApplicationRecord
   belongs_to :category, class_name: 'ProductCategory', inverse_of: :products, optional: true
 
   has_many :variations, class_name: 'ProductVariation', inverse_of: :product
 
   validates :title, presence: true
 
-  searchable do |o|
-    o.relation :variations, :title, :stock_status
+  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
 
-    o.attribute :title
-    o.attribute :description
-    o.attribute :rating, unkeyed: false
-    o.attribute :title_length, unkeyed: false do
-      Arel::Nodes::NamedFunction.new('LENGTH', [arel_table[:title]])
+  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
 
-    o.attribute :category, :category_id
+  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,7 +1,29 @@
 # frozen_string_literal: true
 
-class ProductCategory < ActiveRecord::Base
+class ProductCategory < ApplicationRecord
   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,6 @@
 # frozen_string_literal: true
 
-class ProductVariation < ActiveRecord::Base
+class ProductVariation < ApplicationRecord
   belongs_to :product
 
   enum stock_status: { in_stock: 1, low_stock: 2, out_of_stock: 3 }
@@ -9,4 +9,29 @@ class ProductVariation < ActiveRecord::Base
 
   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