DrMark-thinking-sphinx 0.9.9 → 1.1.6

data/spec/unit/thinking_sphinx/search_spec.rb

@@ -3,17 +3,18 @@ require 'will_paginate/collection'
 
 describe ThinkingSphinx::Search do
   describe "search method" do
-    it "should actually have some tests"
-  end
-  
-  describe "search_for_id method" do
     before :each do
       @client = Riddle::Client.stub_instance(
         :filters    => [],
         :filters=   => true,
         :id_range=  => true,
+        :sort_mode  => :asc,
+        :limit      => 5,
+        :offset=    => 0,
+        :sort_mode= => true,
         :query      => {
-          :matches  => []
+          :matches  => [],
+          :total    => 50
         }
       )
       
@@ -23,236 +24,36 @@ describe ThinkingSphinx::Search do
       )
     end
     
-    it "should set the client id range to focus on the given id" do
-      ThinkingSphinx::Search.search_for_id 42, "an_index"
-      
-      @client.should have_received(:id_range=).with(42..42)
-    end
-    
-    it "should query on the given index" do
-      ThinkingSphinx::Search.search_for_id 42, "an_index"
-      
-      @client.should have_received(:query).with("", "an_index")
-    end
-    
-    it "should return true if a record is returned" do
-      @client.stub_method(:query => {
-        :matches => [24]
-      })
-      
-      ThinkingSphinx::Search.search_for_id(42, "an_index").should be_true
-    end
-    
-    it "should return false if no records are returned" do
-      ThinkingSphinx::Search.search_for_id(42, "an_index").should be_false
-    end
-  end
-  
-  describe "instance_from_result method" do
-    before :each do
-      Person.stub_method(:find => true)
-      ThinkingSphinx::Search.stub_method(:class_from_crc => Person)
-    end
-    
-    after :each do
-      Person.unstub_method(:find)
-      ThinkingSphinx::Search.unstub_method(:class_from_crc)
-    end
-
-    it "should honour the :include option" do
-      ThinkingSphinx::Search.send(
-        :instance_from_result,
-        {
-          :doc => 1, :attributes => {
-            "sphinx_internal_id" => 2, "class_crc" => 123
-          }
-        },
-        {:include => :assoc}
-      )
-
-      Person.should have_received(:find).with(2, :include => :assoc, :select => nil)
-    end
-
-    it "should honour the :select option" do
-      ThinkingSphinx::Search.send(
-        :instance_from_result,
-        {
-          :doc => 1, :attributes => {
-            "sphinx_internal_id" => 2, "class_crc" => 123
-          }
-        },
-        {:select => :columns}
-      )
-
-      Person.should have_received(:find).with(2, :include => nil, :select => :columns)
-    end
-
-  end
-
-  describe "instances_from_results method" do
-    before :each do
-      @person_a = Person.stub_instance
-      @person_b = Person.stub_instance
-      @person_c = Person.stub_instance
-
-      @person_a.stub_method(:attributes => [])
-      @person_b.stub_method(:attributes => [])
-      @person_c.stub_method(:attributes => [])
-      
-      @results = [
-        {:attributes => {"sphinx_internal_id" => @person_a.id}},
-        {:attributes => {"sphinx_internal_id" => @person_b.id}},
-        {:attributes => {"sphinx_internal_id" => @person_c.id}}
-      ]
+    describe ":star option" do
       
-      Person.stub_method(
-        :find => [@person_c, @person_a, @person_b]
-      )
-      ThinkingSphinx::Search.stub_method(:instance_from_result => true)
-    end
-
-    after :each do
-      Person.unstub_method(:find)
-      ThinkingSphinx::Search.unstub_method(:instance_from_result)
-    end
-
-    it "should pass calls to instance_from_result if no class given" do
-      ThinkingSphinx::Search.send(
-        :instances_from_results, @results
-      )
+      it "should not apply by default" do
+        ThinkingSphinx::Search.search "foo bar"
+        @client.should have_received(:query).with("foo bar")
+      end
 
