search_cop 1.0.0

data/lib/search_cop_grammar/nodes.rb

@@ -0,0 +1,183 @@
+
+require "treetop"
+
+module SearchCopGrammar
+  module Nodes
+    module Base
+      def and(node)
+        And.new self, node
+      end
+
+      def or(node)
+        Or.new self, node
+      end
+
+      def not
+        Not.new self
+      end
+
+      def can_flatten?
+        false
+      end
+
+      def flatten!
+        self
+      end
+
+      def can_group?
+        false
+      end
+
+      def group!
+        self
+      end
+
+      def fulltext?
+        false
+      end
+
+      def can_optimize?
+        can_flatten? || can_group?
+      end
+
+      def optimize!
+        flatten!.group! while can_optimize?
+
+        finalize!
+      end
+
+      def finalize!
+        self
+      end
+
+      def nodes
+        []
+      end
+    end
+
+    class Binary
+      include Base
+
+      attr_accessor :left, :right
+
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+    end
+
+    class Equality < Binary; end
+    class NotEqual < Binary; end
+    class GreaterThan < Binary; end
+    class GreaterThanOrEqual < Binary; end
+    class LessThan < Binary; end
+    class LessThanOrEqual < Binary; end
+    class Matches < Binary; end
+
+    class Not
+      include Base
+
+      attr_accessor :object
+
+      def initialize(object)
+        @object = object
+      end
+    end
+
+    class MatchesFulltext < Binary
+      include Base
+
+      def not
+        MatchesFulltextNot.new left, right
+      end
+
+      def fulltext?
+        true
+      end
+
+      def finalize!
+        FulltextExpression.new collection, self
+      end
+
+      def collection
+        left
+      end
+    end
+
+    class MatchesFulltextNot < MatchesFulltext; end
+
+    class FulltextExpression
+      include Base
+
+      attr_reader :collection, :node
+
+      def initialize(collection, node)
+        @collection = collection
+        @node = node
+      end
+    end
+
+    class Collection
+      include Base
+
+      attr_reader :nodes
+
+      def initialize(*nodes)
+        @nodes = nodes.flatten
+      end
+
+      def can_flatten?
+        nodes.any?(&:can_flatten?) || nodes.any? { |node| node.is_a?(self.class) || node.nodes.size == 1 }
+      end
+
+      def flatten!(&block)
+        @nodes = nodes.collect(&:flatten!).collect { |node| node.is_a?(self.class) || node.nodes.size == 1 ? node.nodes : node }.flatten
+
+        self
+      end
+
+      def can_group?
+        nodes.reject(&:fulltext?).any?(&:can_group?) || nodes.select(&:fulltext?).group_by(&:collection).any? { |_, group| group.size > 1 }
+      end
+
+      def group!
+        @nodes = nodes.reject(&:fulltext?).collect(&:group!) + nodes.select(&:fulltext?).group_by(&:collection).collect { |collection, group| group.size > 1 ? self.class::Fulltext.new(collection, group) : group.first }
+
+        self
+      end
+
+      def finalize!
+        @nodes = nodes.collect(&:finalize!)
+
+        self
+      end
+    end
+
+    class FulltextCollection < Collection
+      attr_reader :collection
+
+      def initialize(collection, *nodes)
+        @collection = collection
+
+        super *nodes
+      end
+
+      def fulltext?
+        true
+      end
+
+      def finalize!
+        FulltextExpression.new collection, self
+      end
+    end
+
+    class And < Collection
+      class Fulltext < FulltextCollection; end
+    end
+
+    class Or < Collection
+      class Fulltext < FulltextCollection; end
+    end
+  end
+end
+

data/lib/search_cop_grammar.rb

