bloodhound 0.1 → 0.2

data/.gitignore

@@ -1 +1,2 @@
 dist
+spec/test.db

data/README.markdown

@@ -83,6 +83,15 @@ Any extra options you pass to `search_field` are added into the finder options:
     attributes #=> { :joins => :user,
                      :conditions => { "users.login" => "foca" } }
 
+Install it
+----------
+
+    gem install bloodhound
+
+For the active record interface:
+
+    config.gem "bloodhound", :lib => "bloodhound/active_record"
+
 Known problems
 --------------
 

data/bloodhound.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name    = "bloodhound"
-  s.version = "0.1"
-  s.date    = "2010-01-15"
+  s.version = "0.2"
+  s.date    = "2010-02-01"
 
   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 }"
@@ -18,10 +18,8 @@ Gem::Specification.new do |s|
 README.markdown
 bloodhound.gemspec
 lib/bloodhound.rb
-lib/bloodhound/active_record.rb
 spec/spec_helper.rb
 spec/bloodhound_spec.rb
-spec/bloodhound/active_record_spec.rb
 ]
 end
 

data/lib/bloodhound.rb

@@ -1,28 +1,82 @@
 require "chronic"
 
 class Bloodhound
-  VERSION = "0.1"
-  ATTRIBUTE_RE = /\s*(\S+):(?:"([^"]*)"|'([^']*)'|(\S+))\s*/.freeze
+  VERSION = "0.2"
+  ATTRIBUTE_RE = /\s*(?:(?:(\S+):)?(?:"([^"]*)"|'([^']*)'|(\S+)))\s*/.freeze
 
   def initialize
-    @mappings = {}
+    @search_fields = {}
+    @keywords = {}
   end
 
-  def add_search_field(name, type=:string, attribute=name, &mapping)
-    @mappings[name.to_sym] = [attribute, type.to_sym, mapping]
+  def fields
+    @search_fields
   end
 
-  def attributes_from(query)
-    parse_query(query).inject({}) do |conditions, (key,value)|
-      attribute, type, mapping = @mappings.fetch(key.to_sym, [])
+  def field(name, options={}, &mapping)
+    attribute = options.delete(:attribute) || name
+    fuzzy = options.delete(:fuzzy)
+    type = options.delete(:type).try(:to_sym)
 
-      if attribute && type
-        conditions[attribute.to_s] = (mapping || default_mapping).call(cast_value(value, type))
+    fields[name.to_sym] = {
+      :attribute => attribute.to_s,
+      :type      => type,
+      :fuzzy     => fuzzy.nil? ? true : fuzzy,
+      :options   => options,
+      :mapping   => mapping || default_mapping
+    }
+  end
+
+  def keyword(name, &block)
+    @keywords[name.to_sym] = block
+  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
+    end
+  end
+
+  def text_search_for(model, value)
+    return model if fields.empty?
 
-      conditions
+    model = scoped_by_text_search_options(model)
+
+    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
+      else
+        conditions
+      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 }))
+  end
+  private :attribute_search_for
+
+  def keyword_search_for(model, keyword, value)
+    model.scoped(@keywords[keyword].call(value))
   end
+  private :keyword_search_for
 
   def default_mapping
     lambda {|value| value }
@@ -54,10 +108,33 @@ class Bloodhound
   end
   private :cast_value
 
-  def parse_query(query)
+  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)
     query.scan(ATTRIBUTE_RE).map do |(key,*value)|
-      [key, value.compact.first]
+      value = value.compact.first
+      [key || value, key && value]
+    end
+  end
+  private :tokenize
+
+  def has_keyword?(name)
+    @keywords.has_key?(name)
+  end
+
+  module Searchable
+    def bloodhound(&block)
+      @bloodhound ||= Bloodhound.new
+      block ? @bloodhound.tap(&block) : @bloodhound
+    end
+
+    def scoped_search(query)
+      bloodhound.search_scope(self, query)
     end
   end
-  private :parse_query
 end

data/spec/bloodhound_spec.rb

@@ -1,107 +1,86 @@
 require "spec_helper"
 
-describe Bloodhound do
-  context "adding fields" do
-    it "can specify a type of :string" do
-      subject.add_search_field(:some_string, :string)
-      { "some_string" => "falafel" }.should be_included_in_extracted_attributes_from("some_string:falafel")
-    end
-
-    it "can specify a type of :integer" do
-      subject.add_search_field(:some_number, :integer)
-      { "some_number" => 1 }.should be_included_in_extracted_attributes_from("some_number:1")
-    end
-
-    it "can specify a type of :float" do
-      subject.add_search_field(:some_number, :float)
-      { "some_number" => 1.5 }.should be_included_in_extracted_attributes_from("some_number:1.5")
-    end
-
-    it "can specify a type of :boolean" do
-      subject.add_search_field(:some_boolean, :boolean)
-      { "some_boolean" => true }.should be_included_in_extracted_attributes_from("some_boolean:true")
-    end
+class User < ActiveRecord::Base
+  extend Bloodhound::Searchable
+
+  has_many :products
+
+  bloodhound do |search|
+    search.field(:first_name, :attribute => "lower(users.first_name)") {|value| value.downcase }
+    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(",")
+  end
+end
 
