skalee-thinking-sphinx 1.3.14.1

data/features/sphinx_detection.feature

@@ -0,0 +1,25 @@
+Feature: Checking whether Sphinx is running or not
+  In order to avoid unnecessary errors
+  Thinking Sphinx
+  Should be able to determine whether Sphinx is running or not
+  
+  Scenario: Checking Sphinx's status
+    Given Sphinx is running
+    Then Sphinx should be running
+    
+    When I stop Sphinx
+    And I wait for Sphinx to catch up
+    Then Sphinx should not be running
+    
+    When I start Sphinx
+    And I wait for Sphinx to catch up
+    Then Sphinx should be running
+    
+    Given Sphinx is running
+    When I kill the Sphinx process
+    And I wait for Sphinx to catch up
+    Then Sphinx should not be running
+    
+    When I start Sphinx again
+    And I wait for Sphinx to catch up
+    Then Sphinx should be running again

data/features/sphinx_scopes.feature

@@ -0,0 +1,42 @@
+Feature: Sphinx Scopes
+
+  Scenario: Single Scope
+    Given Sphinx is running
+    And I am searching on people
+    When I use the with_first_name scope set to "Andrew"
+    Then I should get 7 results
+
+  Scenario: Two Field Scopes
+    Given Sphinx is running
+    And I am searching on people
+    When I use the with_first_name scope set to "Andrew"
+    And I use the with_last_name scope set to "Byrne"
+    Then I should get 1 result
+
+  Scenario: Mixing Filter and Field Scopes
+    Given Sphinx is running
+    And I am searching on people
+    When I use the with_first_name scope set to "Andrew"
+    And I use the with_id scope set to 99
+    Then I should get 1 result
+  
+  Scenario: Mixing Field and ID Scopes
+    Given Sphinx is running
+    And I am searching on people
+    When I use the with_first_name scope set to "Andrew"
+    And I use the ids_only scope
+    Then I should get 7 results
+    And I should have an array of integers
+  
+  Scenario: Non-field/filter Scopes
+    Given Sphinx is running
+    And I am searching on people
+    When I use the ids_only scope
+    Then I should have an array of integers
+  
+  Scenario: Counts with scopes
+    Given Sphinx is running
+    And I am searching on people
+    When I use the with_first_name scope set to "Andrew"
+    And I am retrieving the scoped result count
+    Then I should get a value of 7

data/features/step_definitions/alpha_steps.rb

@@ -0,0 +1,16 @@
+When /^I create a new alpha named (\w+)$/ do |name|
+  Alpha.create!(:name => name, :value => 101)
+end
+
+When /^I change the (\w+) of alpha (\w+) to (\w+)$/ do |column, name, replacement|
+  Alpha.find_by_name(name).update_attributes(column.to_sym => replacement)
+end
+
+When /^I filter by active alphas$/ do
+  @results = nil
+  @with[:active] = true
+end
+
+When /^I flag alpha (\w+) as inactive$/ do |name|
+  Alpha.find_by_name(name).update_attributes(:active => false)
+end

data/features/step_definitions/beta_steps.rb

@@ -0,0 +1,7 @@
+When /^I create a new beta named (\w+)$/ do |name|
+  Beta.create!(:name => name, :value => 101)
+end
+
+When /^I change the (\w+) of beta (\w+) to (\w+)$/ do |column, name, replacement|
+  Beta.find_by_name(name).update_attributes(column.to_sym => replacement)
+end

data/features/step_definitions/common_steps.rb

