bloodhound 0.3 → 0.3.1

data/bloodhound.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name    = "bloodhound"
-  s.version = "0.3"
-  s.date    = "2010-02-07"
+  s.version = "0.3.1"
+  s.date    = "2010-03-01"
 
   s.description = "Map strings like 'user:foca age:23' to ActiveRecord named_scopes"
   s.summary = "Map strings like 'user:foca age:23' to ActiveRecord named_scopes"

data/lib/bloodhound.rb

@@ -2,7 +2,7 @@ require "chronic"
 require "active_record"
 
 class Bloodhound
-  VERSION = "0.3"
+  VERSION = "0.3.1"
   ATTRIBUTE_RE = /\s*(?:(?:(\S+):)?(?:"([^"]*)"|'([^']*)'|(\S+)))\s*/.freeze
 
   attr_reader :fields
@@ -14,17 +14,28 @@ class Bloodhound
 
   def field(name, options={}, &mapping)
     @fields[name.to_sym] = field = {
-      :attribute => options.fetch(:attribute, name).to_s,
-      :type      => options.fetch(:type, :string).to_sym,
-      :options   => options.except(:attribute, :type),
-      :mapping   => mapping || default_mapping
+      :attribute       => options.fetch(:attribute, name).to_s,
+      :type            => options.fetch(:type, :string).to_sym,
+      :case_sensitive  => options.fetch(:case_sensitive, true),
+      :match_substring => options.fetch(:match_substring, false),
+      :options         => options.except(:attribute, :type, :case_sensitive, :match_substring),
+      :mapping         => mapping || default_mapping
     }
 
+    define_field(name, field)
+  end
+
+  def define_field(name, field)
     define_scope(name) do |value|
-      value = field[:mapping].call(cast_value(value, field[:type]))
-      field[:options].merge(:conditions => { field[:attribute] => value })
+      field[:options].merge(:conditions => setup_conditions(field, value))
     end
   end
+  private :define_field
+
+  def alias_field(name, other_field)
+    @fields[name.to_sym] = @fields[other_field.to_sym]
+    define_field(name, @fields[name.to_sym])
+  end
 
   def text_search(*fields)
     options = fields.extract_options!
@@ -75,14 +86,10 @@ class Bloodhound
         "false" => false,
         "no"    => false,
         "n"     => false }.fetch(value.downcase, true)
-    when :integer
-      # Kernel#Float is a bit more lax about parsing numbers, like
-      # Integer(0.0) fails, when we just want it interpreted as a zero
-      Float(value).to_i
-    when :float, :decimal
-      Float(value)
+    when :float, :decimal, :integer
+      NumericExpression.new(value, type)
     when :date
-      Date.parse(Chronic.parse(value).to_s)
+      Date.parse(Chronic.parse(value, :context => :past).to_s)
     when :time, :datetime
       Chronic.parse(value)
     else
@@ -91,6 +98,38 @@ class Bloodhound
   end
   private :cast_value
 
+  def setup_conditions(field, value)
+    value = field[:mapping].call(cast_value(value, field[:type]))
+    case field[:type]
+    when :string
+      conditions_for_string_search(field, value)
+    when :float, :decimal, :integer
+      conditions_for_numeric(field, value)
+    else
+      { field[:attribute] => value }
+    end
+  end
+  private :setup_conditions
+
+  def conditions_for_numeric(field, value)
+    [ "#{field[:attribute]} #{value.condition} ?", value.to_s ]
+  end
+
+  def conditions_for_string_search(field, value)
+    if field[:case_sensitive]
+      field_to_search = field[:attribute]
+      value_to_search = value
+    else
+      field_to_search = "lower(#{field[:attribute]})"
+      value_to_search = value.downcase
+    end
+    if field[:match_substring]
+      value_to_search = "%#{value_to_search}%"
+    end
+    [ "#{field_to_search} like ?", value_to_search ]
+  end
+  private :conditions_for_string_search
+
   def self.tokenize(query)
     query.scan(ATTRIBUTE_RE).map do |(key,*value)|
       value = value.compact.first
@@ -108,4 +147,34 @@ class Bloodhound
       bloodhound.search(query)
     end
   end