-      ThinkingSphinx::Search.should have_received(:instance_from_result).with(
-        {:attributes => {"sphinx_internal_id" => @person_a.id}}, {}
-      )
-      ThinkingSphinx::Search.should have_received(:instance_from_result).with(
-        {:attributes => {"sphinx_internal_id" => @person_b.id}}, {}
-      )
-      ThinkingSphinx::Search.should have_received(:instance_from_result).with(
-        {:attributes => {"sphinx_internal_id" => @person_c.id}}, {}
-      )
-    end
+      it "should apply when passed, and handle full extended syntax" do
+        input    = %{a b* c (d | e) 123 5&6 (f_f g) !h "i j" "k l"~10 "m n"/3 @o p -(q|r)}
+        expected = %{*a* b* *c* (*d* | *e*) *123* *5*&*6* (*f_f* *g*) !*h* "i j" "k l"~10 "m n"/3 @o *p* -(*q*|*r*)}
+        ThinkingSphinx::Search.search input, :star => true
+        @client.should have_received(:query).with(expected)
+      end
 
-    it "should call a find on all ids for the class" do
-      ThinkingSphinx::Search.send(
-        :instances_from_results, @results, {}, Person
-      )
-      
-      Person.should have_received(:find).with(
-        :all,
-        :conditions => {:id => [@person_a.id, @person_b.id, @person_c.id]},
-        :include    => nil,
-        :select     => nil
-      )
-    end
-
-    it "should honour the :include option" do
-      ThinkingSphinx::Search.send(
-        :instances_from_results, @results, {:include => :something}, Person
-      )
-      
-      Person.should have_received(:find).with(
-        :all,
-        :conditions => {:id => [@person_a.id, @person_b.id, @person_c.id]},
-        :include    => :something,
-        :select     => nil
-      )
-    end
+      it "should default to /\w+/ as token" do
+        ThinkingSphinx::Search.search "foo@bar.com", :star => true
+        @client.should have_received(:query).with("*foo*@*bar*.*com*")
+      end
 
-    it "should honour the :select option" do
-      ThinkingSphinx::Search.send(
-        :instances_from_results, @results, {:select => :fields}, Person
-      )
-      
-      Person.should have_received(:find).with(
-        :all,
-        :conditions => {:id => [@person_a.id, @person_b.id, @person_c.id]},
-        :include    => nil,
-        :select     => :fields
-      )
-    end
+      it "should honour custom token" do
+        ThinkingSphinx::Search.search "foo@bar.com -foo-bar", :star => /[\w@.-]+/u
+        @client.should have_received(:query).with("*foo@bar.com* -*foo-bar*")
+      end
 
-    it "should sort the objects the same as the result set" do
-      ThinkingSphinx::Search.send(
-        :instances_from_results, @results, {:select => :fields}, Person
-      ).should == [@person_a, @person_b, @person_c]
-    end
-    
-    it "should run the append distances function when distance_name is passed" do
-      ThinkingSphinx::Search.stub_method(:append_distances => @results)
-      
-      ThinkingSphinx::Search.send(
-        :instances_from_results, @results, {:distance_name => 'distance'}, Person
-      )
-      
-      Person.should have_received(:find).with(
-        :all,
-        :conditions => {:id => [@person_a.id, @person_b.id, @person_c.id]},
-        :include    => nil,
-        :select     => nil
-      )
     end
-    
-    it "should have a test for the append_distances function"
   end
-  
-  describe "count method" do
-    before :each do
-      @client = Riddle::Client.stub_instance(
-        :filters    => [],
-        :filters=   => true,
-        :id_range=  => true,
-        :sort_mode  => :asc,
-        :limit      => 5,
-        :offset=    => 0,
-        :sort_mode= => true,
-        :query      => {
-          :matches  => [],
-          :total    => 50
-        }
-      )
-
-      ThinkingSphinx::Search.stub_methods(
-        :client_from_options => @client,
-        :search_conditions   => ["", []]
-      )
-    end
+end
 