-    it "can specify a type of :date" do
-      subject.add_search_field(:some_date, :date)
-      { "some_date" => Date.parse('2010-01-05') }.should be_included_in_extracted_attributes_from("some_date:2010-01-05")
-    end
+class Product < ActiveRecord::Base
+  extend Bloodhound::Searchable
 
-    it "can specifiy a type of :time" do
-      subject.add_search_field(:some_time, :time)
-      { "some_time" => Time.mktime(2010, 1, 5, 12, 0, 0) }.should be_included_in_extracted_attributes_from("some_time:'2010-01-05 12:00:00'")
-    end
+  belongs_to :user
 
-    it "can specify a type of :text" do
-      subject.add_search_field(:some_text, :text)
-      { "some_text" => "Hello world" }.should be_included_in_extracted_attributes_from("some_text:'Hello world'")
-    end
+  bloodhound do |search|
+    search.field :name
+    search.field :value
+    search.field :available, :type => :boolean, :fuzzy => false
 
-    it "defaults to a :string field" do
-      subject.add_search_field(:some_string)
-      { "some_string" => "falafel" }.should be_included_in_extracted_attributes_from("some_string:falafel")
+    search.keyword :sort do |value|
+      { :order => "#{search.fields[value.to_sym][:attribute]} DESC" }
     end
   end
+end
 
-  context "matching quoted values" do
-    before { subject.add_search_field(:foo) }
-
-    it "matches unquoted values" do
-      { "foo" => "bar" }.should be_included_in_extracted_attributes_from("foo:bar")
-      { "foo" => "b'a'r" }.should be_included_in_extracted_attributes_from("foo:b'a'r")
-      { "foo" => "ba'r" }.should be_included_in_extracted_attributes_from("foo:ba'r")
-    end
-
-    it "matches values within double quotes" do
-      { "foo" => "this is awesome" }.should be_included_in_extracted_attributes_from(%Q(foo:"this is awesome"))
-      { "foo" => "this is 'tricky'" }.should be_included_in_extracted_attributes_from(%Q(foo:"this is 'tricky'"))
-      { "foo" => "'this is even trickier'" }.should be_included_in_extracted_attributes_from(%Q(foo:"'this is even trickier'"))
-    end
-
-    it "matches values within single quotes" do
-      { "foo" => 'this is awesome' }.should be_included_in_extracted_attributes_from(%Q(foo:'this is awesome'))
-      { "foo" => 'this is "tricky"' }.should be_included_in_extracted_attributes_from(%Q(foo:'this is "tricky"'))
-      { "foo" => '"this is even trickier"' }.should be_included_in_extracted_attributes_from(%Q(foo:'"this is even trickier"'))
-    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)
   end
 
-  context "casting values" do
-    it "matches 'yes', 'true', 'y', 'no', 'false', and 'n' as boolean values" do
-      subject.add_search_field(:foo, :boolean)
-      { "foo" => true }.should be_included_in_extracted_attributes_from("foo:yes")
-      { "foo" => true }.should be_included_in_extracted_attributes_from("foo:y")
-      { "foo" => true }.should be_included_in_extracted_attributes_from("foo:true")
-      { "foo" => false }.should be_included_in_extracted_attributes_from("foo:no")
-      { "foo" => false }.should be_included_in_extracted_attributes_from("foo:n")
-      { "foo" => false }.should be_included_in_extracted_attributes_from("foo:false")
-    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)
+  end
 
-    it "parses integers as Integer objects" do
-      subject.add_search_field(:foo, :integer)
-      subject.add_search_field(:bar, :integer)
-      { "foo" => 1, "bar" => 2 }.should be_included_in_extracted_attributes_from("foo:1 bar:2.8")
-    end
+  it "uses LIKE '%query%' for fuzzy searches" do
+    User.scoped_search("oh").should include(@john)
+  end
 
-    it "parses decimal values as Float objects" do
-      subject.add_search_field(:foo, :float)
-      { "foo" => 1.5 }.should be_included_in_extracted_attributes_from("foo:1.5")
-    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)
+  end
 
-    it "parses dates as instances of Date" do
-      subject.add_search_field(:foo, :date)
-      { "foo" => Date.today }.should be_included_in_extracted_attributes_from("foo:today")
-    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)
+  end
 
-    it "parses times as instances of Time" do
-      subject.add_search_field(:foo, :time)
-      { "foo" => Time.mktime(2010, 1, 5, 12, 0, 0) }.should be_included_in_extracted_attributes_from("foo:2010-01-05 12:00:00")
-    end
+  it "allows defining arbitrary keywords to create scopes" do
+    @john.products.scoped_search("order:name").all.should == [@tv, @ducky]
   end
 