@@ -0,0 +1,188 @@
+Before do
+  $queries_executed = []
+  
+  @model      = nil
+  @method     = :search
+  @query      = ""
+  @conditions = {}
+  @with       = {}
+  @without    = {}
+  @with_all   = {}
+  @options    = {}
+  @results    = nil
+  
+  Given "updates are enabled"
+end
+
+Given /^I am searching on (.+)$/ do |model|
+  @model = model.gsub(/\s/, '_').singularize.camelize.constantize
+end
+
+Given /^updates are (\w+)$/ do |action|
+  ThinkingSphinx.updates_enabled = (action == "enabled")
+end
+
+When /^I am searching for ids$/ do
+  @results = nil
+  @method = :search_for_ids
+end
+
+When /^I use index (.+)$/ do |index|
+  @results = nil
+  @options[:index] = index
+end
+
+When /^I am retrieving the result count$/ do
+  @result = nil
+  @method = @model ? :search_count : :count
+end
+
+When /^I search$/ do
+  @results = nil
+end
+
+When /^I search for (\w+)$/ do |query|
+  @results = nil
+  @query = query
+end
+
+When /^I search for "([^\"]*)"$/ do |query|
+  @results = nil
+  @query = query
+end
+
+When /^I search for (\w+) on (\w+)$/ do |query, field|
+  @results = nil
+  @conditions[field.to_sym] = query
+end
+
+When /^I output the raw result data$/ do
+  puts results.results.inspect
+end
+
+When /^I clear existing filters$/ do
+  @with     = {}
+  @without  = {}
+  @with_all = {}
+end
+
+When /^I filter by (\w+) on (\w+)$/ do |filter, attribute|
+  @results = nil
+  @with[attribute.to_sym] = filter.to_i
+end
+
+When /^I filter by (\d+) and (\d+) on (\w+)$/ do |value_one, value_two, attribute|
+  @results = nil
+  @with[attribute.to_sym] = [value_one.to_i, value_two.to_i]
+end
+
+When /^I filter by both (\d+) and (\d+) on (\w+)$/ do |value_one, value_two, attribute|
+  @results = nil
+  @with_all[attribute.to_sym] = [value_one.to_i, value_two.to_i]
+end
+
+When /^I filter between ([\d\.]+) and ([\d\.]+) on (\w+)$/ do |first, last, attribute|
+  @results = nil
+  if first[/\./].nil? && last[/\./].nil?
+    @with[attribute.to_sym] = first.to_i..last.to_i
+  else
+    @with[attribute.to_sym] = first.to_f..last.to_f
+  end
+end
+
+When /^I filter between (\d+) and (\d+) days ago on (\w+)$/ do |last, first, attribute|
+  @results = nil
+  @with[attribute.to_sym] = first.to_i.days.ago..last.to_i.days.ago
+end
+
+When /^I filter by (\w+) between (\d+) and (\d+)$/ do |attribute, first, last|
+  @results = nil
+  @with[attribute.to_sym] = Time.utc(first.to_i)..Time.utc(last.to_i)
+end
+
+When /^I order by (\w+)$/ do |attribute|
+  @results = nil
+  @options[:order] = attribute.to_sym
+end
+
+When /^I order by "([^\"]+)"$/ do |str|
+  @results = nil
+  @options[:order] = str
+end
+
+When /^I group results by the (\w+) attribute$/ do |attribute|
+  @results = nil
+  @options[:group_function] = :attr
+  @options[:group_by]       = attribute
+end
+
+When /^I set match mode to (\w+)$/ do |match_mode|
+  @results = nil
+  @options[:match_mode] = match_mode.to_sym
+end
+
+When /^I set per page to (\d+)$/ do |per_page|
+  @results = nil
+  @options[:per_page] = per_page.to_i
+end
+
+When /^I set retry stale to (\w+)$/ do |retry_stale|
+  @results = nil
+  @options[:retry_stale] = case retry_stale
+  when "true"  then true
+  when "false" then false
+  else retry_stale.to_i
+  end
+end
+
+When /^I destroy (\w+) (\w+)$/ do |model, name|
+  model.gsub(/\s/, '_').camelize.
+    constantize.find_by_name(name).destroy
+end
+
+Then /^the (\w+) of each result should indicate order$/ do |attribute|
+  results.inject(nil) do |prev, current|
+    unless prev.nil?
+      current.send(attribute.to_sym).should >= prev.send(attribute.to_sym)
+    end
+    
+    current
+  end
+end
+
+Then /^I can iterate by result and (\w+)$/ do |attribute|
+  iteration = lambda { |result, attr_value|
+    result.should be_kind_of(@model)
+    unless attribute == "group" && attr_value.nil?
+      attr_value.should be_kind_of(Integer)
+    end
+  }
+  
+  results.send("each_with_#{attribute}", &iteration)
+end
+
+Then /^I should get (\d+) results?$/ do |count|
+  results.length.should == count.to_i
+end
+
+Then /^I should not get (\d+) results?$/ do |count|
+  results.length.should_not == count.to_i
+end
+
+Then /^I should get as many results as there are (.+)$/ do |model|
+  results.length.should == model.gsub(/\s/, '_').singularize.camelize.
+    constantize.count
+end
+
+def results
+  @results ||= (@model || ThinkingSphinx).send(
+    @method,
+    @query,
+    @options.merge(
+      :conditions => @conditions,
+      :with       => @with,
+      :without    => @without,
+      :with_all   => @with_all
+    )
+  )
+end

