bloodhound 0.2.1 → 0.3

data/bloodhound.gemspec

@@ -1,10 +1,10 @@
 Gem::Specification.new do |s|
   s.name    = "bloodhound"
-  s.version = "0.2.1"
-  s.date    = "2010-02-04"
+  s.version = "0.3"
+  s.date    = "2010-02-07"
 
-  s.description = "Convert strings like 'user:foca age:23' to { 'user' => 'foca' => 'age' => 23 }"
-  s.summary = "Convert strings like 'user:foca age:23' to { 'user' => 'foca' => 'age' => 23 }"
+  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"
   s.homepage    = "http://github.com/foca/bloodhound"
 
   s.authors = ["Nicolás Sanguinetti"]

data/lib/bloodhound.rb

@@ -1,82 +1,65 @@
 require "chronic"
+require "active_record"
 
 class Bloodhound
-  VERSION = "0.2.1"
+  VERSION = "0.3"
   ATTRIBUTE_RE = /\s*(?:(?:(\S+):)?(?:"([^"]*)"|'([^']*)'|(\S+)))\s*/.freeze
 
-  def initialize
-    @search_fields = {}
-    @keywords = {}
-  end
+  attr_reader :fields
 
-  def fields
-    @search_fields
+  def initialize(model)
+    @model = model
+    @fields = {}
   end
 
   def field(name, options={}, &mapping)
-    attribute = options.delete(:attribute) || name
-    fuzzy = options.delete(:fuzzy)
-    type = options.delete(:type).try(:to_sym)
-
-    fields[name.to_sym] = {
-      :attribute => attribute.to_s,
-      :type      => type,
-      :fuzzy     => fuzzy.nil? ? true : fuzzy,
-      :options   => options,
+    @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
     }
-  end
 
-  def keyword(name, &block)
-    @keywords[name.to_sym] = block
+    define_scope(name) do |value|
+      value = field[:mapping].call(cast_value(value, field[:type]))
+      field[:options].merge(:conditions => { field[:attribute] => value })
+    end
   end
 
-  def search_scope(model, query)
-    tokenize(query).inject(model) do |model, (key,value)|
-      if value.nil?
-        text_search_for(model, key)
-      elsif has_keyword?(key)
-        keyword_search_for(model, key, value)
-      else
-        attribute_search_for(model, key, value)
-      end
+  def text_search(*fields)
+    options = fields.extract_options!
+    fields = fields.map {|f| "LOWER(#{f}) LIKE :value" }.join(" OR ")
+
+    define_scope "text_search" do |value|
+      options.merge(:conditions => [fields, { :value => "%#{value.downcase}%" }])
     end
   end
 
-  def text_search_for(model, value)
-    return model if fields.empty?
+  def keyword(name, &block)
+    define_scope(name, &block)
+  end
 
-    model = scoped_by_text_search_options(model)
+  def search(query)
+    self.class.tokenize(query).inject(@model) do |model, (key,value)|
+      key, value = "text_search", key if value.nil?
 
-    text_search_conditions = fields.inject([[], {}]) do |conditions, (name,properties)|
-      if properties[:fuzzy]
-        conditions[0] << "#{properties[:attribute]} LIKE :#{name}"
-        conditions[1].update(name => properties[:mapping].call("%#{value}%"))
-        conditions
+      if model.respond_to?(scope_name_for(key))
+        model.send(scope_name_for(key), value)
       else
-        conditions
+        model
       end
     end
-
-    model = model.scoped(:conditions => [text_search_conditions[0].join(" OR "),
-                                         text_search_conditions[1]])
   end
-  private :text_search_for
-
-  def attribute_search_for(model, name, value)
-    properties = fields.fetch(name.to_sym, {})
 
-    return model if properties[:type].nil?
-
-    value = properties[:mapping].call(cast_value(value, properties[:type]))
-    model.scoped(properties[:options].merge(:conditions => { properties[:attribute] => value }))
+  def define_scope(name, &scope)
+    @model.send(:named_scope, scope_name_for(name), scope)
   end
-  private :attribute_search_for
+  private :define_scope
 
-  def keyword_search_for(model, keyword, value)
-    model.scoped(@keywords[keyword.to_sym].call(value))
+  def scope_name_for(key)
+    "bloodhound_for_#{key}"
   end
-  private :keyword_search_for
+  private :scope_name_for
 
   def default_mapping
     lambda {|value| value }
@@ -108,33 +91,21 @@ class Bloodhound
   end
   private :cast_value
 
-  def scoped_by_text_search_options(model)
-    fields.inject(model) do |model, (name,properties)|
-      properties[:fuzzy] ? model.scoped(properties[:options]) : model
-    end
-  end
-  private :scoped_by_text_search_options
-
-  def tokenize(query)
+  def self.tokenize(query)
     query.scan(ATTRIBUTE_RE).map do |(key,*value)|
       value = value.compact.first
       [key || value, key && value]
     end
   end
-  private :tokenize
-
-  def has_keyword?(name)
-    @keywords.has_key?(name.to_sym)
-  end
 
   module Searchable
     def bloodhound(&block)
-      @bloodhound ||= Bloodhound.new
+      @bloodhound ||= Bloodhound.new(self)
       block ? @bloodhound.tap(&block) : @bloodhound
     end
 