-  context "processing matched values with user-defined lambdas" do
-    it "lets you convert matched values according to your business rules" do
-      subject.add_search_field(:incomplete, :boolean, "complete") {|value| not value }
-      { "complete" => false }.should be_included_in_extracted_attributes_from("incomplete:yes")
-    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 == {}
   end
 end

data/spec/spec_helper.rb

@@ -1,12 +1,38 @@
 require "spec"
 require "ostruct"
 require "bloodhound"
+require "active_record"
+
+ActiveRecord::Base.establish_connection(
+  :adapter => "sqlite3",
+  :database => "spec/test.db"
+)
+
+#ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+ActiveRecord::Base.connection.tables.each do |table|
+  ActiveRecord::Base.connection.drop_table(table)
+end
+
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :users do |t|
+    t.string :first_name
+    t.string :last_name
+  end
+
+  create_table :products do |t|
+    t.string :name
+    t.integer :value
+    t.boolean :available, :default => true
+    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.attributes_from(attribute_string)
+        expected = subject.tokenize(attribute_string)
         given.each do |key, value|
           expected.fetch(key).should == value
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bloodhound
 version: !ruby/object:Gem::Version 
-  version: "0.1"
+  version: "0.2"
 platform: ruby
 authors: 
 - "Nicol\xC3\xA1s Sanguinetti"
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-15 00:00:00 -02:00
+date: 2010-02-01 00:00:00 -02:00
 default_executable: 
 dependencies: []
 
@@ -26,10 +26,8 @@ files:
 - README.markdown
 - bloodhound.gemspec
 - lib/bloodhound.rb
-- lib/bloodhound/active_record.rb
 - spec/spec_helper.rb
 - spec/bloodhound_spec.rb
-- spec/bloodhound/active_record_spec.rb
 has_rdoc: false
 homepage: http://github.com/foca/bloodhound
 licenses: []

data/lib/bloodhound/active_record.rb

@@ -1,43 +0,0 @@
-require "bloodhound"
-
-module ActiveRecord
-  class Bloodhound < ::Bloodhound
-    def initialize
-      super()
-      @extra_options = {}
-    end
-
-    def add_search_field(name, type=:string, attribute=name, options={}, &mapping)
-      super(name, type, attribute, &mapping)
-      @extra_options[attribute.to_s] = options
-    end
-
-    def attributes_from(query)
-      super(query).inject({}) do |finder_options, (name, value)|
-        finder_options[:conditions] ||= {}
-        finder_options[:conditions].update(name => value)
-        finder_options.update(@extra_options.fetch(name, {}))
-        finder_options
-      end
-    end
-  end
-end
-
-module Bloodhound::Searchable
-  def bloodhound
-    @bloodhound ||= ActiveRecord::Bloodhound.new
-  end
-
-  def search_field(name, options={}, &mapping)
-    attribute = options.delete(:attribute) || name
-    type      = options.delete(:type) || :string
-    bloodhound.add_search_field(name, type, attribute, options, &mapping)
-  end
-
-  def self.extended(model)
-    model.columns.each do |column|
-      next if column.name.to_s =~ /_?id$/
-      model.search_field column.name, :type => column.type
-    end
-  end
-end

data/spec/bloodhound/active_record_spec.rb

@@ -1,44 +0,0 @@
-require "spec_helper"
-require "bloodhound/active_record"
-
-describe ActiveRecord::Bloodhound do
-  it "returns a hash with { :conditions => {keys matched} } instead of just the keys" do
-    subject.add_search_field(:foo)
-    subject.attributes_from("foo:bar").should == { :conditions => { "foo" => "bar" } }
-  end
-
-  it "allows for extra options, that get merged into the return hash" do
-    subject.add_search_field(:user, :string, "users.name", :joins => :users)
-    subject.attributes_from("user:'John Doe'").should == {
-      :joins => :users,
-      :conditions => { "users.name" => "John Doe" }
-    }
-  end
-end
-
-describe Bloodhound::Searchable do
-  Column = Struct.new(:name, :type)
-
-  class MockModel
-    def self.columns
-      [Column.new(:id, :integer), Column.new(:name, :string), Column.new(:user_id, :integer)]
-    end
-
-    extend Bloodhound::Searchable
-  end
-
-  it "allows accessing the bloodhound object in the model by calling Model.bloodhound" do
-    MockModel.bloodhound.should be_an(ActiveRecord::Bloodhound)
-  end
-
-  it "adds search fields for the non-id fields in the model" do
-    conditions = MockModel.bloodhound.attributes_from("name:John id:3 user_id:5").fetch(:conditions)
-    conditions.should_not have_key("id")
-    conditions.should_not have_key("user_id")
-  end
-
-  it "allows you to add search fields with a more ActiveRecord-ish syntax" do
-    MockModel.search_field :user, :type => :string, :attribute => "users.name"
-    MockModel.bloodhound.attributes_from("user:John").should == { :conditions => { "users.name" => "John" } }
-  end
-end