data/features/step_definitions/extensible_delta_indexing_steps.rb

@@ -0,0 +1,7 @@
+When /I change the name of extensible beta (\w+) to (\w+)$/ do |current, replacement|
+  ExtensibleBeta.find_by_name(current).update_attributes(:name => replacement)
+end
+
+Then /^the generic delta handler should handle the delta indexing$/ do
+  ExtensibleBeta.find(:first, :conditions => {:changed_by_generic => true}).should_not be_nil
+end

data/features/step_definitions/facet_steps.rb

@@ -0,0 +1,96 @@
+When /^I am requesting facet results$/ do
+  @results = nil
+  @method  = :facets
+end
+
+When /^I am requesting just the facet (\w+)$/ do |facet|
+  @results = nil
+  @options[:facets] = facet.downcase.to_sym
+end
+
+When /^I am requesting just the facets (\w+) and (\w+)$/ do |one, two|
+  @results = nil
+  @options[:facets] = [one.downcase.to_sym, two.downcase.to_sym]
+end
+
+When "I want classes included" do
+  @options[:class_facet] = true
+end
+
+When "I don't want classes included" do
+  @options[:class_facet] = false
+end
+
+When "I want all possible attributes" do
+  @options[:all_facets] = true
+end
+
+When /^I drill down where (\w+) is (\w+)$/ do |facet, value|
+  @results = results.for(facet.downcase.to_sym => value)
+end
+
+When /^I drill down where (\w+) is (\w+) and (\w+) is (\w+)$/ do |facet_one, value_one, facet_two, value_two|
+  value_one = value_one.to_i unless value_one[/^\d+$/].nil?
+  value_two = value_two.to_i unless value_two[/^\d+$/].nil?
+  
+  @results = results.for(
+    facet_one.downcase.to_sym => value_one,
+    facet_two.downcase.to_sym => value_two
+  )
+end
+
+When /^I drill down where ([\w_]+) includes the id of tag (\w+)$/ do |facet, text|
+  tag = Tag.find_by_text(text)
+  @results = results.for(facet.downcase.to_sym => tag.id)
+end
+
+When /^I drill down where ([\w_]+) includes the id of tags (\w+) or (\w+)$/ do |facet, text_one, text_two|
+  tag_one = Tag.find_by_text(text_one)
+  tag_two = Tag.find_by_text(text_two)
+  @results = results.for(facet.downcase.to_sym => [tag_one.id, tag_two.id])
+end
+
+Then "I should have valid facet results" do
+  results.should be_kind_of(Hash)
+  results.values.each { |value| value.should be_kind_of(Hash) }
+end
+
+Then /^I should have (\d+) facets?$/ do |count|
+  results.keys.length.should == count.to_i
+end
+
+Then /^I should have the facet ([\w_\s]+)$/ do |name|
+  results[facet_name(name)].should be_kind_of(Hash)
+end
+
+Then /^I should not have the facet ([\w_\s]+)$/ do |name|
+  results.keys.should_not include(facet_name(name))
+end
+
+Then /^the ([\w_\s]+) facet should have an? "([\w\s_]+)" key with (\d+) hits$/ do |name, key, hit_count|
+  facet_name = facet_name name
+  results[facet_name].keys.should include(key)
+  results[facet_name][key].should eql(hit_count.to_i)
+end
+
+Then /^the ([\w_\s]+) facet should have an? "(\w+)" key$/ do |name, key|
+  results[facet_name(name)].keys.should include(key)
+end
+
+Then /^the ([\w_\s]+) facet should have an? (\d+\.?\d*) key$/ do |name, key|
+  if key[/\./]
+    key = key.to_f
+  else
+    key = key.to_i
+  end
+  
+  results[facet_name(name)].keys.should include(key)
+end
+
+Then /^the ([\w\s]+) facet should have (\d+) keys$/ do |name, count|
+  results[facet_name(name)].keys.length.should == count.to_i
+end
+
+def facet_name(string)
+  string.gsub(/\s/, '').underscore.to_sym
+end

