pursuit 0.4.5 → 1.1.0

data/lib/pursuit/search.rb

@@ -1,172 +0,0 @@
-# frozen_string_literal: true
-
-module Pursuit
-  class Search
-    # @return [SearchOptions] The options to use when building the search query.
-    #
-    attr_reader :options
-
-    # Create a new instance to search a specific ActiveRecord record class.
-    #
-    # @param options [SearchOptions]
-    #
-    def initialize(options)
-      @options = options
-    end
-
-    # Perform a search for the specified query.
-    #
-    # @param  query [String]                 The query to transform into a SQL search.
-    # @return       [ActiveRecord::Relation] The search results.
-    #
-    def perform(query)
-      options.record_class.where(build_arel(query))
-    end
-
-    private
-
-    def build_arel(query)
-      parser = SearchTermParser.new(query, keys: options.keys)
-      unkeyed_arel = build_arel_for_unkeyed_term(parser.unkeyed_term)
-      keyed_arel = build_arel_for_keyed_terms(parser.keyed_terms)
-
-      if unkeyed_arel && keyed_arel
-        unkeyed_arel.and(keyed_arel)
-      else
-        unkeyed_arel || keyed_arel
-      end
-    end
-
-    def build_arel_for_unkeyed_term(value)
-      return nil if value.blank?
-
-      sanitized_value = "%#{ActiveRecord::Base.sanitize_sql_like(value)}%"
-      options.unkeyed_attributes.reduce(nil) do |chain, (_attribute_name, node_builder)|
-        node = node_builder.call.matches(sanitized_value)
-        chain ? chain.or(node) : node
-      end
-    end
-
-    def build_arel_for_keyed_terms(terms)
-      return nil if terms.blank?
-
-      terms.reduce(nil) do |chain, term|
-        attribute_name = term.key.to_sym
-        reflection = options.relations.key?(attribute_name) ? options.record_class.reflections[term.key] : nil
-        node = if reflection.present?
-                 attribute_names = options.relations[attribute_name]
-                 build_arel_for_reflection(reflection, attribute_names, term.operator, term.value)
-               else
-                 node_builder = options.keyed_attributes[attribute_name]
-                 build_arel_for_node(node_builder.call, term.operator, term.value)
-               end
-
-        chain ? chain.and(node) : node
-      end
-    end
-
-    def build_arel_for_node(node, operator, value) # rubocop:disable Metrics/CyclomaticComplexity
-      sanitized_value = ActiveRecord::Base.sanitize_sql_like(value)
-      sanitized_value = sanitized_value.to_i if sanitized_value =~ /^[0-9]+$/
-
-      case operator
-      when '>'   then node.gt(sanitized_value)
-      when '>='  then node.gteq(sanitized_value)
-      when '<'   then node.lt(sanitized_value)
-      when '<='  then node.lteq(sanitized_value)
-      when '*='  then node.matches("%#{sanitized_value}%")
-      when '!*=' then node.does_not_match("%#{sanitized_value}%")
-      when '!='  then node.not_eq(sanitized_value)
-      when '=='
-        if value.present?
-          node.eq(sanitized_value)
-        else
-          node.eq(nil).or(node.eq(''))
-        end
-      else
-        raise "The operator '#{operator}' is not supported."
-      end
-    end
-
-    def build_arel_for_reflection(reflection, attribute_names, operator, value)
-      nodes = build_arel_for_reflection_join(reflection)
-      count_nodes = build_arel_for_relation_count(nodes, operator, value) unless reflection.belongs_to?
-      return count_nodes if count_nodes.present?
-
-      match_nodes = attribute_names.reduce(nil) do |chain, attribute_name|
-        node = build_arel_for_node(reflection.klass.arel_table[attribute_name], operator, value)
-        chain ? chain.or(node) : node
-      end
-
-      return nil if match_nodes.blank?
-
-      nodes.where(match_nodes).project(1).exists
-    end
-
-    def build_arel_for_reflection_join(reflection)
-      if reflection.belongs_to?
-        build_arel_for_belongs_to_reflection_join(reflection)
-      else
-        build_arel_for_has_reflection_join(reflection)
-      end
-    end
-
-    def build_arel_for_belongs_to_reflection_join(reflection)
-      reflection_table = reflection.klass.arel_table
-      reflection_table.where(
-        reflection_table[reflection.join_primary_key].eq(
-          options.record_class.arel_table[reflection.join_foreign_key]
-        )
-      )
-    end
-
-    # rubocop:disable Metrics/AbcSize
-    def build_arel_for_has_reflection_join(reflection)
-      reflection_table = reflection.klass.arel_table
-      reflection_through = reflection.through_reflection
-
-      if reflection_through.present?
-        # :has_one through / :has_many through
-        reflection_through_table = reflection_through.klass.arel_table
-        reflection_table.join(reflection_through_table).on(
-          reflection_through_table[reflection.foreign_key].eq(reflection_table[reflection.klass.primary_key])
-        ).where(
-          reflection_through_table[reflection_through.foreign_key].eq(
-            options.record_class.arel_table[options.record_class.primary_key]
-          )
-        )
-      else
-        # :has_one / :has_many
-        reflection_table.where(
-          reflection_table[reflection.foreign_key].eq(
-            options.record_class.arel_table[options.record_class.primary_key]
-          )
-        )
-      end
-    end
-    # rubocop:enable Metrics/AbcSize
-
-    def build_arel_for_relation_count(nodes, operator, value) # rubocop:disable Metrics/CyclomaticComplexity
-      node_builder = proc do |klass|
-        count = ActiveRecord::Base.sanitize_sql_like(value).to_i
-        klass.new(nodes.project(Arel.star.count), count)
-      end
-
-      case operator
-      when '>'  then node_builder.call(Arel::Nodes::GreaterThan)
-      when '>=' then node_builder.call(Arel::Nodes::GreaterThanOrEqual)
-      when '<'  then node_builder.call(Arel::Nodes::LessThan)
-      when '<=' then node_builder.call(Arel::Nodes::LessThanOrEqual)
-      else
-        return nil unless value =~ /^([0-9]+)$/
-
-        case operator
-        when '=='  then node_builder.call(Arel::Nodes::Equality)
-        when '!='  then node_builder.call(Arel::Nodes::NotEqual)
-        when '*='  then node_builder.call(Arel::Nodes::Matches)
-        when '!*=' then node_builder.call(Arel::Nodes::DoesNotMatch)
-        end
-      end
-    end
-  end
-end

