pursuit 0.4.3 → 1.0.1

data/spec/lib/pursuit/simple_search_spec.rb

@@ -0,0 +1,59 @@
+# 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
+
+  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))
+    end
+
+    it 'is expected to evaluate the passed block' do
+      expect(simple_search.attributes).to be_present
+    end
+  end
+
+  describe '#search_attribute' do
+    subject(:search_attribute) do
+      simple_search.search_attribute(ProductVariation.arel_table[:currency])
+    end
+
+    it 'is expected to add the attribute to #attributes' do
+      search_attribute
+      expect(simple_search.attributes).to include(ProductVariation.arel_table[:currency])
+    end
+  end
+
+  describe '#parse' do
+    subject(:parse) { simple_search.parse('Shirt') }
+
+    it 'is expected to equal the ARel node' do
+      expect(parse).to eq(
+        Product.arel_table[:title].matches('%Shirt%').or(
+          ProductVariation.arel_table[:title].matches('%Shirt%')
+        )
+      )
+    end
+  end
+
+  describe '#apply' do
+    subject(:apply) { simple_search.apply('Shirt') }
+
+    it 'is expected to equal #relation with clauses applied' do
+      expect(apply).to eq(
+        Product.left_outer_joins(:variations).group(:id).where(
+          Product.arel_table[:title].matches('%Shirt%').or(
+            ProductVariation.arel_table[:title].matches('%Shirt%')
+          )
+        )
+      )
+    end
+  end
+end