data/features/step_definitions/find_arguments_steps.rb

@@ -0,0 +1,36 @@
+When "I include comments" do
+  @results = nil
+  @options[:include] = :comments
+end
+
+When /^I get the first comment$/ do
+  @comment = Comment.find(:first)
+end
+
+When /^I track queries$/ do
+  $queries_executed = []
+end
+
+When /^I compare comments$/ do
+  results.first.comments.first.should == @comment
+end
+
+When /^I select only content$/ do
+  @results = nil
+  @options[:select] = "id, content"
+end
+
+Then /^I should have (\d+) quer[yies]+$/ do |count|
+  $queries_executed.length.should == count.to_i
+end
+
+Then /^I should not get an error accessing the subject$/ do
+  lambda { results.first.subject }.should_not raise_error
+end
+
+Then /^I should get an error accessing the subject$/ do
+  error_class = NoMethodError
+  error_class = ActiveRecord::MissingAttributeError if ActiveRecord.constants.include?("MissingAttributeError")
+  
+  lambda { results.first.subject }.should raise_error(error_class)
+end

data/features/step_definitions/gamma_steps.rb

@@ -0,0 +1,15 @@
+When /^I destroy gamma (\w+) without callbacks$/ do |name|
+  @results = nil
+  gamma = Gamma.find_by_name(name)
+  Gamma.delete(gamma.id) if gamma
+end
+
+Then "I should get a single result of nil" do
+  results.to_a.should == [nil]
+end
+
+Then /^I should get a single gamma result with a name of (\w+)$/ do |name|
+  results.length.should == 1
+  results.first.should be_a(Gamma)
+  results.first.name.should == name
+end

data/features/step_definitions/scope_steps.rb

@@ -0,0 +1,15 @@
+When /^I use the ([\w]+) scope$/ do |scope|
+  @results = results.send(scope.to_sym)
+end
+
+When /^I use the ([\w]+) scope set to "([^\"]*)"$/ do |scope, value|
+  @results = results.send(scope.to_sym, value)
+end
+
+When /^I use the ([\w]+) scope set to (\d+)$/ do |scope, int|
+  @results = results.send(scope.to_sym, int.to_i)
+end
+
+When /^I am retrieving the scoped result count$/ do
+  @results = results.search_count
+end

data/features/step_definitions/search_steps.rb