+
+  class NumericExpression
+    attr_reader :value, :condition
+
+    def initialize(value, type)
+      parts = value.scan(/(?:[=<>]+|(?:\d|\.)+)/)[0,2]
+      # Kernel#Float is a bit more lax about parsing numbers, like
+      # Integer(0.0) fails, when we just want it interpreted as a zero
+      @value = Float(parts.last)
+      @value = @value.to_i if type == :integer
+      @condition = sanitize_condition(parts.first)
+    end
+
+    def sanitize_condition(cond)
+      valid = %w(= == > < <= >= <>)
+      valid.include?(cond) ? cond : "="
+    end
+
+    def to_i
+      value.to_i
+    end
+
+    def to_f
+      value.to_f
+    end
+
+    def to_s
+      value.to_s
+    end
+  end
 end

data/spec/bloodhound_spec.rb

@@ -7,7 +7,10 @@ class User < ActiveRecord::Base
 
   bloodhound do |search|
     search.field :first_name
+    search.alias_field :name, :first_name
     search.field :last_name
+    search.field :insensitive_last_name, :attribute => "last_name", :case_sensitive => false
+    search.field :substringed_last_name, :attribute => "last_name", :match_substring => true
     search.field :available_product, :type => :boolean,
                                      :attribute => "products.available",
                                      :include => :products
@@ -25,7 +28,7 @@ class Product < ActiveRecord::Base
     search.text_search "products.name", "products.value"
 
     search.field :name
-    search.field :value
+    search.field :value, :type => :decimal
     search.field :available, :type => :boolean
 
     search.keyword :sort do |value|
@@ -45,6 +48,10 @@ describe Bloodhound do
     User.scopes_for_query("first_name:John").should include(@john)
   end
 
+  it "finds a user by first_name, using an alias" do
+    User.scopes_for_query("name:John").should include(@john)
+  end
+
   it "finds by text search" do
     Product.scopes_for_query("duck rubber").should include(@ducky)
   end
@@ -54,6 +61,16 @@ describe Bloodhound do
     User.scopes_for_query("last_name:Doe").should have(1).element
   end
 
+  it "can find using case insensitive search" do
+    User.scopes_for_query("insensitive_last_name:doe").should include(@john)
+    User.scopes_for_query("insensitive_last_name:doe").should have(1).element
+  end
+
+  it "can find matching substrings" do
+    User.scopes_for_query("substringed_last_name:oe").should include(@john)
+    User.scopes_for_query("substringed_last_name:oe").should have(1).element
+  end
+
   it "can find using key:value pairs for attribuets that define a type" do
     User.scopes_for_query("available_product:yes").should include(@john)
     User.scopes_for_query("available_product:no").should_not include(@john)
@@ -62,4 +79,18 @@ describe Bloodhound do
   it "allows defining arbitrary keywords to create scopes" do
     @john.products.scopes_for_query("sort:name").all.should == [@tv, @ducky]
   end
+
+  it "allows to search by numeric fields with greater than or lower than modifiers" do
+    @john.products.scopes_for_query("value:=10").should include(@ducky)
+    @john.products.scopes_for_query("value:=10").should have(1).element
+    @john.products.scopes_for_query("value:10").should include(@ducky)
+    @john.products.scopes_for_query("value:10").should have(1).element
+    @john.products.scopes_for_query("value:>100").should include(@tv)
+    @john.products.scopes_for_query("value:>100").should have(1).element
+    @john.products.scopes_for_query("value:<100").should include(@ducky)
+    @john.products.scopes_for_query("value:<100").should have(1).element
+    @john.products.scopes_for_query("value:>200").should have(0).elements
+    @john.products.scopes_for_query("value:>=200").should include(@tv)
+    @john.products.scopes_for_query("value:>=200").should have(1).element
+  end
 end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: bloodhound
 version: !ruby/object:Gem::Version 
-  version: "0.3"
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 1
+  version: 0.3.1
 platform: ruby
 authors: 
 - "Nicol\xC3\xA1s Sanguinetti"
@@ -9,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-07 00:00:00 -02:00
+date: 2010-03-01 00:00:00 -02:00
 default_executable: 
 dependencies: []
 
@@ -41,18 +46,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Map strings like 'user:foca age:23' to ActiveRecord named_scopes