-    it "should return query total" do
-      ThinkingSphinx::Search.count(42, "an_index").should == 50
-    end
-  end
-  
-  describe "search result" do
-    before :each do
-      @results = ThinkingSphinx::Search.search "nothing will match this"
-    end
-    
-    it "should respond to previous_page" do
-      @results.should respond_to(:previous_page)
-    end
-    
-    it "should respond to next_page" do
-      @results.should respond_to(:next_page)
-    end
-    
-    it "should respond to current_page" do
-      @results.should respond_to(:current_page)
-    end
-    
-    it "should respond to total_pages" do
-      @results.should respond_to(:total_pages)
-    end
-    
-    it "should respond to total_entries" do
-      @results.should respond_to(:total_entries)
-    end
-    
-    it "should respond to offset" do
-      @results.should respond_to(:offset)
-    end
-        
-    it "should be a subclass of Array" do
-      @results.should be_kind_of(Array)
-    end
+describe ThinkingSphinx::Search, "playing nice with Search model" do
+  it "should not conflict with models called Search" do
+    lambda { Search.find(:all) }.should_not raise_error
   end
 end

data/spec/unit/thinking_sphinx_spec.rb

@@ -1,12 +1,6 @@
 require 'spec/spec_helper'
 
 describe ThinkingSphinx do
-  describe "indexed_models methods" do
-    it "should contain all the names of models that have indexes" do
-      ThinkingSphinx.indexed_models.should include("Person")
-    end
-  end
-  
   it "should define indexes by default" do
     ThinkingSphinx.define_indexes?.should be_true
   end
@@ -58,12 +52,24 @@ describe ThinkingSphinx do
   end
   
   describe "use_group_by_shortcut? method" do
