attr_searchable 0.0.3 → 0.0.4

data/README.md

@@ -5,6 +5,8 @@
 [![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)
 
+![attr_searchable](https://raw.githubusercontent.com/mrkamel/attr_searchable_logo/master/attr_searchable.png)
+
 AttrSearchable extends your ActiveRecord models to support fulltext search
 engine like queries via simple query strings and hash-based queries. Assume you
 have a `Book` model having various attributes like `title`, `author`, `stock`,
@@ -218,6 +220,28 @@ from from the usual non-fulltext indices. Thus, you should add a usual index on
 every column you expose to search queries plus a fulltext index for every
 fulltext attribute.
 
+In case you can't use fulltext indices, because you're e.g. still on MySQL 5.5
+while using InnoDB or another RDBMS without fulltext support, you can make your
+RDBMS use usual non-fulltext indices for string columns if you don't need the
+left wildcard within `LIKE` queries. Simply supply the following option:
+
+```ruby
+class User < ActiveRecord::Base
+  include AttrSearchable
+
+  attr_searchable :username
+  attr_searchable_options :username, :left_wildcard => false
+
+  # ...
+```
+
+such that AttrSearchable will omit the left most wildcard.
+
+```ruby
+User.search("admin")
+# ... WHERE users.username LIKE 'admin%'
+```
+
 ## Associations
 
 If you specify searchable attributes from another model, like
@@ -267,6 +291,44 @@ end
 AttrSearchable will then skip any association auto loading and will use
 the `search_scope` instead.
 
+## Custom table names and associations
+
+AttrSearchable tries to infer a model's class name and SQL alias from the
+specified attributes to autodetect datatype definitions, etc. This usually
+works quite fine. In case you're using custom table names via `self.table_name
+= ...` or if a model is associated multiple times, AttrSearchable however can't
+infer the class and alias names, e.g.
+
+```ruby
+class Book < ActiveRecord::Base
+  # ...
+
+  has_many :users, :through => :comments
+  belongs_to :user
+
+  attr_searchable :user => ["users.username", "users_books.username"]
+
+  # ...
+end
+```
+
+Here, for queries to work you have to use `users_books.username`, because
+ActiveRecord assigns a different SQL alias for users within its SQL queries,
+because the user model is associated multiple times. However, as AttrSearchable
+now can't infer the `User` model from `users_books`, you have to add:
+
+```ruby
+class Book < ActiveRecord::Base
+  # ...
+
+  attr_searchable_alias :users_books => :user
+
+  # ...
+end
+```
+
+to tell AttrSearchable about the custom SQL alias and mapping.
+
 ## Supported operators
 
 Query string queries support `AND/and`, `OR/or`, `:`, `=`, `!=`, `<`, `<=`,
@@ -360,6 +422,12 @@ Book.unsafe_search("stock: None") # => raise AttrSearchable::IncompatibleDatatyp
 
 ## Changelog
 
+Version 0.0.4:
+
+* Fixed date attributes
+* Fail softly for mixed datatype attributes
+* Support custom table, class and alias names via attr_searchable_alias
+
 Version 0.0.3:
 
 * belongs_to association fixes

data/lib/attr_searchable.rb

@@ -18,8 +18,8 @@ module AttrSearchable
   class ParseError < RuntimeError; end
 
   module Parser
-    def self.parse(arg, model)
-      arg.is_a?(Hash) ? parse_hash(arg, model) : parse_string(arg, model)
+    def self.parse(query, model)
+      query.is_a?(Hash) ? parse_hash(query, model) : parse_string(query, model)
     end
 
     def self.parse_hash(hash, model)
@@ -40,6 +40,9 @@ module AttrSearchable
     base.class_attribute :searchable_attribute_options
     base.searchable_attribute_options = {}
 
+    base.class_attribute :searchable_attribute_aliases
+    base.searchable_attribute_aliases = {}
+
     base.extend ClassMethods
   end
 
@@ -61,22 +64,30 @@ module AttrSearchable
     end
 
     def attr_searchable_options(key, options = {})
-      self.searchable_attribute_options[key.to_s] = (self.searchable_attribute_options[key.to_s] || {}).merge(options)
+      self.searchable_attribute_options[key.to_s] = (searchable_attribute_options[key.to_s] || {}).merge(options)
+    end
+
+    def attr_searchable_alias(hash)
+      hash.each do |key, value|
+        self.searchable_attribute_aliases[key.to_s] = value.respond_to?(:table_name) ? value.table_name : value.to_s
+      end
     end
 
-    def search(*args)
-      unsafe_search *args
+    def search(query)
+      unsafe_search query
     rescue AttrSearchable::RuntimeError
       respond_to?(:none) ? none : where("1 = 0")
     end
 
-    def unsafe_search(arg)
-      return respond_to?(:scoped) ? scoped : all if arg.blank?
+    def unsafe_search(query)
+      return respond_to?(:scoped) ? scoped : all if query.blank?
+
+      associations = searchable_attributes.values.flatten.uniq.collect { |column| column.split(".").first }.collect { |column| searchable_attribute_aliases[column] || column.to_sym }
 
       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 ||= eager_load(associations - [name.tableize.to_sym])
 
-      scope.where AttrSearchable::Parser.parse(arg, self).optimize!.to_sql(self)
+      scope.where AttrSearchable::Parser.parse(query, self).optimize!.to_sql(self)
     end
   end
 end

data/lib/attr_searchable/version.rb

@@ -1,3 +1,3 @@
 module AttrSearchable
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/attr_searchable_grammar.rb

@@ -87,9 +87,9 @@ module AttrSearchableGrammar
       keys = model.searchable_attribute_options.select { |key, value| value[:default] == true }.keys
       keys = model.searchable_attributes.keys if keys.empty?
 
-      queries = keys.collect { |key| collection_for key }.select { |attribute| attribute.compatible? text_value }.collect { |attribute| attribute.matches text_value }
+      queries = keys.collect { |key| collection_for key }.select { |collection| collection.compatible? text_value }.collect { |collection| collection.matches text_value }
 
-      raise AttrSearchable::NoSearchableAttributes unless model.searchable_attributes
+      raise AttrSearchable::NoSearchableAttributes if queries.empty?
 
       queries.flatten.inject(:or)
     end

data/lib/attr_searchable_grammar/attributes.rb

@@ -55,13 +55,24 @@ module AttrSearchableGrammar
         @attributes ||= model.searchable_attributes[key].collect { |attribute_definition| attribute_for attribute_definition }
       end
 
+      def klass_for(table)
+        klass = model.searchable_attribute_aliases[table]
+        klass ||= table
+
+        klass.classify.constantize
+      end
+
+      def alias_for(table)
+        (model.searchable_attribute_aliases[table] && table) || klass_for(table).table_name
+      end
+
       def attribute_for(attribute_definition)
         table, column = attribute_definition.split(".")
-        klass = table.classify.constantize
+        klass = klass_for(table)
 
         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)
+        Attributes.const_get(klass.columns_hash[column].type.to_s.classify).new(klass.arel_table.alias(alias_for(table))[column], klass, options)
       end
     end
 
@@ -148,16 +159,16 @@ module AttrSearchableGrammar
           ::Time.new($1, $3, 15).beginning_of_month .. ::Time.new($1, $3, 15).end_of_month
         elsif value =~ /^([0-9]{1,2})(\.|-|\/)([0-9]{4,})$/
           ::Time.new($3, $1, 15).beginning_of_month .. ::Time.new($3, $1, 15).end_of_month
-        elsif value !~ /:/ 
+        elsif value !~ /:/
           time = ::Time.parse(value)
           time.beginning_of_day .. time.end_of_day
         else
           time = ::Time.parse(value)
           time .. time
-        end 
+        end
       rescue ArgumentError
         raise AttrSearchable::IncompatibleDatatype, "Incompatible datatype for #{value}"
-      end 
+      end
 
       def map(value)
         parse(value).first
@@ -180,8 +191,20 @@ module AttrSearchableGrammar
 
     class Date < Datetime
       def parse(value)
-        dates = super(value).collect { |time| ::Time.parse(time).to_date }
-        dates.first .. dates.last
+        return value .. value unless value.is_a?(::String)
+
+        if value =~ /^[0-9]{4,}$/
+          ::Date.new(value.to_i).beginning_of_year .. ::Date.new(value.to_i).end_of_year
+        elsif value =~ /^([0-9]{4,})(\.|-|\/)([0-9]{1,2})$/
+          ::Date.new($1.to_i, $3.to_i, 15).beginning_of_month .. ::Date.new($1.to_i, $3.to_i, 15).end_of_month
+        elsif value =~ /^([0-9]{1,2})(\.|-|\/)([0-9]{4,})$/
+          ::Date.new($3.to_i, $1.to_i, 15).beginning_of_month .. ::Date.new($3.to_i, $1.to_i, 15).end_of_month
+        else
+          date = ::Date.parse(value)
+          date .. date
+        end
+      rescue ArgumentError
+        raise AttrSearchable::IncompatibleDatatype, "Incompatible datatype for #{value}"
       end
     end
 
@@ -193,7 +216,7 @@ module AttrSearchableGrammar
         return false if value.to_s =~ /^(0|false|no)$/i
 
         raise AttrSearchable::IncompatibleDatatype, "Incompatible datatype for #{value}"
-      end 
+      end
     end
   end
 end

data/test/date_test.rb

@@ -0,0 +1,75 @@
+
+require File.expand_path("../test_helper", __FILE__)
+
+class DateTest < AttrSearchable::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-05-02"), 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 AttrSearchable::IncompatibleDatatype do
+      Product.unsafe_search "created_on: Value"
+    end
+  end
+end
+

data/test/test_helper.rb

@@ -34,11 +34,12 @@ end
 class Product < ActiveRecord::Base
   include AttrSearchable
 
-  attr_searchable :title, :description, :brand, :stock, :price, :created_at, :available
-  attr_searchable :comment => ["comments.title", "comments.message"], :user => "users.username"
-
+  attr_searchable :title, :description, :brand, :stock, :price, :created_at, :created_on, :available
+  attr_searchable :comment => ["comments.title", "comments.message"], :user => ["users.username", "users_products.username"]
   attr_searchable :primary => [:title, :description]
 
+  attr_searchable_alias :users_products => :user
+
   if DATABASE != "sqlite"
     attr_searchable_options :title, :type => :fulltext
     attr_searchable_options :description, :type => :fulltext
@@ -51,6 +52,8 @@ class Product < ActiveRecord::Base
 
   has_many :comments
   has_many :users, :through => :comments
+
+  belongs_to :user
 end
 
 FactoryGirl.define do
@@ -69,11 +72,13 @@ ActiveRecord::Base.connection.execute "DROP TABLE IF EXISTS comments"
 ActiveRecord::Base.connection.execute "DROP TABLE IF EXISTS users"
 
 ActiveRecord::Base.connection.create_table :products do |t|
+  t.references :user
   t.string :title
   t.text :description
   t.integer :stock
   t.float :price
   t.datetime :created_at
+  t.date :created_on
   t.boolean :available
   t.string :brand
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: attr_searchable
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-26 00:00:00.000000000 Z
+date: 2014-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: treetop
@@ -154,6 +154,7 @@ files:
 - test/attr_searchable_test.rb
 - test/boolean_test.rb
 - test/database.yml
+- test/date_test.rb
 - test/datetime_test.rb
 - test/error_test.rb
 - test/float_test.rb
@@ -195,6 +196,7 @@ test_files:
 - test/attr_searchable_test.rb
 - test/boolean_test.rb
 - test/database.yml
+- test/date_test.rb
 - test/datetime_test.rb
 - test/error_test.rb
 - test/float_test.rb