data/spec/lib/pursuit/term_parser_spec.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+RSpec.describe Pursuit::TermParser do
+  subject(:parser) { described_class.new }
+
+  describe '#space' do
+    subject(:space) { parser.space }
+
+    context 'when parsing an empty value' do
+      subject(:parse) { space.parse('') }
+
+      it { expect { parse }.to raise_exception(Parslet::ParseFailed) }
+    end
+
+    context 'when parsing one or more spaces' do
+      subject(:parse) { space.parse(value) }
+
+      let(:value) { ' ' * rand(1..10) }
+
+      it 'is expected to eq the parsed spaces' do
+        expect(parse).to eq(value)
+      end
+    end
+  end
+
+  describe '#space?' do
+    subject(:space?) { parser.space? }
+
+    context 'when parsing an empty value' do
+      subject(:parse) { space?.parse('') }
+
+      it 'is expected to eq the empty value' do
+        expect(parse).to eq('')
+      end
+    end
+
+    context 'when parsing one or more spaces' do
+      subject(:parse) { space?.parse(value) }
+
+      let(:value) { ' ' * rand(1..10) }
+
+      it 'is expected to eq the parsed spaces' do
+        expect(parse).to eq(value)
+      end
+    end
+  end
+
+  describe '#escaped_character' do
+    subject(:escaped_character) { parser.escaped_character }
+
+    context 'when parsing an escaped character' do
+      subject(:parse) { escaped_character.parse('\\"') }
+
+      it 'is expected to eq the escaped character' do
+        expect(parse).to eq('\\"')
+      end
+    end
+
+    context 'when parsing an unescaped character' do
+      subject(:parse) { escaped_character.parse('"') }
+
+      it { expect { parse }.to raise_exception(Parslet::ParseFailed) }
+    end
+  end
+
+  describe '#string_double_quotes' do
+    subject(:string_double_quotes) { parser.string_double_quotes }
+
+    context 'when parsing a double quoted string' do
+      subject(:parse) { string_double_quotes.parse('"Double \"Quoted\""') }
+
+      it 'is expected to capture the contents of the double quotes as :string_double_quotes' do
+        expect(parse).to eq(string_double_quotes: 'Double \"Quoted\"')
+      end
+    end
+
+    context 'when parsing a single quoted string' do
+      subject(:parse) { string_double_quotes.parse("'Single Quoted'") }
+
+      it { expect { parse }.to raise_exception(Parslet::ParseFailed) }
+    end
+
+    context 'when parsing an unquoted string' do
+      subject(:parse) { string_double_quotes.parse('Unquoted') }
+
+      it { expect { parse }.to raise_exception(Parslet::ParseFailed) }
+    end
+  end
+
+  describe '#string_single_quotes' do
+    subject(:string_single_quotes) { parser.string_single_quotes }
+
+    context 'when parsing a single quoted string' do
+      subject(:parse) { string_single_quotes.parse("'Single \\'Quoted\\''") }
+
+      it 'is expected to capture the contents of the single quotes as :string_single_quotes' do
+        expect(parse).to eq(string_single_quotes: "Single \\'Quoted\\'")
+      end
+    end
+
+    context 'when parsing a double quoted string' do
+      subject(:parse) { string_single_quotes.parse('"Double Quoted"') }
+
+      it { expect { parse }.to raise_exception(Parslet::ParseFailed) }
+    end
+
+    context 'when parsing an unquoted string' do
+      subject(:parse) { string_single_quotes.parse('Unquoted') }
+
+      it { expect { parse }.to raise_exception(Parslet::ParseFailed) }
+    end
+  end
+
+  describe '#string_no_quotes' do
+    subject(:string_no_quotes) { parser.string_no_quotes }
+
+    context 'when parsing an unquoted string with no spaces or symbols' do
+      subject(:parse) { string_no_quotes.parse('Unquoted') }
+
+      it 'is expected to eq the parsed value' do
+        expect(parse).to eq(string_no_quotes: 'Unquoted')
+      end
+    end
+
+    context 'when parsing an unquoted string with spaces' do
+      subject(:parse) { string_no_quotes.parse('No Quotes') }
+
+      it { expect { parse }.to raise_exception(Parslet::ParseFailed) }
+    end
+
+    context 'when parsing an unquoted string with symbols' do
+      subject(:parse) { string_no_quotes.parse('No:Quotes') }
+
+      it 'is expected to eq the parsed value' do
+        expect(parse).to eq(string_no_quotes: 'No:Quotes')
+      end
+    end
+  end
+
+  describe '#string' do
+    subject(:string) { parser.string }
+
+    context 'when parsing a double quoted string' do
+      subject(:parse) { string.parse('"Double \"Quoted\""') }
+
+      it 'is expected to capture the contents of the double quotes as :string_double_quotes' do
+        expect(parse).to eq(string_double_quotes: 'Double \"Quoted\"')
+      end
+    end
+
+    context 'when parsing a single quoted string' do
+      subject(:parse) { string.parse("'Single \\'Quoted\\''") }
+
+      it 'is expected to capture the contents of the single quotes as :string_single_quotes' do
+        expect(parse).to eq(string_single_quotes: "Single \\'Quoted\\'")
+      end
+    end
+
+    context 'when parsing an unquoted string' do
+      subject(:parse) { string.parse('Unquoted') }
+
+      it 'is expected to eq the parsed value' do
+        expect(parse).to eq(string_no_quotes: 'Unquoted')
+      end
+    end
+
+    context 'when parsing an unquoted string with spaces' do
+      subject(:parse) { string.parse('No Quotes') }
+
+      it { expect { parse }.to raise_exception(Parslet::ParseFailed) }
+    end
+
+    context 'when parsing an unquoted string with symbols' do
+      subject(:parse) { string.parse('a@b.c') }
+
+      it 'is expected to eq the parsed value' do
+        expect(parse).to eq(string_no_quotes: 'a@b.c')
+      end
+    end
+  end
+
+  describe '#term' do
+    subject(:term) { parser.term }
+
+    context 'when parsing a string' do
+      subject(:parse) { term.parse('Hello') }
+
+      it 'is expected to capture the value as :term' do
+        expect(parse).to match(hash_including(term: { string_no_quotes: 'Hello' }))
+      end
+    end
+  end
+
+  describe '#term_pair' do
+    subject(:term_pair) { parser.term_pair }
+
+    context 'when parsing a term' do
+      subject(:parse) { term_pair.parse('Hello') }
+
+      it { expect { parse }.to raise_exception(Parslet::ParseFailed) }
+    end
+
+    context 'when parsing two terms separated by a space' do
+      subject(:parse) { term_pair.parse('Hello World') }
+
+      it 'is expected to capture the first term as :left' do
+        expect(parse).to match(hash_including(left: { term: { string_no_quotes: 'Hello' } }))
+      end
+
+      it 'is expected to capture the second term as :right' do
+        expect(parse).to match(hash_including(right: { term: { string_no_quotes: 'World' } }))
+      end
+    end
+  end
+
+  describe '#term_node' do
+    subject(:term_node) { parser.term_node }
+
+    context 'when parsing a term' do
+      subject(:parse) { term_node.parse('Hello') }
+
+      it 'is expected to eq the term result' do
+        expect(parse).to match(hash_including(term: { string_no_quotes: 'Hello' }))
+      end
+    end
+
+    context 'when parsing multiple terms' do
+      subject(:parse) { term_node.parse('Hello World') }
+
+      it 'is expected to eq the term list result' do
+        expect(parse).to match(
+          hash_including(
+            left: { term: { string_no_quotes: 'Hello' } },
+            right: { term: { string_no_quotes: 'World' } }
+          )
+        )
+      end
+    end
+  end
+
+  describe '#terms' do
+    subject(:terms) { parser.terms }
+
+    context 'when parsing a complex list of terms' do
+      subject(:parse) { terms.parse(" FirstTerm \"Second Term\" Third<>Term 'Fourth Term' ") }
+
+      it 'is expected to eq the correct term tree' do
+        expect(parse).to match(
+          hash_including(
+            left: { term: { string_no_quotes: 'FirstTerm' } },
+            right: {
+              left: { term: { string_double_quotes: 'Second Term' } },
+              right: {
+                left: { term: { string_no_quotes: 'Third<>Term' } },
+                right: { term: { string_single_quotes: 'Fourth Term' } }
+              }
+            }
+          )
+        )
+      end
+    end
+  end
+
+  describe '#root' do
+    subject(:root) { parser.root }
+
+    it 'is expected to eq #terms' do
+      expect(root).to eq(parser.terms)
+    end
+  end
+end