@@ -0,0 +1,89 @@
+# encoding: UTF-8
+When /^I search for the specific id of (\d+) in the (\w+) index$/ do |id, index|
+  @id     = id.to_i
+  @index  = index
+end
+
+When /^I search for the document id of (\w+) (\w+) in the (\w+) index$/ do |model, name, index|
+  model   = model.gsub(/\s/, '_').camelize.constantize
+  @id     = model.find_by_name(name).sphinx_document_id
+  @index  = index
+end
+
+Then "it should exist" do
+  ThinkingSphinx::Search.search_for_id(@id, @index).should == true
+end
+
+Then "it should not exist" do
+  ThinkingSphinx::Search.search_for_id(@id, @index).should == false
+end
+
+Then "it should exist if using Rails 2.1 or newer" do
+  require 'active_record/version'
+  unless ActiveRecord::VERSION::STRING.to_f < 2.1
+    ThinkingSphinx::Search.search_for_id(@id, @index).should == true
+  end
+end
+
+Then "it should not exist if using Rails 2.1 or newer" do
+  require 'active_record/version'
+  unless ActiveRecord::VERSION::STRING.to_f < 2.1
+    ThinkingSphinx::Search.search_for_id(@id, @index).should == false
+  end
+end
+
+Then /^I can iterate by result and group and count$/ do
+  results.each_with_groupby_and_count do |result, group, count|
+    result.should be_kind_of(@model)
+    count.should  be_kind_of(Integer)
+    group.should  be_kind_of(Integer)
+  end
+end
+
+Then "each result id should match the corresponding sphinx internal id" do
+  results.each_with_sphinx_internal_id do |result, id|
+    result.id.should == id
+  end
+end
+
+Then "I should have an array of integers" do
+  results.each do |result|
+    result.should be_kind_of(Integer)
+  end
+end
+
+Then "searching for ids should match the record ids of the normal search results" do
+  normal_results = results
+  
+  # reset search, switch method
+  @results = nil
+  @method  = :search_for_ids
+  
+  results.to_a.should == normal_results.collect(&:id)
+end
+
+Then /^I should get a value of (\d+)$/ do |count|
+  results.should == count.to_i
+end
+
+Then /^the (\w+) excerpt of the first result is "(.*)"$/ do |column, string|
+  excerpt = results.excerpt_for(results.first.send(column))
+  if excerpt.respond_to?(:force_encoding)
+    excerpt = excerpt.force_encoding('UTF-8')
+  end
+  
+  excerpt.should == string
+end
+
+Then /^calling (\w+) on the first result excerpts object should return "(.*)"$/ do |column, string|
+  excerpt = results.first.excerpts.send(column)
+  if excerpt.respond_to?(:force_encoding)
+    excerpt = excerpt.force_encoding('UTF-8')
+  end
+  
+  excerpt.should == string
+end
+
+Then /^the first result should have a (\w+\s?\w*) of (\d+)$/ do |attribute, value|
+  results.first.sphinx_attributes[attribute.gsub(/\s+/, '_')].should == value.to_i
+end

data/features/step_definitions/sphinx_steps.rb

@@ -0,0 +1,35 @@
+Given "Sphinx is running" do
+  ThinkingSphinx::Configuration.instance.controller.should be_running
+end
+
+When "I kill the Sphinx process" do
+  Process.kill(9, ThinkingSphinx.sphinx_pid.to_i)
+end
+
+When "I wait for Sphinx to catch up" do
+  sleep(0.25)
+end
+
+When /^I start Sphinx/ do
+  ThinkingSphinx::Configuration.instance.controller.start
+end
+
+When "I stop Sphinx" do
+  ThinkingSphinx::Configuration.instance.controller.stop
+end
+
+When /^I (enable|disable) delta updates$/ do |mode|
+  ThinkingSphinx.deltas_enabled = (mode == 'enable')
+end
+
+When /^I process the (\w+) index$/ do |index|
+  ThinkingSphinx::Configuration.instance.controller.index index
+end
+
+Then /^Sphinx should be running/ do
+  ThinkingSphinx.sphinx_running?.should be_true
+end
+
+Then "Sphinx should not be running" do
+  ThinkingSphinx.sphinx_running?.should be_false
+end

data/features/sti_searching.feature

@@ -0,0 +1,19 @@
+Feature: Searching via STI model relationships
+  In order to be used easy in applications with STI relationships
+  Thinking Sphinx
+  Should return expected results depending on where in the hierarchy searches are called from.
+  
+  Scenario: Searching from a parent model
+    Given Sphinx is running
+    And I am searching on animals
+    Then I should get as many results as there are animals
+  
+  Scenario: Searching from a child model
+    Given Sphinx is running
+    And I am searching on cats
+    Then I should get as many results as there are cats
+
+  Scenario: Searching across super and subclass indexes
+    Given Sphinx is running
+    When I search for "fantastic"
+    Then I should get 1 result

data/features/support/database.example.yml

@@ -0,0 +1,3 @@
+username: root
+host: localhost
+password: 

data/features/support/db/.gitignore

@@ -0,0 +1 @@
+database.yml

data/features/support/db/fixtures/alphas.rb