data/lib/pursuit/search_options.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-module Pursuit
-  class SearchOptions
-    # @return [Struct] The structure which holds the search options for a single attribute.
-    #
-    AttributeOptions = Struct.new(:keyed, :unkeyed, :block)
-
-    # @return [Class<ActiveRecord::Base>] The `ActiveRecord::Base` child class to search.
-    #
-    attr_reader :record_class
-
-    # @return [Hash<Symbol, Array<Symbol>>] The attribute names of the record's relatives which can be searched.
-    #
-    attr_reader :relations
-
-    # @return [Hash<Symbol, AttributeOptions>] The attributes which can be searched.
-    #
-    attr_reader :attributes
-
-    # Create a new `SearchOptions` and call the passed block to setup the options.
-    #
-    # @params record_class [Class<ActiveRecord::Base>]
-    # @params block        [Proc]
-    #
-    def initialize(record_class, &block)
-      @record_class = record_class
-      @relations = {}
-      @attributes = {}
-
-      block&.call(self)
-    end
-
-    # @return [Hash<Symbol, Proc>] The attributes which can be queried using a keyed term.
-    #
-    def keyed_attributes
-      attributes.each_with_object({}) do |(name, options), keyed_attributes|
-        keyed_attributes[name] = options.block if options.keyed
-      end
-    end
-
-    # @return [Hash<Symbol, Proc>] The attributes which can be queried using an unkeyed term.
-    #
-    def unkeyed_attributes
-      attributes.each_with_object({}) do |(name, options), unkeyed_attributes|
-        unkeyed_attributes[name] = options.block if options.unkeyed
-      end
-    end
-
-    # @return [Array<String>] The collection of all possible attributes which can be used as a keyed term.
-    #
-    def keys
-      keys = relations.keys + attributes.select { |_, a| a.keyed }.keys
-      keys.map(&:to_s).uniq
-    end
-
-    # Add a relation to search.
-    #
-    # @param name            [Symbol] The name of the relationship attribute.
-    # @param attribute_names [Splat]  The name of the attributes within the relationship to search.
-    #
-    def relation(name, *attribute_names)
-      relations[name] = attribute_names
-      nil
-    end
-
-    # Add an attribute to search.
-    #
-    # @param term_name      [Symbol]  The keyed search term (can be an existing attribute, or a custom value when
-    #                                 passing either the `attribute_name` or a block returning an Arel node).
-    # @param attribute_name [Symbol]  The attribute name to search (defaults to the keyword, when left blank and no
-    #                                 block is passed).
-    # @param keyed          [Boolean] `true` when the attribute should be searchable using a keyed term,
-    #                                 `false` otherwise.
-    # @param unkeyed        [Boolean] `true` when the attribute should be searchable using an unkeyed term,
-    #                                 `false` otherwise.
-    # @param block          [Proc]    A block which returns the Arel node to query against. When left blank, the
-    #                                 matching attribute from `.arel_table` is queried instead.
-    #
-    def attribute(term_name, attribute_name = nil, keyed: true, unkeyed: true, &block)
-      block ||= -> { record_class.arel_table[attribute_name || term_name] }
-      attributes[term_name] = AttributeOptions.new(keyed, unkeyed, block)
-      nil
-    end
-  end
-end

