attr_searchable 0.0.1 → 0.0.2

data/.travis.yml

@@ -20,7 +20,6 @@ matrix:
   allow_failures:
     - rvm: rbx-2
     - rvm: jruby
-  fast_finish: true
 
 gemfile:
   - gemfiles/3.2.gemfile

data/README.md

@@ -3,6 +3,7 @@
 [![Build Status](https://secure.travis-ci.org/mrkamel/attr_searchable.png?branch=master)](http://travis-ci.org/mrkamel/attr_searchable)
 [![Code Climate](https://codeclimate.com/github/mrkamel/attr_searchable.png)](https://codeclimate.com/github/mrkamel/attr_searchable)
 [![Dependency Status](https://gemnasium.com/mrkamel/attr_searchable.png?travis)](https://gemnasium.com/mrkamel/attr_searchable)
+[![Gem Version](https://badge.fury.io/rb/attr_searchable.svg)](http://badge.fury.io/rb/attr_searchable)
 
 AttrSearchable extends your ActiveRecord models to support fulltext search
 engine like queries via simple query strings and hash-based queries. Assume you
@@ -35,7 +36,7 @@ Book.search(:or => [{:query => "Rowling -Potter"}, {:query => "Tolkien -Rings"}]
 
 ## Installation
 
-Add this line to your application's Gemfile:
+For Rails/ActiveRecord 3 (or 4), add this line to your application's Gemfile:
 
     gem 'attr_searchable'
 
@@ -142,8 +143,8 @@ attributes having fulltext indices to:
 
 ```ruby
 Book.search("Harry Potter")
-# MySQL: ... WHERE MATCH(books.title) AGAINST('+Harry +Potter' IN BOOLEAN MODE) OR MATCH(books.author) AGAINST('+Harry +Potter' IN BOOLEAN MODE)
-# PostgreSQL: ... WHERE to_tsvector('simple', books.title) @@ to_tsquery('simple', 'Harry & Potter') OR to_tsvector('simple', books.author) @@ to_tsquery('simple', 'Harry & Potter')
+# MySQL: ... WHERE (MATCH(books.title) AGAINST('+Harry' IN BOOLEAN MODE) OR MATCH(books.author) AGAINST('+Harry' IN BOOLEAN MODE)) AND (MATCH(books.title) AGAINST ('+Potter' IN BOOLEAN MODE) OR MATCH(books.author) AGAINST('+Potter' IN BOOLEAN MODE))
+# PostgreSQL: ... WHERE (to_tsvector('simple', books.title) @@ to_tsquery('simple', 'Harry') OR to_tsvector('simple', books.author) @@ to_tsquery('simple', 'Harry')) AND (to_tsvector('simple', books.title) @@ to_tsquery('simple', 'Potter') OR to_tsvector('simple', books.author) @@ to_tsquery('simple', 'Potter'))
 ```
 
 Obviously, theses queries won't always return the same results as wildcard
@@ -165,8 +166,8 @@ Now AttrSearchable can optimize the following, not yet optimal query:
 
 ```ruby
 BookSearch("Rowling OR Tolkien stock > 1")
-# MySQL: ... WHERE (MATCH(books.author) AGAINST('+Rowling' IN BOOLEAN MODE) OR MATCH(books.title) AGAINST('+Tolkien' IN BOOLEAN MODE)) AND books.stock > 1
-# PostgreSQL: ... WHERE (to_tsvector('simple', books.author) @@ to_tsquery('simple', 'Rowling') OR to_tsvector('simple', books.title) @@ to_tsquery('simple', 'Tolkien')) AND books.stock > 1
+# MySQL: ... WHERE ((MATCH(books.author) AGAINST('+Rowling' IN BOOLEAN MODE) OR MATCH(books.title) AGAINST('+Rowling' IN BOOLEAN MODE)) OR (MATCH(books.author) AGAINST('+Tolkien' IN BOOLEAN MODE) OR MATCH(books.title) AGAINST('+Tolkien' IN BOOLEAN MODE))) AND books.stock > 1
+# PostgreSQL: ... WHERE ((to_tsvector('simple', books.author) @@ to_tsquery('simple', 'Rowling') OR to_tsvector('simple', books.title) @@ to_tsquery('simple', 'Rowling')) OR (to_tsvector('simple', books.author) @@ to_tsquery('simple', 'Tolkien') OR to_tsvector('simple', books.title) @@ to_tsquery('simple', 'Tolkien'))) AND books.stock > 1
 ```
 
 to the following, more performant query:
@@ -330,6 +331,16 @@ instead of
 
 Thus, if you use fulltext indices, you better avoid chaining.
 
+## Debugging
+
+AttrSearchable conveniently hides certain errors, like parse errors, and
+instead returns an empty relation. However, if you need to debug certain
+cases, use `Model#unsafe_search`, which will raise them.
+
+```ruby
+Book.unsafe_search("stock: None") # => raise AttrSearchable::IncompatibleDatatype
+```
+
 ## Contributing
 
 1. Fork it

data/attr_searchable.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = AttrSearchable::VERSION
   spec.authors       = ["Benjamin Vetter"]
   spec.email         = ["vetter@flakks.com"]
-  spec.description   = %q{Complex search-engine like query support for activerecord}
-  spec.summary       = %q{Easily perform complex search-engine like queries on your activerecord models}
+  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/attr_searchable"
   spec.license       = "MIT"
 

data/lib/attr_searchable.rb

@@ -8,11 +8,14 @@ require "treetop"
 Treetop.load File.expand_path("../attr_searchable_grammar.treetop", __FILE__)
 
 module AttrSearchable
-  class Error < StandardError; end
-  class UnknownColumn < Error; end
-  class NoSearchableAttributes < Error; end
-  class IncompatibleDatatype < Error; end
-  class ParseError < Error; end
+  class SpecificationError < StandardError; end
+  class UnknownAttribute < SpecificationError; end
+
+  class RuntimeError < StandardError; end
+  class UnknownColumn < RuntimeError; end
+  class NoSearchableAttributes < RuntimeError; end
+  class IncompatibleDatatype < RuntimeError; end
+  class ParseError < RuntimeError; end
 
   module Parser
     def self.parse(arg, model)
@@ -26,7 +29,7 @@ module AttrSearchable
     def self.parse_string(string, model)
       node = AttrSearchableGrammarParser.new.parse(string) || raise(ParseError)
       node.model = model
-      node.to_arel
+      node.evaluate
     end
   end
 
@@ -61,15 +64,19 @@ module AttrSearchable
       self.searchable_attribute_options[key.to_s] = (self.searchable_attribute_options[key.to_s] || {}).merge(options)
     end
 
-    def search(arg)
+    def search(*args)
+      unsafe_search *args
+    rescue AttrSearchable::RuntimeError
+      respond_to?(:none) ? none : where("1 = 0")
+    end
+
+    def unsafe_search(arg)
       return respond_to?(:scoped) ? scoped : all if arg.blank?
 
       scope = respond_to?(:search_scope) ? search_scope : nil
       scope ||= eager_load(searchable_attributes.values.flatten.uniq.collect { |column| column.split(".").first.to_sym } - [name.tableize.to_sym])
 
-      scope.where AttrSearchable::Parser.parse(arg, self).optimize!
-    rescue AttrSearchable::Error
-      respond_to?(:none) ? none : where("1 = 0")
+      scope.where AttrSearchable::Parser.parse(arg, self).optimize!.to_sql(self)
     end
   end
 end

data/lib/attr_searchable/arel/visitors.rb

@@ -5,19 +5,83 @@ module AttrSearchable
       module ToSql
         if ::Arel::VERSION >= "4.0.1"
           def visit_AttrSearchableGrammar_Nodes_And(o, a)
-            visit ::Arel::Nodes::Grouping.new(o.to_arel), a
+            visit ::Arel::Nodes::Grouping.new(o.nodes.inject { |res, cur| ::Arel::Nodes::And.new [res, cur] }), a
           end
 
           def visit_AttrSearchableGrammar_Nodes_Or(o, a)
-            visit ::Arel::Nodes::Grouping.new(o.to_arel), a
+            visit ::Arel::Nodes::Grouping.new(o.nodes.inject { |res, cur| ::Arel::Nodes::Or.new res, cur }), a
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_Equality(o, a)
+            visit ::Arel::Nodes::Equality.new(o.left, o.right), a
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_NotEqual(o, a)
+            visit ::Arel::Nodes::NotEqual.new(o.left, o.right), a
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_LessThan(o, a)
+            visit ::Arel::Nodes::LessThan.new(o.left, o.right), a
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_LessThanOrEqual(o, a)
+            visit ::Arel::Nodes::LessThanOrEqual.new(o.left, o.right), a
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_GreaterThan(o, a)
+            visit ::Arel::Nodes::GreaterThan.new(o.left, o.right), a
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_GreaterThanOrEqual(o, a)
+            visit ::Arel::Nodes::GreaterThanOrEqual.new(o.left, o.right), a
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_Not(o, a)
+            visit ::Arel::Nodes::Not.new(o.object), a
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_Matches(o, a)
+            visit ::Arel::Nodes::Matches.new(o.left, o.right), a
           end
         else
           def visit_AttrSearchableGrammar_Nodes_And(o)
-            visit ::Arel::Nodes::Grouping.new(o.to_arel)
+            visit ::Arel::Nodes::Grouping.new(o.nodes.inject { |res, cur| ::Arel::Nodes::And.new [res, cur] })
           end
 
           def visit_AttrSearchableGrammar_Nodes_Or(o)
-            visit ::Arel::Nodes::Grouping.new(o.to_arel)
+            visit ::Arel::Nodes::Grouping.new(o.nodes.inject { |res, cur| ::Arel::Nodes::Or.new res, cur })
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_Equality(o)
+            visit ::Arel::Nodes::Equality.new(o.left, o.right)
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_NotEqual(o)
+            visit ::Arel::Nodes::NotEqual.new(o.left, o.right)
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_LessThan(o)
+            visit ::Arel::Nodes::LessThan.new(o.left, o.right)
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_LessThanOrEqual(o)
+            visit ::Arel::Nodes::LessThanOrEqual.new(o.left, o.right)
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_GreaterThan(o)
+            visit ::Arel::Nodes::GreaterThan.new(o.left, o.right)
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_GreaterThanOrEqual(o)
+            visit ::Arel::Nodes::GreaterThanOrEqual.new(o.left, o.right)
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_Not(o)
+            visit ::Arel::Nodes::Not.new(o.object)
+          end
+
+          def visit_AttrSearchableGrammar_Nodes_Matches(o)
+            visit ::Arel::Nodes::Matches.new(o.left, o.right)
           end
         end
       end

data/lib/attr_searchable/hash_parser.rb

@@ -29,7 +29,7 @@ class AttrSearchable::HashParser
     collection = AttrSearchableGrammar::Attributes::Collection.new(@model, key.to_s)
 
     if value.is_a?(Hash)
-      raise AttrSearchable::ParseError unless [:matches, :eq, :not_eq, :gt, :gteq, :lt, :lteq].include?(value.keys.first)
+      raise(AttrSearchable::ParseError, "Unknown operator #{value.keys.first}") unless [:matches, :eq, :not_eq, :gt, :gteq, :lt, :lteq].include?(value.keys.first)
 
       collection.send value.keys.first, value.values.first.to_s
     else

data/lib/attr_searchable/version.rb

@@ -1,3 +1,3 @@
 module AttrSearchable
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/attr_searchable_grammar.rb

@@ -10,23 +10,23 @@ module AttrSearchableGrammar
       @model || parent.model
     end
 
-    def to_arel
-      elements.collect(&:to_arel).inject(:and)
+    def evaluate
+      elements.collect(&:evaluate).inject(:and)
     end
 
     def elements
       super.select { |element| element.class != Treetop::Runtime::SyntaxNode }
     end
 
-    def arel_collection_for(key)
-      raise AttrSearchable::UnknownColumn, "Unknown key: #{key}" if model.searchable_attributes[key].nil?
+    def collection_for(key)
+      raise(AttrSearchable::UnknownColumn, "Unknown column #{key}") if model.searchable_attributes[key].nil?
 
       Attributes::Collection.new model, key
     end
   end
 
   class OperatorNode < Treetop::Runtime::SyntaxNode
-    def to_arel
+    def evaluate
       text_value
     end
   end
@@ -35,59 +35,59 @@ module AttrSearchableGrammar
   class ParenthesesExpression < BaseNode; end
 
   class ComparativeExpression < BaseNode
-    def to_arel
-      elements[0].arel_collection.send elements[1].to_arel_method, elements[2].text_value
+    def evaluate
+      elements[0].collection.send elements[1].method_name, elements[2].text_value
     end
   end
 
   class IncludesOperator < OperatorNode
-    def to_arel_method
+    def method_name
       :matches
     end
   end
 
   class EqualOperator < OperatorNode
-    def to_arel_method
+    def method_name
       :eq
     end
   end
 
   class UnequalOperator < OperatorNode
-    def to_arel_method
+    def method_name
       :not_eq
     end
   end
 
   class GreaterEqualOperator < OperatorNode
-    def to_arel_method
+    def method_name
       :gteq
     end
   end
 
   class GreaterOperator < OperatorNode
-    def to_arel_method
+    def method_name
       :gt
     end
   end
 
   class LessEqualOperator < OperatorNode
-    def to_arel_method
+    def method_name
       :lteq
     end
   end
 
   class LessOperator < OperatorNode
-    def to_arel_method
+    def method_name
       :lt
     end
   end
 
   class AnywhereExpression < BaseNode
-    def to_arel
+    def evaluate
       keys = model.searchable_attribute_options.select { |key, value| value[:default] == true }.keys
       keys = model.searchable_attributes.keys if keys.empty?
 
-      queries = keys.collect { |key| arel_collection_for key }.select { |attribute| attribute.compatible? text_value }.collect { |attribute| attribute.matches text_value }
+      queries = keys.collect { |key| collection_for key }.select { |attribute| attribute.compatible? text_value }.collect { |attribute| attribute.matches text_value }
 
       raise AttrSearchable::NoSearchableAttributes unless model.searchable_attributes
 
@@ -96,26 +96,26 @@ module AttrSearchableGrammar
   end
 
   class AndExpression < BaseNode
-    def to_arel
-      [elements.first.to_arel, elements.last.to_arel].inject(:and)
+    def evaluate
+      [elements.first.evaluate, elements.last.evaluate].inject(:and)
     end
   end
 
   class OrExpression < BaseNode
-    def to_arel
-      [elements.first.to_arel, elements.last.to_arel].inject(:or)
+    def evaluate
+      [elements.first.evaluate, elements.last.evaluate].inject(:or)
     end
   end
 
   class NotExpression < BaseNode
-    def to_arel
-      elements.first.to_arel.not
+    def evaluate
+      elements.first.evaluate.not
     end
   end
 
   class Column < BaseNode
-    def arel_collection
-      arel_collection_for text_value
+    def collection
+      collection_for text_value
     end
   end
 

data/lib/attr_searchable_grammar/attributes.rb

@@ -7,7 +7,7 @@ module AttrSearchableGrammar
       attr_reader :model, :key
 
       def initialize(model, key)
-        raise AttrSearchable::IncompatibleDatatype unless model.searchable_attributes[key]
+        raise(AttrSearchable::UnknownColumn, "Unknown column #{key}") unless model.searchable_attributes[key]
 
         @model = model
         @key = key
@@ -52,12 +52,16 @@ module AttrSearchableGrammar
       end
 
       def attributes
-        @attributes ||= model.searchable_attributes[key].collect do |attribute|
-          table, column = attribute.split(".")
-          klass = table.classify.constantize
+        @attributes ||= model.searchable_attributes[key].collect { |attribute_definition| attribute_for attribute_definition }
+      end
 
-          Attributes.const_get(klass.columns_hash[column].type.to_s.classify).new(klass.arel_table.alias(klass.table_name)[column], klass, options)
-        end
+      def attribute_for(attribute_definition)
+        table, column = attribute_definition.split(".")
+        klass = table.classify.constantize
+
+        raise(AttrSearchable::UnknownAttribute, "Unknown attribute #{attribute_definition}") unless klass.columns_hash[column]
+
+        Attributes.const_get(klass.columns_hash[column].type.to_s.classify).new(klass.arel_table.alias(klass.table_name)[column], klass, options)
       end
     end
 
@@ -88,7 +92,7 @@ module AttrSearchableGrammar
 
       { :eq => "Equality", :not_eq => "NotEqual", :lt => "LessThan", :lteq => "LessThanOrEqual", :gt => "GreaterThan", :gteq => "GreaterThanOrEqual", :matches => "Matches" }.each do |method, class_name|
         define_method method do |value|
-          raise AttrSearchable::IncompatibleDatatype unless compatible?(value)
+          raise(AttrSearchable::IncompatibleDatatype, "Incompatible datatype for #{value}") unless compatible?(value)
 
           AttrSearchableGrammar::Nodes.const_get(class_name).new(@attribute, map(value))
         end
@@ -152,7 +156,7 @@ module AttrSearchableGrammar
           time .. time
         end 
       rescue ArgumentError
-        raise AttrSearchable::IncompatibleDatatype
+        raise AttrSearchable::IncompatibleDatatype, "Incompatible datatype for #{value}"
       end 
 
       def map(value)
@@ -188,7 +192,7 @@ module AttrSearchableGrammar
         return true if value.to_s =~ /^(1|true|yes)$/i
         return false if value.to_s =~ /^(0|false|no)$/i
 
-        raise AttrSearchable::IncompatibleDatatype
+        raise AttrSearchable::IncompatibleDatatype, "Incompatible datatype for #{value}"
       end 
     end
   end

data/lib/attr_searchable_grammar/nodes.rb

@@ -46,6 +46,10 @@ module AttrSearchableGrammar
         finalize!
       end
 
+      def to_sql(model)
+        model.connection.visitor.accept self
+      end
+
       def finalize!
         self
       end
@@ -55,12 +59,36 @@ module AttrSearchableGrammar
       end
     end
 
-    ["Equality", "NotEqual", "GreaterThan", "LessThan", "GreaterThanOrEqual", "LessThanOrEqual", "Matches", "Not"].each do |name|
-      const_set name, Class.new(Arel::Nodes.const_get(name))
-      const_get(name).send :include, Base
+    class Binary
+      include Base
+
+      attr_accessor :left, :right
+
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
     end
 
-    class MatchesFulltext < Arel::Nodes::Binary
+    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
@@ -82,7 +110,7 @@ module AttrSearchableGrammar
 
     class MatchesFulltextNot < MatchesFulltext; end
 
-    class FulltextExpression < Arel::Nodes::Node
+    class FulltextExpression
       include Base
 
       attr_reader :collection, :node
@@ -93,7 +121,7 @@ module AttrSearchableGrammar
       end
     end
 
-    class Collection < Arel::Nodes::Node
+    class Collection
       include Base
 
       attr_reader :nodes
@@ -149,18 +177,10 @@ module AttrSearchableGrammar
 
     class And < Collection
       class Fulltext < FulltextCollection; end
-
-      def to_arel
-        nodes.inject { |res, cur| Arel::Nodes::And.new [res, cur] }
-      end
     end
 
     class Or < Collection
       class Fulltext < FulltextCollection; end
-
-      def to_arel
-        nodes.inject { |res, cur| Arel::Nodes::Or.new res, cur }
-      end
     end
   end
 end

data/test/and_test.rb

@@ -3,8 +3,8 @@ require File.expand_path("../test_helper", __FILE__)
 
 class AndTest < AttrSearchable::TestCase
   def test_and_string
-    expected = FactoryGirl.create(:product, :title => "Expected title", :description => "Description")
-    rejected = FactoryGirl.create(:product, :title => "Rejected title", :description => "Description")
+    expected = create(:product, :title => "Expected title", :description => "Description")
+    rejected = create(:product, :title => "Rejected title", :description => "Description")
 
     results = Product.search("title: 'Expected title' description: Description")
 
@@ -15,8 +15,8 @@ class AndTest < AttrSearchable::TestCase
   end
 
   def test_and_hash
-    expected = FactoryGirl.create(:product, :title => "Expected title", :description => "Description")
-    rejected = FactoryGirl.create(:product, :title => "Rejected title", :description => "Description")
+    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"}])
 

data/test/attr_searchable_test.rb

@@ -3,9 +3,9 @@ require File.expand_path("../test_helper", __FILE__)
 
 class AttrSearchableTest < AttrSearchable::TestCase
   def test_associations
-    product = FactoryGirl.create(:product, :comments => [
-      FactoryGirl.create(:comment, :title => "Title1", :message => "Message1"),
-      FactoryGirl.create(:comment, :title => "Title2", :message => "Message2")
+    product = create(:product, :comments => [
+      create(:comment, :title => "Title1", :message => "Message1"),
+      create(:comment, :title => "Title2", :message => "Message2")
     ])
 
     assert_includes Product.search("comment: Title1 comment: Message1"), product
@@ -13,15 +13,15 @@ class AttrSearchableTest < AttrSearchable::TestCase
   end
 
   def test_multiple
-    product = FactoryGirl.create(:product, :comments => [FactoryGirl.create(:comment, :title => "Title", :message => "Message")])
+    product = create(:product, :comments => [create(:comment, :title => "Title", :message => "Message")])
 
     assert_includes Product.search("comment: Title"), product
     assert_includes Product.search("comment: Message"), product
   end
 
   def test_default
-    product1 = FactoryGirl.create(:product, :title => "Expected")
-    product2 = FactoryGirl.create(:product, :description => "Expected")
+    product1 = create(:product, :title => "Expected")
+    product2 = create(:product, :description => "Expected")
 
     results = Product.search("Expected")
 
@@ -30,9 +30,9 @@ class AttrSearchableTest < AttrSearchable::TestCase
   end
 
   def test_custom_default
-    product1 = FactoryGirl.create(:product, :title => "Expected")
-    product2 = FactoryGirl.create(:product, :description => "Expected")
-    product3 = FactoryGirl.create(:product, :brand => "Expected")
+    product1 = create(:product, :title => "Expected")
+    product2 = create(:product, :description => "Expected")
+    product3 = create(:product, :brand => "Expected")
 
     results = with_attr_searchable_options(Product, :primary, :default => true) { Product.search "Expected" }
 
@@ -40,5 +40,11 @@ class AttrSearchableTest < AttrSearchable::TestCase
     assert_includes results, product2
     refute_includes results, product3
   end
+
+  def test_count
+    create_list :product, 2, :title => "Expected"
+
+    assert_equal 2, Product.search("Expected").count
+  end
 end
 

data/test/boolean_test.rb

@@ -3,13 +3,13 @@ require File.expand_path("../test_helper", __FILE__)
 
 class BooleanTest < AttrSearchable::TestCase
   def test_mapping
-    product = FactoryGirl.create(:product, :available => true)
+    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 = FactoryGirl.create(:product, :available => false)
+    product = create(:product, :available => false)
 
     assert_includes Product.search("available: 0"), product
     assert_includes Product.search("available: false"), product
@@ -17,31 +17,37 @@ class BooleanTest < AttrSearchable::TestCase
   end
 
   def test_anywhere
-    product = FactoryGirl.create(:product, :available => true)
+    product = create(:product, :available => true)
 
     assert_includes Product.search("true"), product
     refute_includes Product.search("false"), product
   end
 
   def test_includes
-    product = FactoryGirl.create(:product, :available => true)
+    product = create(:product, :available => true)
 
     assert_includes Product.search("available: true"), product
     refute_includes Product.search("available: false"), product
   end
 
   def test_equals
-    product = FactoryGirl.create(:product, :available => true)
+    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 = FactoryGirl.create(:product, :available => false)
+    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 AttrSearchable::IncompatibleDatatype do
+      Product.unsafe_search "available: Value"
+    end
+  end
 end
 

data/test/datetime_test.rb

@@ -3,7 +3,7 @@ require File.expand_path("../test_helper", __FILE__)
 
 class DatetimeTest < AttrSearchable::TestCase
   def test_mapping
-    product = FactoryGirl.create(:product, :created_at => Time.parse("2014-05-01 12:30:30"))
+    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
@@ -12,59 +12,65 @@ class DatetimeTest < AttrSearchable::TestCase
   end
 
   def test_anywhere
-    product = FactoryGirl.create(:product, :created_at => Time.parse("2014-05-01"))
+    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 = FactoryGirl.create(:product, :created_at => Time.parse("2014-05-01"))
+    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 = FactoryGirl.create(:product, :created_at => Time.parse("2014-05-01"))
+    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 = FactoryGirl.create(:product, :created_at => Time.parse("2014-05-01"))
+    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 = FactoryGirl.create(:product, :created_at => Time.parse("2014-05-01"))
+    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_equals
-    product = FactoryGirl.create(:product, :created_at => Time.parse("2014-05-01"))
+    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 = FactoryGirl.create(:product, :created_at => Time.parse("2014-05-01"))
+    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 = FactoryGirl.create(:product, :created_at => Time.parse("2014-05-02"))
+    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 AttrSearchable::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 < AttrSearchable::TestCase
+  def test_parse_error
+    assert_raises AttrSearchable::ParseError do
+      Product.unsafe_search :title => { :unknown_operator => "Value" }
+    end
+  end
+
+  def test_unknown_column
+    assert_raises AttrSearchable::UnknownColumn do
+      Product.unsafe_search "Unknown: Column"
+    end
+  end
+end
+

data/test/float_test.rb

@@ -3,59 +3,65 @@ require File.expand_path("../test_helper", __FILE__)
 
 class FloatTest < AttrSearchable::TestCase
   def test_anywhere
-    product = FactoryGirl.create(:product, :price => 10.5, :created_at => Time.now - 1.day)
+    product = create(:product, :price => 10.5, :created_at => Time.now - 1.day)
 
     assert_includes Product.search("10.5"), product
     refute_includes Product.search("11.5"), product
   end
 
   def test_includes
-    product = FactoryGirl.create(:product, :price => 10.5)
+    product = create(:product, :price => 10.5)
 
     assert_includes Product.search("price: 10.5"), product
     refute_includes Product.search("price: 11.5"), product
   end
 
   def test_equals
-    product = FactoryGirl.create(:product, :price => 10.5)
+    product = create(:product, :price => 10.5)
 
     assert_includes Product.search("price = 10.5"), product
     refute_includes Product.search("price = 11.5"), product
   end
 
   def test_equals_not
-    product = FactoryGirl.create(:product, :price => 10.5)
+    product = create(:product, :price => 10.5)
 
     assert_includes Product.search("price != 11.5"), product
     refute_includes Product.search("price != 10.5"), product
   end
 
   def test_greater
-    product = FactoryGirl.create(:product, :price => 10.5)
+    product = create(:product, :price => 10.5)
 
     assert_includes Product.search("price > 10.4"), product
     refute_includes Product.search("price < 10.5"), product
   end
 
   def test_greater_equals
-    product = FactoryGirl.create(:product, :price => 10.5)
+    product = create(:product, :price => 10.5)
 
     assert_includes Product.search("price >= 10.5"), product
     refute_includes Product.search("price >= 10.6"), product
   end
 
   def test_less
-    product = FactoryGirl.create(:product, :price => 10.5)
+    product = create(:product, :price => 10.5)
 
     assert_includes Product.search("price < 10.6"), product
     refute_includes Product.search("price < 10.5"), product
   end
 
   def test_less_equals
-    product = FactoryGirl.create(:product, :price => 10.5)
+    product = create(:product, :price => 10.5)
 
     assert_includes Product.search("price <= 10.5"), product
     refute_includes Product.search("price <= 10.4"), product
   end
+
+  def test_incompatible_datatype
+    assert_raises AttrSearchable::IncompatibleDatatype do
+      Product.unsafe_search "price: Value"
+    end
+  end
 end
 

data/test/fulltext_test.rb

@@ -3,9 +3,9 @@ require File.expand_path("../test_helper", __FILE__)
 
 class FulltextTest < AttrSearchable::TestCase
   def test_complex
-    product1 = FactoryGirl.create(:product, :title => "word1")
-    product2 = FactoryGirl.create(:product, :title => "word2 word3")
-    product3 = FactoryGirl.create(:product, :title => "word2")
+    product1 = create(:product, :title => "word1")
+    product2 = create(:product, :title => "word2 word3")
+    product3 = create(:product, :title => "word2")
 
     results = Product.search("title:word1 OR (title:word2 -title:word3)")
 
@@ -15,8 +15,8 @@ class FulltextTest < AttrSearchable::TestCase
   end
 
   def test_mixed
-    expected = FactoryGirl.create(:product, :title => "Expected title", :stock => 1)
-    rejected = FactoryGirl.create(:product, :title => "Expected title", :stock => 0)
+    expected = create(:product, :title => "Expected title", :stock => 1)
+    rejected = create(:product, :title => "Expected title", :stock => 0)
 
     results = Product.search("title:Expected title:Title stock > 0")
 

data/test/hash_test.rb

@@ -0,0 +1,97 @@
+
+require File.expand_path("../test_helper", __FILE__)
+
+class HashTest < AttrSearchable::TestCase
+  def test_subquery
+    product1 = create(:product, :title => "Title1", :description => "Description")
+    product2 = create(:product, :title => "Title2", :description => "Description")
+    product3 = create(:product, :title => "TItle3", :description => "Description")
+
+    results = Product.search(:or => [{ :query => "Description Title1" }, { :query => "Description Title2" }])
+
+    assert_includes results, product1
+    assert_includes results, product2
+    refute_includes results, product3
+  end
+
+  def test_matches
+    expected = create(:product, :title => "Expected")
+    rejected = create(:product, :title => "Rejected")
+
+    results = Product.search(:title => { :matches => "Expected" })
+
+    assert_includes results, expected
+    refute_includes results, rejected
+  end
+
+  def test_matches_default
+    expected = create(:product, :title => "Expected")
+    rejected = create(:product, :title => "Rejected")
+
+    results = Product.search(:title => "Expected")
+
+    assert_includes results, expected
+    refute_includes results, rejected
+  end
+
+  def test_eq
+    expected = create(:product, :title => "Expected")
+    rejected = create(:product, :title => "Rejected")
+
+    results = Product.search(:title => { :eq => "Expected" })
+
+    assert_includes results, expected
+    refute_includes results, rejected
+  end
+
+  def test_not_eq
+    expected = create(:product, :title => "Expected")
+    rejected = create(:product, :title => "Rejected")
+
+    results = Product.search(:title => { :not_eq => "Rejected" })
+
+    assert_includes results, expected
+    refute_includes results, rejected
+  end
+
+  def test_gt
+    expected = create(:product, :stock => 1)
+    rejected = create(:product, :stock => 0)
+
+    results = Product.search(:stock => { :gt => 0 })
+
+    assert_includes results, expected
+    refute_includes results, rejected
+  end
+
+  def test_gteq
+    expected = create(:product, :stock => 1)
+    rejected = create(:product, :stock => 0)
+
+    results = Product.search(:stock => { :gteq => 1 })
+
+    assert_includes results, expected
+    refute_includes results, rejected
+  end
+
+  def test_lt
+    expected = create(:product, :stock => 0)
+    rejected = create(:product, :stock => 1)
+
+    results = Product.search(:stock => { :lt => 1 })
+
+    assert_includes results, expected
+    refute_includes results, rejected
+  end
+
+  def test_lteq
+    expected = create(:product, :stock => 0)
+    rejected = create(:product, :stock => 1)
+
+    results = Product.search(:stock => { :lteq => 0 })
+
+    assert_includes results, expected
+    refute_includes results, rejected
+  end
+end
+

data/test/integer_test.rb

@@ -3,59 +3,65 @@ require File.expand_path("../test_helper", __FILE__)
 
 class IntegerTest < AttrSearchable::TestCase
   def test_anywhere
-    product = FactoryGirl.create(:product, :stock => 1)
+    product = create(:product, :stock => 1)
 
     assert_includes Product.search("1"), product
     refute_includes Product.search("0"), product
   end
 
   def test_includes
-    product = FactoryGirl.create(:product, :stock => 1)
+    product = create(:product, :stock => 1)
 
     assert_includes Product.search("stock: 1"), product
     refute_includes Product.search("stock: 10"), product
   end
 
   def test_equals
-    product = FactoryGirl.create(:product, :stock => 1)
+    product = create(:product, :stock => 1)
 
     assert_includes Product.search("stock = 1"), product
     refute_includes Product.search("stock = 0"), product
   end
 
   def test_equals_not
-    product = FactoryGirl.create(:product, :stock => 1)
+    product = create(:product, :stock => 1)
 
     assert_includes Product.search("stock != 0"), product
     refute_includes Product.search("stock != 1"), product
   end
 
   def test_greater
-    product = FactoryGirl.create(:product, :stock => 1)
+    product = create(:product, :stock => 1)
 
     assert_includes Product.search("stock > 0"), product
     refute_includes Product.search("stock < 1"), product
   end
 
   def test_greater_equals
-    product = FactoryGirl.create(:product, :stock => 1)
+    product = create(:product, :stock => 1)
 
     assert_includes Product.search("stock >= 1"), product
     refute_includes Product.search("stock >= 2"), product
   end
 
   def test_less
-    product = FactoryGirl.create(:product, :stock => 1)
+    product = create(:product, :stock => 1)
 
     assert_includes Product.search("stock < 2"), product
     refute_includes Product.search("stock < 1"), product
   end
 
   def test_less_equals
-    product = FactoryGirl.create(:product, :stock => 1)
+    product = create(:product, :stock => 1)
 
     assert_includes Product.search("stock <= 1"), product
     refute_includes Product.search("stock <= 0"), product
   end
+
+  def test_incompatible_datatype
+    assert_raises AttrSearchable::IncompatibleDatatype do
+      Product.unsafe_search "stock: Value"
+    end
+  end
 end
 

data/test/not_test.rb

@@ -3,8 +3,8 @@ require File.expand_path("../test_helper", __FILE__)
 
 class NotTest < AttrSearchable::TestCase
   def test_not_string
-    expected = FactoryGirl.create(:product, :title => "Expected title")
-    rejected = FactoryGirl.create(:product, :title => "Rejected title")
+    expected = create(:product, :title => "Expected title")
+    rejected = create(:product, :title => "Rejected title")
 
     results = Product.search("title: Title NOT title: Rejected")
 
@@ -15,8 +15,8 @@ class NotTest < AttrSearchable::TestCase
   end
 
   def test_not_hash
-    expected = FactoryGirl.create(:product, :title => "Expected title")
-    rejected = FactoryGirl.create(:product, :title => "Rejected title")
+    expected = create(:product, :title => "Expected title")
+    rejected = create(:product, :title => "Rejected title")
 
     results = Product.search(:and => [{:title => "Title"}, {:not => {:title => "Rejected"}}])
 

data/test/or_test.rb

@@ -3,9 +3,9 @@ require File.expand_path("../test_helper", __FILE__)
 
 class OrTest < AttrSearchable::TestCase
   def test_or_string
-    product1 = FactoryGirl.create(:product, :title => "Title1")
-    product2 = FactoryGirl.create(:product, :title => "Title2")
-    product3 = FactoryGirl.create(:product, :title => "Title3")
+    product1 = create(:product, :title => "Title1")
+    product2 = create(:product, :title => "Title2")
+    product3 = create(:product, :title => "Title3")
 
     results = Product.search("title: Title1 OR title: Title2")
 
@@ -15,9 +15,9 @@ class OrTest < AttrSearchable::TestCase
   end
 
   def test_or_hash
-    product1 = FactoryGirl.create(:product, :title => "Title1")
-    product2 = FactoryGirl.create(:product, :title => "Title2")
-    product3 = FactoryGirl.create(:product, :title => "Title3")
+    product1 = create(:product, :title => "Title1")
+    product2 = create(:product, :title => "Title2")
+    product3 = create(:product, :title => "Title3")
 
     results = Product.search(:or => [{:title => "Title1"}, {:title => "Title2"}])
 

data/test/string_test.rb

@@ -3,35 +3,35 @@ require File.expand_path("../test_helper", __FILE__)
 
 class StringTest < AttrSearchable::TestCase
   def test_anywhere
-    product = FactoryGirl.create(:product, :title => "Expected title")
+    product = create(:product, :title => "Expected title")
 
     assert_includes Product.search("Expected"), product
     refute_includes Product.search("Rejected"), product
   end
 
   def test_multiple
-    product = FactoryGirl.create(:product, :comments => [FactoryGirl.create(:comment, :title => "Expected title", :message => "Expected message")])
+    product = create(:product, :comments => [create(:comment, :title => "Expected title", :message => "Expected message")])
 
     assert_includes Product.search("Expected"), product
     refute_includes Product.search("Rejected"), product
   end
 
   def test_includes
-    product = FactoryGirl.create(:product, :title => "Expected")
+    product = create(:product, :title => "Expected")
 
     assert_includes Product.search("title: Expected"), product
     refute_includes Product.search("title: Rejected"), product
   end
 
   def test_includes_with_left_wildcard
-    product = FactoryGirl.create(:product, :title => "Some title")
+    product = create(:product, :title => "Some title")
 
     assert_includes Product.search("title: Title"), product
   end
 
   def test_includes_without_left_wildcard
-    expected = FactoryGirl.create(:product, :brand => "Brand")
-    rejected = FactoryGirl.create(:product, :brand => "Rejected brand")
+    expected = create(:product, :brand => "Brand")
+    rejected = create(:product, :brand => "Rejected brand")
 
     results = with_attr_searchable_options(Product, :brand, :left_wildcard => false) { Product.search "brand: Brand" }
 
@@ -40,42 +40,42 @@ class StringTest < AttrSearchable::TestCase
   end
 
   def test_equals
-    product = FactoryGirl.create(:product, :title => "Expected title")
+    product = create(:product, :title => "Expected title")
 
     assert_includes Product.search("title = 'Expected title'"), product
     refute_includes Product.search("title = Expected"), product
   end
 
   def test_equals_not
-    product = FactoryGirl.create(:product, :title => "Expected")
+    product = create(:product, :title => "Expected")
 
     assert_includes Product.search("title != Rejected"), product
     refute_includes Product.search("title != Expected"), product
   end
 
   def test_greater
-    product = FactoryGirl.create(:product, :title => "Title B")
+    product = create(:product, :title => "Title B")
 
     assert_includes Product.search("title > 'Title A'"), product
     refute_includes Product.search("title > 'Title B'"), product
   end
 
   def test_greater_equals
-    product = FactoryGirl.create(:product, :title => "Title A")
+    product = create(:product, :title => "Title A")
 
     assert_includes Product.search("title >= 'Title A'"), product
     refute_includes Product.search("title >= 'Title B'"), product
   end
 
   def test_less
-    product = FactoryGirl.create(:product, :title => "Title A")
+    product = create(:product, :title => "Title A")
 
     assert_includes Product.search("title < 'Title B'"), product
     refute_includes Product.search("title < 'Title A'"), product
   end
 
   def test_less_or_greater
-    product = FactoryGirl.create(:product, :title => "Title B")
+    product = create(:product, :title => "Title B")
 
     assert_includes Product.search("title <= 'Title B'"), product
     refute_includes Product.search("title <= 'Title A'"), product

data/test/test_helper.rb

@@ -79,6 +79,8 @@ if DATABASE == "mysql"
 end
 
 class AttrSearchable::TestCase
+  include FactoryGirl::Syntax::Methods
+
   def teardown
     Product.delete_all
     Comment.delete_all

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: attr_searchable
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-11 00:00:00.000000000 Z
+date: 2014-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: treetop
@@ -123,7 +123,7 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Complex search-engine like query support for activerecord
+description: Search-engine like fulltext query support for ActiveRecord
 email:
 - vetter@flakks.com
 executables: []
@@ -155,13 +155,14 @@ files:
 - test/boolean_test.rb
 - test/database.yml
 - test/datetime_test.rb
+- test/error_test.rb
 - test/float_test.rb
 - test/fulltext_test.rb
+- test/hash_test.rb
 - test/integer_test.rb
 - test/not_test.rb
 - test/or_test.rb
 - test/string_test.rb
-- test/sub_query_test.rb
 - test/test_helper.rb
 homepage: https://github.com/mrkamel/attr_searchable
 licenses:
@@ -187,18 +188,20 @@ rubyforge_project:
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: Easily perform complex search-engine like queries on your activerecord models
+summary: Easily perform complex search-engine like fulltext queries on your ActiveRecord
+  models
 test_files:
 - test/and_test.rb
 - test/attr_searchable_test.rb
 - test/boolean_test.rb
 - test/database.yml
 - test/datetime_test.rb
+- test/error_test.rb
 - test/float_test.rb
 - test/fulltext_test.rb
+- test/hash_test.rb
 - test/integer_test.rb
 - test/not_test.rb
 - test/or_test.rb
 - test/string_test.rb
-- test/sub_query_test.rb
 - test/test_helper.rb

data/test/sub_query_test.rb

@@ -1,17 +0,0 @@
-
-require File.expand_path("../test_helper", __FILE__)
-
-class SubQueryTest < AttrSearchable::TestCase
-  def test_subquery
-    product1 = FactoryGirl.create(:product, :title => "Title1")
-    product2 = FactoryGirl.create(:product, :title => "Title2")
-    product3 = FactoryGirl.create(:product, :title => "TItle3")
-
-    results = Product.search(:or => [{:query => "Title1"}, {:query => "Title2"}])
-
-    assert_includes results, product1
-    assert_includes results, product2
-    refute_includes results, product3
-  end
-end
-