@@ -0,0 +1,10 @@
+Alpha.create :name => "one",    :value =>  1, :cost =>  1.51, :created_on =>  1.day.ago.to_date, :created_at =>  1.day.ago
+Alpha.create :name => "two",    :value =>  2, :cost =>  2.52, :created_on =>  2.day.ago.to_date, :created_at =>  2.day.ago
+Alpha.create :name => "three",  :value =>  3, :cost =>  3.53, :created_on =>  3.day.ago.to_date, :created_at =>  3.day.ago
+Alpha.create :name => "four",   :value =>  4, :cost =>  4.54, :created_on =>  4.day.ago.to_date, :created_at =>  4.day.ago
+Alpha.create :name => "five",   :value =>  5, :cost =>  5.55, :created_on =>  5.day.ago.to_date, :created_at =>  5.day.ago
+Alpha.create :name => "six",    :value =>  6, :cost =>  6.56, :created_on =>  6.day.ago.to_date, :created_at =>  6.day.ago
+Alpha.create :name => "seven",  :value =>  7, :cost =>  7.57, :created_on =>  7.day.ago.to_date, :created_at =>  7.day.ago
+Alpha.create :name => "eight",  :value =>  8, :cost =>  8.58, :created_on =>  8.day.ago.to_date, :created_at =>  8.day.ago
+Alpha.create :name => "nine",   :value =>  9, :cost =>  9.59, :created_on =>  9.day.ago.to_date, :created_at =>  9.day.ago
+Alpha.create :name => "ten",    :value => 10, :cost => 10.50, :created_on => 10.day.ago.to_date, :created_at => 10.day.ago

data/features/support/db/fixtures/authors.rb

@@ -0,0 +1 @@
+Author.create :name => "William Shakespeare"

data/features/support/db/fixtures/betas.rb

@@ -0,0 +1,10 @@
+Beta.create :name => "one", :value => 1
+Beta.create :name => "two", :value => 2
+Beta.create :name => "three", :value => 3
+Beta.create :name => "four", :value => 4
+Beta.create :name => "five", :value => 5
+Beta.create :name => "six", :value => 6
+Beta.create :name => "seven", :value => 7
+Beta.create :name => "eight", :value => 8
+Beta.create :name => "nine", :value => 9
+Beta.create :name => "ten", :value => 10

data/features/support/db/fixtures/boxes.rb

@@ -0,0 +1,9 @@
+(1..10).each do |i|
+  Box.create :width => i, :length => i, :depth => i
+end
+
+(11..20).each do |i|
+  Box.create :width => i, :length => i+1, :depth => i+2
+end
+
+Box.create :width => 5, :length => 5, :depth => nil

data/features/support/db/fixtures/categories.rb

@@ -0,0 +1 @@
+Category.create :name => "hello"

data/features/support/db/fixtures/cats.rb

@@ -0,0 +1,3 @@
+%w( rogue nat molly jasper moggy ).each do |name|
+  Cat.create :name => name
+end

data/features/support/db/fixtures/comments.rb

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+Comment.create(
+  :name         => "Pat",
+  :content      => "+1",
+  :post_id      => 1,
+  :category_id  => 1
+).update_attribute(:created_at, Time.utc(2001, 01, 01))
+
+Comment.create(
+  :name         => "Menno",
+  :content      => "Second post!",
+  :post_id      => 1,
+  :category_id  => 1
+)
+
+Comment.create :name => 'A', :post_id => 1, :content => 'Es un hecho establecido hace demasiado tiempo que un lector se distraerá con el contenido del texto', :category_id => 1
+Comment.create :name => 'B', :post_id => 1, :content => 'de un sitio mientras que mira su diseño. El punto de usar Lorem Ipsum es que tiene una distribución', :category_id => 1
+Comment.create :name => 'C', :post_id => 1, :content => 'más o menos normal de las letras, al contrario de usar textos como por ejemplo "Contenido aquí', :category_id => 1
+Comment.create :name => 'D', :post_id => 1, :content => 'contenido aquí". Estos textos hacen parecerlo un español que se puede leer. Muchos paquetes de', :category_id => 1
+Comment.create :name => 'E', :post_id => 1, :content => 'autoedición y editores de páginas web usan el Lorem Ipsum como su texto por defecto, y al hacer una', :category_id => 1
+Comment.create :name => 'F', :post_id => 1, :content => 'búsqueda de "Lorem Ipsum" va a dar por resultado muchos sitios web que usan este texto si se', :category_id => 1
+
+# The one we'll really want to find via Sphinx search
+Comment.create :name => 'G', :post_id => 1, :content => 'Turtle', :category_id => 1