data/lib/pursuit/search_term_parser.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Pursuit
-  class SearchTermParser
-    # @return [Struct] Represents a single keyed term extracted from a query.
-    #
-    KeyedTerm = Struct.new(:key, :operator, :value)
-
-    # @return [Array<Pursuit::SearchTermParser::KeyedTerm>] The keys which are permitted for use as keyed terms.
-    #
-    attr_reader :keyed_terms
-
-    # @return [String] The unkeyed term.
-    #
-    attr_reader :unkeyed_term
-
-    # Create a new search term parser by parsing the specified query into an 'unkeyed term' and 'keyed terms'.
-    #
-    # @param query [String]        The query to parse.
-    # @param keys  [Array<String>] The keys which are permitted for use as keyed terms.
-    #
-    def initialize(query, keys: [])
-      @keyed_terms = []
-      @unkeyed_term = query.gsub(/(\s+)?(\w+)(==|\*=|!=|!\*=|<=|>=|<|>)("([^"]+)?"|'([^']+)?'|[^\s]+)(\s+)?/) do |term|
-        key = Regexp.last_match(2)
-        next term unless keys.include?(key)
-
-        operator = Regexp.last_match(3)
-        value = Regexp.last_match(4)
-        value = value[1..-2] if value =~ /^(".*"|'.*')$/
-
-        @keyed_terms << KeyedTerm.new(key, operator, value)
-
-        # Both the starting and ending spaces surrounding the keyed term can be removed, so in this case we'll need to
-        # replace with a single space to ensure the unkeyed term's words are separated correctly.
-        if term =~ /^\s.*\s$/
-          ' '
-        else
-          ''
-        end
-      end
-
-      @unkeyed_term = @unkeyed_term.strip
-    end
-  end
-end

data/spec/lib/pursuit/dsl_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Pursuit::DSL do
-  subject(:record) { Product.new }
-
-  describe '.search_options' do
-    subject(:search_options) { record.class.search_options }
-
-    it { is_expected.to be_a(Pursuit::SearchOptions) }
-  end
-
-  describe '.search' do
-    subject(:search) { record.class.search('funky') }
-
-    let(:product_a) { Product.create!(title: 'Plain Shirt') }
-    let(:product_b) { Product.create!(title: 'Funky Shirt') }
-
-    it 'is expected to return the matching records' do
-      expect(search).to contain_exactly(product_b)
-    end
-  end
-end

data/spec/lib/pursuit/search_options_spec.rb