-    after :each do
-      ::ActiveRecord::Base.connection.unstub_method(:select_all)
+    before :each do
+      adapter = defined?(JRUBY_VERSION) ? :JdbcAdapter : :MysqlAdapter
+      unless ::ActiveRecord::ConnectionAdapters.const_defined?(adapter)
+        pending "No MySQL"
+        return
+      end
+      
+      @connection = ::ActiveRecord::ConnectionAdapters.const_get(adapter).stub_instance(
+        :select_all => true,
+        :config => {:adapter => defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql'}
+      )
+      ::ActiveRecord::Base.stub_method(
+        :connection => @connection
+      )
     end
     
     it "should return true if no ONLY_FULL_GROUP_BY" do
-      ::ActiveRecord::Base.connection.stub_method(
+      @connection.stub_method(
         :select_all => {:a => "OTHER SETTINGS"}
       )
       
@@ -71,7 +77,7 @@ describe ThinkingSphinx do
     end
   
     it "should return true if NULL value" do
-      ::ActiveRecord::Base.connection.stub_method(
+      @connection.stub_method(
         :select_all => {:a => nil}
       )
       
@@ -79,7 +85,7 @@ describe ThinkingSphinx do
     end
   
     it "should return false if ONLY_FULL_GROUP_BY is set" do
-      ::ActiveRecord::Base.connection.stub_method(
+      @connection.stub_method(
         :select_all => {:a => "OTHER SETTINGS,ONLY_FULL_GROUP_BY,blah"}
       )
       
@@ -87,7 +93,7 @@ describe ThinkingSphinx do
     end
     
     it "should return false if ONLY_FULL_GROUP_BY is set in any of the values" do
-      ::ActiveRecord::Base.connection.stub_method(
+      @connection.stub_method(
         :select_all => {
           :a => "OTHER SETTINGS",
           :b => "ONLY_FULL_GROUP_BY"
@@ -99,21 +105,19 @@ describe ThinkingSphinx do
     
     describe "if not using MySQL" do
       before :each do
-        unless ::ActiveRecord::ConnectionAdapters.const_defined?(:PostgreSQLAdapter)
+        adapter = defined?(JRUBY_VERSION) ? :JdbcAdapter : :PostgreSQLAdapter
+        unless ::ActiveRecord::ConnectionAdapters.const_defined?(adapter)
           pending "No PostgreSQL"
           return
         end
-        @connection = ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.stub_instance(
-          :select_all => true
+        @connection = ::ActiveRecord::ConnectionAdapters.const_get(adapter).stub_instance(
+          :select_all => true,
+          :config => {:adapter => defined?(JRUBY_VERSION) ? 'jdbcpostgresql' : 'postgresql'}
         )
         ::ActiveRecord::Base.stub_method(
           :connection => @connection
         )
       end
-      
-      after :each do
-        ::ActiveRecord::Base.unstub_method(:connection)
-      end
     
       it "should return false" do
         ThinkingSphinx.use_group_by_shortcut?.should be_false

data/tasks/distribution.rb

@@ -0,0 +1,48 @@
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'thinking_sphinx'
+
+desc 'Generate documentation'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Thinking Sphinx - ActiveRecord Sphinx Plugin'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+spec = Gem::Specification.new do |s|
+  s.name              = "thinking-sphinx"
+  s.version           = ThinkingSphinx::Version::String
+  s.summary           = "A concise and easy-to-use Ruby library that connects ActiveRecord to the Sphinx search daemon, managing configuration, indexing and searching."
+  s.description       = "A concise and easy-to-use Ruby library that connects ActiveRecord to the Sphinx search daemon, managing configuration, indexing and searching."
+  s.author            = "Pat Allan"
+  s.email             = "pat@freelancing-gods.com"
+  s.homepage          = "http://ts.freelancing-gods.com"
+  s.has_rdoc          = true
+  s.rdoc_options     << "--title" << "Thinking Sphinx -- Rails/Merb Sphinx Plugin" <<
+                        "--line-numbers"
+  s.rubyforge_project = "thinking-sphinx"
+  s.test_files        = FileList["spec/**/*_spec.rb"]
+  s.files             = FileList[
+    "lib/**/*.rb",
+    "LICENCE",
+    "README",
+    "tasks/**/*.rb",
+    "tasks/**/*.rake",
+    "vendor/**/*"
+  ]
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+desc "Build gemspec file"
+task :build do
+  File.open('thinking-sphinx.gemspec', 'w') { |f| f.write spec.to_ruby }
+end

data/tasks/rails.rake

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), '/../lib/thinking_sphinx/tasks')

data/tasks/testing.rb

@@ -0,0 +1,86 @@
+require 'rubygems'
+require 'spec/rake/spectask'
+require 'cucumber/rake/task'
+
+desc "Run the specs under spec"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts << "-c"
+end
+
+desc "Run all feature-set configurations"
+task :features do |t|
+  puts   "rake features:mysql"
+  system "rake features:mysql"
+  puts   "rake features:postgresql"
+  system "rake features:postgresql"
+end
+
+namespace :features do
+  def add_task(name, description)
+    Cucumber::Rake::Task.new(name, description) do |t|
+      t.cucumber_opts = "--format pretty"
+      t.step_pattern  = [
+        "features/support/env",
+        "features/support/db/#{name}",
+        "features/support/db/active_record",
+        "features/support/post_database",
+        "features/step_definitions/**.rb"
+      ]
+    end
+  end
+  
+  add_task :mysql,      "Run feature-set against MySQL"
+  add_task :postgresql, "Run feature-set against PostgreSQL"
+end
+
+desc "Generate RCov reports"
+Spec::Rake::SpecTask.new(:rcov) do |t|
+  t.libs << 'lib'
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec', '--exclude', 'gems', '--exclude', 'riddle']
+end
+
+namespace :rcov do
+  def add_task(name, description)
+    Cucumber::Rake::Task.new(name, description) do |t|
+      t.cucumber_opts = "--format pretty"
+      t.step_pattern  = [
+        "features/support/env",
+        "features/support/db/#{name}",
+        "features/support/db/active_record",
+        "features/support/post_database",
+        "features/step_definitions/**.rb"
+      ]
+      t.rcov = true
+      t.rcov_opts = [
+        '--exclude', 'spec',
+        '--exclude', 'gems',
+        '--exclude', 'riddle',
+        '--exclude', 'features'
+      ]
+    end
+  end
+  
+  add_task :mysql,      "Run feature-set against MySQL with rcov"
+  add_task :postgresql, "Run feature-set against PostgreSQL with rcov"
+end
+
+desc "Build cucumber.yml file"
+task :cucumber_defaults do
+  default_requires = %w(
+    --require features/support/env.rb
+    --require features/support/db/mysql.rb
+    --require features/support/db/active_record.rb
+    --require features/support/post_database.rb
+  ).join(" ")
+  
+  step_definitions = FileList["features/step_definitions/**.rb"].collect { |path|
+    "--require #{path}"
+  }.join(" ")
+  
+  File.open('cucumber.yml', 'w') { |f|
+    f.write "default: \"#{default_requires} #{step_definitions}\""
+  }
+end