-    def scoped_search(query)
-      bloodhound.search_scope(self, query)
+    def scopes_for_query(query)
+      bloodhound.search(query)
     end
   end
 end

data/spec/bloodhound_spec.rb

@@ -6,14 +6,13 @@ class User < ActiveRecord::Base
   has_many :products
 
   bloodhound do |search|
-    search.field(:first_name, :attribute => "lower(users.first_name)") {|value| value.downcase }
+    search.field :first_name
     search.field :last_name
-    search.field :product, :attribute => "products.name", :joins => :products, :group => column_names.join(",")
     search.field :available_product, :type => :boolean,
                                      :attribute => "products.available",
-                                     :fuzzy => false,
-                                     :joins => :products,
-                                     :group => column_names.join(",")
+                                     :include => :products
+
+    search.text_search "first_name", "last_name", "products.name", :include => :products
   end
 end
 
@@ -23,9 +22,11 @@ class Product < ActiveRecord::Base
   belongs_to :user
 
   bloodhound do |search|
+    search.text_search "products.name", "products.value"
+
     search.field :name
     search.field :value
-    search.field :available, :type => :boolean, :fuzzy => false
+    search.field :available, :type => :boolean
 
     search.keyword :sort do |value|
       { :order => "#{search.fields[value.to_sym][:attribute]} DESC" }
@@ -36,51 +37,29 @@ end
 describe Bloodhound do
   before :all do
     @john = User.create(:first_name => "John", :last_name => "Doe")
-    @tv = @john.products.create(:name => "Rubber Duck", :value => 10)
-    @ducky = @john.products.create(:name => "TV", :value => 200)
+    @ducky = @john.products.create(:name => "Rubber Duck", :value => 10)
+    @tv = @john.products.create(:name => "TV", :value => 200)
   end
 
-  it "finds a user by first_name, in a case insensitive manner" do
-    User.scoped_search("John").should include(@john)
-    User.scoped_search("joHN").should include(@john)
+  it "finds a user by first_name" do
+    User.scopes_for_query("first_name:John").should include(@john)
   end
 
-  it "uses LIKE '%query%' for fuzzy searches" do
-    User.scoped_search("oh").should include(@john)
+  it "finds by text search" do
+    Product.scopes_for_query("duck rubber").should include(@ducky)
   end
 
   it "finds a user by last_name, but only in a case sensitive manner" do
-    User.scoped_search("Doe").should include(@john)
-    User.scoped_search("Doe").should have(1).element
-    User.scoped_search("Smith").should_not include(@john)
+    User.scopes_for_query("last_name:Doe").should include(@john)
+    User.scopes_for_query("last_name:Doe").should have(1).element
   end
 
   it "can find using key:value pairs for attribuets that define a type" do
-    User.scoped_search("available_product:yes").should include(@john)
-    User.scoped_search("available_product:no").should_not include(@john)
+    User.scopes_for_query("available_product:yes").should include(@john)
+    User.scopes_for_query("available_product:no").should_not include(@john)
   end
 
   it "allows defining arbitrary keywords to create scopes" do
-    @john.products.scoped_search("order:name").all.should == [@tv, @ducky]
-  end
-
-  it "exposes the fields via bloodhound#attributes" do
-    last_name = User.bloodhound.fields[:last_name]
-    last_name[:attribute].should == "last_name"
-    last_name[:type].should be_nil
-    last_name[:fuzzy].should be_true
-    last_name[:options].should == {}
-
-    first_name = User.bloodhound.fields[:first_name]
-    first_name[:attribute].should == "lower(users.first_name)"
-    first_name[:type].should be_nil
-    first_name[:fuzzy].should be_true
-    first_name[:options].should == {}
-
-    availability = Product.bloodhound.fields[:available]
-    availability[:attribute].should == "available"
-    availability[:type].should == :boolean
-    availability[:fuzzy].should be_false
-    availability[:options].should == {}
+    @john.products.scopes_for_query("sort:name").all.should == [@tv, @ducky]
   end
 end

data/spec/spec_helper.rb

@@ -27,18 +27,3 @@ ActiveRecord::Schema.define(:version => 1) do
     t.belongs_to :user
   end
 end
-
-Spec::Runner.configure do |config|
-  module CustomMatchers
-    def be_included_in_extracted_attributes_from(attribute_string)
-      simple_matcher :other_set_of_attributes do |given|
-        expected = subject.tokenize(attribute_string)
-        given.each do |key, value|
-          expected.fetch(key).should == value
-        end
-      end
-    end
-  end
-
-  config.include CustomMatchers
-end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bloodhound
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
+  version: "0.3"
 platform: ruby
 authors: 
 - "Nicol\xC3\xA1s Sanguinetti"
@@ -9,11 +9,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-04 00:00:00 -02:00
+date: 2010-02-07 00:00:00 -02:00
 default_executable: 
 dependencies: []
 
-description: Convert strings like 'user:foca age:23' to { 'user' => 'foca' => 'age' => 23 }
+description: Map strings like 'user:foca age:23' to ActiveRecord named_scopes
 email: contacto@nicolassanguinetti.info
 executables: []
 
@@ -55,6 +55,6 @@ rubyforge_project:
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: Convert strings like 'user:foca age:23' to { 'user' => 'foca' => 'age' => 23 }
+summary: Map strings like 'user:foca age:23' to ActiveRecord named_scopes
 test_files: []