@@ -0,0 +1,133 @@
+
+require "search_cop_grammar/attributes"
+require "search_cop_grammar/nodes"
+
+module SearchCopGrammar
+  class BaseNode < Treetop::Runtime::SyntaxNode
+    attr_accessor :query_info
+
+    def query_info
+      @query_info || parent.query_info
+    end
+
+    def evaluate
+      elements.collect(&:evaluate).inject(:and)
+    end
+
+    def elements
+      super.select { |element| element.class != Treetop::Runtime::SyntaxNode }
+    end
+
+    def collection_for(key)
+      raise(SearchCop::UnknownColumn, "Unknown column #{key}") if query_info.scope.reflection.attributes[key].nil?
+
+      Attributes::Collection.new query_info, key
+    end
+  end
+
+  class OperatorNode < Treetop::Runtime::SyntaxNode
+    def evaluate
+      text_value
+    end
+  end
+
+  class ComplexExpression < BaseNode; end
+  class ParenthesesExpression < BaseNode; end
+
+  class ComparativeExpression < BaseNode
+    def evaluate
+      elements[0].collection.send elements[1].method_name, elements[2].text_value
+    end
+  end
+
+  class IncludesOperator < OperatorNode
+    def method_name
+      :matches
+    end
+  end
+
+  class EqualOperator < OperatorNode
+    def method_name
+      :eq
+    end
+  end
+
+  class UnequalOperator < OperatorNode
+    def method_name
+      :not_eq
+    end
+  end
+
+  class GreaterEqualOperator < OperatorNode
+    def method_name
+      :gteq
+    end
+  end
+
+  class GreaterOperator < OperatorNode
+    def method_name
+      :gt
+    end
+  end
+
+  class LessEqualOperator < OperatorNode
+    def method_name
+      :lteq
+    end
+  end
+
+  class LessOperator < OperatorNode
+    def method_name
+      :lt
+    end
+  end
+
+  class AnywhereExpression < BaseNode
+    def evaluate
+      queries = query_info.scope.reflection.default_attributes.keys.collect { |key| collection_for key }.select { |collection| collection.compatible? text_value }.collect { |collection| collection.matches text_value }
+
+      raise SearchCop::NoSearchableAttributes if queries.empty?
+
+      queries.flatten.inject(:or)
+    end
+  end
+
+  class AndExpression < BaseNode
+    def evaluate
+      [elements.first.evaluate, elements.last.evaluate].inject(:and)
+    end
+  end
+
+  class OrExpression < BaseNode
+    def evaluate
+      [elements.first.evaluate, elements.last.evaluate].inject(:or)
+    end
+  end
+
+  class NotExpression < BaseNode
+    def evaluate
+      elements.first.evaluate.not
+    end
+  end
+
+  class Column < BaseNode
+    def collection
+      collection_for text_value
+    end
+  end
+
+  class SingleQuotedValue < BaseNode
+    def text_value
+      super.gsub /^'|'$/, ""
+    end
+  end
+
+  class DoubleQuotedValue < BaseNode
+    def text_value
+      super.gsub /^"|"$/, ""
+    end
+  end
+
+  class Value < BaseNode; end
+end
+

data/lib/search_cop_grammar.treetop