@@ -1,146 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Pursuit::SearchOptions do
-  subject(:search_options) { described_class.new(Product) }
-
-  let(:title_length_node_builder) do
-    proc do
-      Arel::Nodes::NamedFunction.new('LENGTH', [Product.arel_table[:title]])
-    end
-  end
-
-  describe '#record_class' do
-    subject(:record_class) { search_options.record_class }
-
-    it 'is expected to eq the class passed during initialization' do
-      expect(record_class).to eq(Product)
-    end
-  end
-
-  describe '#relations' do
-    subject(:relations) { search_options.relations }
-
-    before do
-      search_options.relation :variations, :title, :stock_status
-    end
-
-    it 'is expected to contain the correct relations' do
-      expect(relations).to eq(variations: %i[title stock_status])
-    end
-  end
-
-  describe '#keyed_attributes' do
-    subject(:keyed_attributes) { search_options.keyed_attributes }
-
-    before do
-      search_options.attribute :title, keyed: false
-      search_options.attribute :title_length, &title_length_node_builder
-      search_options.attribute :description
-      search_options.attribute :rating, unkeyed: false
-    end
-
-    it 'is expected to contain the correct keyed attributes' do
-      expect(keyed_attributes.keys).to contain_exactly(:title_length, :description, :rating)
-    end
-
-    it 'is expected to set a default node builder for attributes declared without a block' do
-      expect(keyed_attributes[:description].call).to eq(Product.arel_table[:description])
-    end
-
-    it 'is expected to set a custom node builder for attributes declared with a block' do
-      expect(keyed_attributes[:title_length]).to eq(title_length_node_builder)
-    end
-  end
-
-  describe '#unkeyed_attributes' do
-    subject(:unkeyed_attributes) { search_options.unkeyed_attributes }
-
-    before do
-      search_options.attribute :title, keyed: false
-      search_options.attribute :title_length, &title_length_node_builder
-      search_options.attribute :description
-      search_options.attribute :rating, unkeyed: false
-    end
-
-    it 'is expected to contain the correct unkeyed attributes' do
-      expect(unkeyed_attributes.keys).to contain_exactly(:title, :title_length, :description)
-    end
-
-    it 'is expected to set a default node builder for attributes declared without a block' do
-      expect(unkeyed_attributes[:title].call).to eq(Product.arel_table[:title])
-    end
-
-    it 'is expected to set a custom node builder for attributes declared with a block' do
-      expect(unkeyed_attributes[:title_length]).to eq(title_length_node_builder)
-    end
-  end
-
-  describe '#relation' do
-    subject(:relation) { search_options.relation(:variations, :title, :stock_status) }
-
-    it 'is expected to add the relation to #relations' do
-      expect { relation }.to change(search_options, :relations).from({}).to(variations: %i[title stock_status])
-    end
-  end
-
-  describe '#attribute' do
-    subject(:attribute) { search_options.attribute(:description) }
-
-    it { is_expected.to be_nil }
-
-    it 'is expected to add the attribute to #attributes' do
-      expect { attribute }.to change(search_options.attributes, :keys).from([]).to(%i[description])
-    end
-
-    it 'is expected to allow keyed searching by default' do
-      attribute
-      expect(search_options.attributes[:description].keyed).to be(true)
-    end
-
-    it 'is expected to allow unkeyed searching by default' do
-      attribute
-      expect(search_options.attributes[:description].unkeyed).to be(true)
-    end
-
-    it 'is expected to query the #term_name attribute' do
-      attribute
-      expect(search_options.attributes[:description].block.call).to eq(Product.arel_table[:description])
-    end
-
-    context 'when passing the attribute name to search' do
-      subject(:attribute) { search_options.attribute(:desc, :description) }
-
-      it 'is expected to query the #attribute_name attribute' do
-        attribute
-        expect(search_options.attributes[:desc].block.call).to eq(Product.arel_table[:description])
-      end
-    end
-
-    context 'when passing :keyed eq false' do
-      subject(:attribute) { search_options.attribute(:description, keyed: false) }
-
-      it 'is expected to disallow keyed searching' do
-        attribute
-        expect(search_options.attributes[:description].keyed).to be(false)
-      end
-    end
-
-    context 'when passing :unkeyed eq false' do
-      subject(:attribute) { search_options.attribute(:description, unkeyed: false) }
-
-      it 'is expected to disallow unkeyed searching' do
-        attribute
-        expect(search_options.attributes[:description].unkeyed).to be(false)
-      end
-    end
-
-    context 'when passing a block' do
-      subject(:attribute) { search_options.attribute(:description, &title_length_node_builder) }
-
-      it 'is expected to query the result of the passed block' do
-        attribute
-        expect(search_options.attributes[:description].block).to eq(title_length_node_builder)
-      end
-    end
-  end
-end