data/spec/lib/pursuit/term_search_spec.rb

@@ -0,0 +1,71 @@
+# 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
+
+  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))
+    end
+
+    it 'is expected to evaluate the passed block' do
+      expect(term_search.attributes).to be_present
+    end
+  end
+
+  describe '#parser' do
+    subject(:parser) { term_search.parser }
+
+    it { is_expected.to be_a(Pursuit::TermParser) }
+  end
+
+  describe '#transform' do
+    subject(:transform) { term_search.transform }
+
+    it { is_expected.to be_a(Pursuit::TermTransform) }
+  end
+
+  describe '#search_attribute' do
+    subject(:search_attribute) do
+      term_search.search_attribute(ProductVariation.arel_table[:currency])
+    end
+
+    it 'is expected to add the attribute to #attributes' do
+      search_attribute
+      expect(term_search.attributes).to include(ProductVariation.arel_table[:currency])
+    end
+  end
+
+  describe '#parse' do
+    subject(:parse) { term_search.parse('Shirt') }
+
+    it 'is expected to equal the ARel node' do
+      expect(parse).to eq(
+        Product.arel_table[:title].matches('%Shirt%').or(
+          ProductVariation.arel_table[:title].matches('%Shirt%')
+        )
+      )
+    end
+  end
+
+  describe '#apply' do
+    subject(:apply) { term_search.apply('Shirt') }
+
+    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(
+            ProductVariation.arel_table[:title].matches('%Shirt%')
+          )
+        )
+      )
+    end
+  end
+end

data/spec/lib/pursuit/term_transform_spec.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+RSpec.describe Pursuit::TermTransform do
+  subject(:transform) { described_class.new }
+
+  describe '#apply' do
+    subject(:apply) { transform.apply(tree, attributes: attributes) }
+
+    let(:attributes) do
+      [
+        Product.arel_table[:title],
+        ProductVariation.arel_table[:title]
+      ].to_set
+    end
+
+    context 'when passed an empty double quoted string' do
+      let(:tree) do
+        { string_double_quotes: [] }
+      end
+
+      it 'is expected to equal an empty string' do
+        expect(apply).to eq('')
+      end
+    end
+
+    context 'when passed a double quoted string' do
+      let(:tree) do
+        { string_double_quotes: 'Hello \\"World\\"' }
+      end
+
+      it 'is expected to equal the correct string' do
+        expect(apply).to eq('Hello "World"')
+      end
+    end
+
+    context 'when passed an empty single quoted string' do
+      let(:tree) do
+        { string_single_quotes: [] }
+      end
+
+      it 'is expected to equal an empty string' do
+        expect(apply).to eq('')
+      end
+    end
+
+    context 'when passed a single quoted string' do
+      let(:tree) do
+        { string_single_quotes: "Hello \\'World\\'" }
+      end
+
+      it 'is expected to equal the correct string' do
+        expect(apply).to eq("Hello 'World'")
+      end
+    end
+
+    context 'when passed an unquoted string' do
+      let(:tree) do
+        { string_no_quotes: 'hello_world' }
+      end
+
+      it 'is expected to equal the correct string' do
+        expect(apply).to eq('hello_world')
+      end
+    end
+
+    context 'when passed a term' do
+      let(:tree) do
+        { term: { string_no_quotes: 'Shirt' } }
+      end
+
+      it 'is expected to equal the correct ARel node' do
+        expect(apply).to eq(
+          Product.arel_table[:title].matches('%Shirt%').or(
+            ProductVariation.arel_table[:title].matches('%Shirt%')
+          )
+        )
+      end
+    end
+
+    context 'when passed multiple terms' do
+      let(:tree) do
+        {
+          left: {
+            term: { string_no_quotes: 'Shirt' }
+          },
+          right: {
+            term: { string_no_quotes: 'Green' }
+          }
+        }
+      end
+
+      it 'is expected to equal the correct ARel node' do
+        expect(apply).to eq(
+          Product.arel_table[:title].matches('%Shirt%').or(
+            ProductVariation.arel_table[:title].matches('%Shirt%')
+          ).and(
+            Product.arel_table[:title].matches('%Green%').or(
+              ProductVariation.arel_table[:title].matches('%Green%')
+            )
+          )
+        )
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -13,13 +13,12 @@
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 
 require 'combustion'
-Combustion.initialize! :active_record
+Combustion.initialize!(:active_record)
 
 require 'bundler'
-Bundler.require :default, :development
+Bundler.require(:default, :development)
 
 require 'rspec/rails'
-
 RSpec.configure do |config|
   # rspec-expectations config goes here. You can use an alternate assertion/expectation library such as wrong or the
   # stdlib/minitest assertions if you prefer.

data/travis/gemfiles/{5.2.gemfile → 7.1.gemfile}

@@ -4,5 +4,5 @@ source 'https://rubygems.org'
 
 gemspec path: '../../'
 
-gem 'activerecord',  '~> 5.2.0'
-gem 'activesupport', '~> 5.2.0'
+gem 'activerecord',  '~> 7.1.0'
+gem 'activesupport', '~> 7.1.0'