@@ -0,0 +1,55 @@
+
+grammar SearchCopGrammar
+  rule complex_expression
+    space? (boolean_expression / expression) space? <ComplexExpression>
+  end
+
+  rule boolean_expression
+    and_expression
+  end
+
+  rule and_expression
+    or_expression (space? ('AND' / 'and') space? / space !('OR' / 'or')) complex_expression <AndExpression> / or_expression
+  end
+
+  rule or_expression
+    expression space? ('OR' / 'or') space? (or_expression / expression) <OrExpression> / expression
+  end
+
+  rule expression
+    parentheses_expression / not_expression / comparative_expression / anywhere_expression
+  end
+
+  rule parentheses_expression
+    '(' complex_expression ')' <ParenthesesExpression> 
+  end
+
+  rule not_expression
+    ('NOT' space / 'not' space / '-') (comparative_expression / anywhere_expression) <NotExpression>
+  end
+
+  rule comparative_expression
+    simple_column space? comparison_operator space? value <ComparativeExpression>
+  end
+
+  rule comparison_operator
+    ':' <IncludesOperator> / '=' <EqualOperator> / '!=' <UnequalOperator> / '>=' <GreaterEqualOperator> / '>' <GreaterOperator> / '<=' <LessEqualOperator> / '<' <LessOperator>
+  end
+
+  rule anywhere_expression
+    ("'" ([^\']* <AnywhereExpression>) "'") / ('"' ([^\"]* <AnywhereExpression>) '"') / [^\s()]+ <AnywhereExpression>
+  end
+
+  rule simple_column
+    [a-zA-Z0-9_.]+ <Column>
+  end
+
+  rule value
+    "'" [^\']* "'" <SingleQuotedValue> / '"' [^\"]* '"' <DoubleQuotedValue> / [^\s()]+ <Value>
+  end
+
+  rule space
+    [\s]+
+  end
+end
+

data/search_cop.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'search_cop/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "search_cop"
+  spec.version       = SearchCop::VERSION
+  spec.authors       = ["Benjamin Vetter"]
+  spec.email         = ["vetter@flakks.com"]
+  spec.description   = %q{Search engine like fulltext query support for ActiveRecord}
+  spec.summary       = %q{Easily perform complex search engine like fulltext queries on your ActiveRecord models}
+  spec.homepage      = "https://github.com/mrkamel/search_cop"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "treetop"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "activerecord", ">= 3.0.0"
+  spec.add_development_dependency "factory_girl"
+  spec.add_development_dependency "appraisal"
+  spec.add_development_dependency "minitest"
+end

data/test/and_test.rb

@@ -0,0 +1,27 @@
+
+require File.expand_path("../test_helper", __FILE__)
+
+class AndTest < SearchCop::TestCase
+  def test_and_string
+    expected = create(:product, :title => "Expected title", :description => "Description")
+    rejected = create(:product, :title => "Rejected title", :description => "Description")
+
+    results = Product.search("title: 'Expected title' description: Description")
+
+    assert_includes results, expected
+    refute_includes results, rejected
+
+    assert_equal results, Product.search("title: 'Expected title' AND description: Description")
+  end
+
+  def test_and_hash
+    expected = create(:product, :title => "Expected title", :description => "Description")
+    rejected = create(:product, :title => "Rejected title", :description => "Description")
+
+    results = Product.search(:and => [{:title => "Expected title"}, {:description => "Description"}])
+
+    assert_includes results, expected
+    refute_includes results, rejected
+  end
+end
+

data/test/boolean_test.rb

@@ -0,0 +1,53 @@
+
+require File.expand_path("../test_helper", __FILE__)
+
+class BooleanTest < SearchCop::TestCase
+  def test_mapping
+    product = create(:product, :available => true)
+
+    assert_includes Product.search("available: 1"), product
+    assert_includes Product.search("available: true"), product
+    assert_includes Product.search("available: yes"), product
+
+    product = create(:product, :available => false)
+
+    assert_includes Product.search("available: 0"), product
+    assert_includes Product.search("available: false"), product
+    assert_includes Product.search("available: no"), product
+  end
+
+  def test_anywhere
+    product = create(:product, :available => true)
+
+    assert_includes Product.search("true"), product
+    refute_includes Product.search("false"), product
+  end
+
+  def test_includes
+    product = create(:product, :available => true)
+
+    assert_includes Product.search("available: true"), product
+    refute_includes Product.search("available: false"), product
+  end
+
+  def test_equals
+    product = create(:product, :available => true)
+
+    assert_includes Product.search("available = true"), product
+    refute_includes Product.search("available = false"), product
+  end
+
+  def test_equals_not
+    product = create(:product, :available => false)
+
+    assert_includes Product.search("available != true"), product
+    refute_includes Product.search("available != false"), product
+  end
+
+  def test_incompatible_datatype
+    assert_raises SearchCop::IncompatibleDatatype do
+      Product.unsafe_search "available: Value"
+    end
+  end
+end
+

data/test/database.yml

@@ -0,0 +1,17 @@
+
+sqlite:
+  adapter: sqlite3
+  database: ":memory:"
+
+mysql:
+  adapter: mysql2
+  database: search_cop
+  username: root
+  encoding: utf8
+
+postgres:
+  adapter: postgresql
+  database: search_cop
+  username: postgres
+  encoding: utf8
+

data/test/date_test.rb

@@ -0,0 +1,75 @@
+
+require File.expand_path("../test_helper", __FILE__)
+
+class DateTest < SearchCop::TestCase
+  def test_mapping
+    product = create(:product, :created_on => Date.parse("2014-05-01"))
+
+    assert_includes Product.search("created_on: 2014"), product
+    assert_includes Product.search("created_on: 2014-05"), product
+    assert_includes Product.search("created_on: 2014-05-01"), product
+  end
+
+  def test_anywhere
+    product = create(:product, :created_on => Date.parse("2014-05-01"))
+
+    assert_includes Product.search("2014-05-01"), product
+    refute_includes Product.search("2014-05-02"), product
+  end
+
+  def test_includes
+    product = create(:product, :created_on => Date.parse("2014-05-01"))
+
+    assert_includes Product.search("created_on: 2014-05-01"), product
+    refute_includes Product.search("created_on: 2014-05-02"), product
+  end
+
+  def test_equals
+    product = create(:product, :created_on => Date.parse("2014-05-01"))
+
+    assert_includes Product.search("created_on = 2014-05-01"), product
+    refute_includes Product.search("created_on = 2014-05-02"), product
+  end
+
+  def test_equals_not
+    product = create(:product, :created_on => Date.parse("2014-05-01"))
+
+    assert_includes Product.search("created_on != 2014-05-02"), product
+    refute_includes Product.search("created_on != 2014-05-01"), product
+  end
+
+  def test_greater
+    product = create(:product, :created_on => Date.parse("2014-05-01"))
+
+    assert_includes Product.search("created_on > 2014-04-01"), product
+    refute_includes Product.search("created_on > 2014-05-01"), product
+  end
+
+  def test_greater_equals
+    product = create(:product, :created_on => Date.parse("2014-05-01"))
+
+    assert_includes Product.search("created_on >= 2014-05-01"), product
+    refute_includes Product.search("created_on >= 2014-05-02"), product
+  end
+
+  def test_less
+    product = create(:product, :created_on => Date.parse("2014-05-01"))
+
+    assert_includes Product.search("created_on < 2014-05-02"), product
+    refute_includes Product.search("created_on < 2014-05-01"), product
+  end
+
+  def test_less_equals
+    product = create(:product, :created_on => Date.parse("2014-05-02"))
+
+    assert_includes Product.search("created_on <= 2014-05-02"), product
+    refute_includes Product.search("created_on <= 2014-05-01"), product
+  end
+
+  def test_incompatible_datatype
+    assert_raises SearchCop::IncompatibleDatatype do
+      Product.unsafe_search "created_on: Value"
+    end
+  end
+end
+

data/test/datetime_test.rb

@@ -0,0 +1,76 @@
+
+require File.expand_path("../test_helper", __FILE__)
+
+class DatetimeTest < SearchCop::TestCase
+  def test_mapping
+    product = create(:product, :created_at => Time.parse("2014-05-01 12:30:30"))
+
+    assert_includes Product.search("created_at: 2014"), product
+    assert_includes Product.search("created_at: 2014-05"), product
+    assert_includes Product.search("created_at: 2014-05-01"), product
+    assert_includes Product.search("created_at: '2014-05-01 12:30:30'"), product
+  end
+
+  def test_anywhere
+    product = create(:product, :created_at => Time.parse("2014-05-01"))
+
+    assert_includes Product.search("2014-05-01"), product
+    refute_includes Product.search("2014-05-02"), product
+  end
+
+  def test_includes
+    product = create(:product, :created_at => Time.parse("2014-05-01"))
+
+    assert_includes Product.search("created_at: 2014-05-01"), product
+    refute_includes Product.search("created_at: 2014-05-02"), product
+  end
+
+  def test_equals
+    product = create(:product, :created_at => Time.parse("2014-05-01"))
+
+    assert_includes Product.search("created_at = 2014-05-01"), product
+    refute_includes Product.search("created_at = 2014-05-02"), product
+  end
+
+  def test_equals_not
+    product = create(:product, :created_at => Time.parse("2014-05-01"))
+
+    assert_includes Product.search("created_at != 2014-05-02"), product
+    refute_includes Product.search("created_at != 2014-05-01"), product
+  end
+
+  def test_greater
+    product = create(:product, :created_at => Time.parse("2014-05-01"))
+
+    assert_includes Product.search("created_at > 2014-04-01"), product
+    refute_includes Product.search("created_at > 2014-05-01"), product
+  end
+
+  def test_greater_equals
+    product = create(:product, :created_at => Time.parse("2014-05-01"))
+
+    assert_includes Product.search("created_at >= 2014-05-01"), product
+    refute_includes Product.search("created_at >= 2014-05-02"), product
+  end
+
+  def test_less
+    product = create(:product, :created_at => Time.parse("2014-05-01"))
+
+    assert_includes Product.search("created_at < 2014-05-02"), product
+    refute_includes Product.search("created_at < 2014-05-01"), product
+  end
+
+  def test_less_equals
+    product = create(:product, :created_at => Time.parse("2014-05-02"))
+
+    assert_includes Product.search("created_at <= 2014-05-02"), product
+    refute_includes Product.search("created_at <= 2014-05-01"), product
+  end
+
+  def test_incompatible_datatype
+    assert_raises SearchCop::IncompatibleDatatype do
+      Product.unsafe_search "created_at: Value"
+    end
+  end
+end
+

data/test/error_test.rb

@@ -0,0 +1,17 @@
+
+require File.expand_path("../test_helper", __FILE__)
+
+class ErrorTest < SearchCop::TestCase
+  def test_parse_error
+    assert_raises SearchCop::ParseError do
+      Product.unsafe_search :title => { :unknown_operator => "Value" }
+    end
+  end
+
+  def test_unknown_column
+    assert_raises SearchCop::UnknownColumn do
+      Product.unsafe_search "Unknown: Column"
+    end
+  end
+end
+