thinking-sphinx 2.1.0 → 3.0.0.pre

data/spec/thinking_sphinx/auto_version_spec.rb

@@ -1,103 +0,0 @@
-require 'spec_helper'
-
-describe ThinkingSphinx::AutoVersion do
-  describe '.detect' do
-    before :each do
-      @config = ThinkingSphinx::Configuration.instance
-    end
-
-    it "should require 0.9.8 if that is the detected version" do
-      ThinkingSphinx::AutoVersion.should_receive(:require).
-        with('riddle/0.9.8')
-
-      @config.stub!(:version => '0.9.8')
-      ThinkingSphinx::AutoVersion.detect
-    end
-
-    it "should require 0.9.9 if that is the detected version" do
-      ThinkingSphinx::AutoVersion.should_receive(:require).
-        with('riddle/0.9.9')
-
-      @config.stub!(:version => '0.9.9')
-      ThinkingSphinx::AutoVersion.detect
-    end
-
-    it "should require 1.10-beta if that is the detected version" do
-      ThinkingSphinx::AutoVersion.should_receive(:require).
-        with('riddle/1.10')
-
-      @config.stub!(:version => '1.10-beta')
-      ThinkingSphinx::AutoVersion.detect
-    end
-
-    it "should require 1.10-beta if using 1.10-beta compiled with id64 support" do
-      ThinkingSphinx::AutoVersion.should_receive(:require).
-        with('riddle/1.10')
-
-      @config.stub!(:version => '1.10-id64-beta')
-      ThinkingSphinx::AutoVersion.detect
-    end
-
-    it "should require 2.0.1 if using Sphinx 2.0.1 beta" do
-      ThinkingSphinx::AutoVersion.should_receive(:require).
-        with('riddle/2.0.1')
-
-      @config.stub!(:version => '2.0.1-beta')
-      ThinkingSphinx::AutoVersion.detect
-    end
-
-    it "should require 2.0.1 if using Sphinx 2.0.2 dev" do
-      ThinkingSphinx::AutoVersion.should_receive(:require).
-        with('riddle/2.0.1')
-
-      @config.stub!(:version => '2.0.2-dev')
-      ThinkingSphinx::AutoVersion.detect
-    end
-
-    it "should require 2.1.0 if using Sphinx 2.0.3" do
-      ThinkingSphinx::AutoVersion.should_receive(:require).
-        with('riddle/2.1.0')
-
-      @config.stub!(:version => '2.0.3-release')
-      ThinkingSphinx::AutoVersion.detect
-    end
-
-    it "should require 2.1.0 if using Sphinx 2.0.3" do
-      ThinkingSphinx::AutoVersion.should_receive(:require).
-        with('riddle/2.1.0')
-
-      @config.stub!(:version => '2.0.4-release')
-      ThinkingSphinx::AutoVersion.detect
-    end
-
-    it "should require 2.1.0 if using Sphinx 2.0.3" do
-      ThinkingSphinx::AutoVersion.should_receive(:require).
-        with('riddle/2.1.0')
-
-      @config.stub!(:version => '2.0.5-release')
-      ThinkingSphinx::AutoVersion.detect
-    end
-
-    it "should require 2.1.0 if using Sphinx 2.1.0 dev" do
-      ThinkingSphinx::AutoVersion.should_receive(:require).
-        with('riddle/2.1.0')
-
-      @config.stub!(:version => '2.1.0-dev')
-      ThinkingSphinx::AutoVersion.detect
-    end
-
-    it "should output a warning if the detected version is unsupported" do
-      STDERR.should_receive(:puts).with(/unsupported/i)
-
-      @config.stub!(:version => '0.9.7')
-      ThinkingSphinx::AutoVersion.detect
-    end
-
-    it "should output a warning if the version cannot be determined" do
-      STDERR.should_receive(:puts).at_least(:once)
-
-      @config.stub!(:version => nil)
-      ThinkingSphinx::AutoVersion.detect
-    end
-  end
-end

data/spec/thinking_sphinx/connection_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-
-describe ThinkingSphinx::Connection do
-  describe '#client' do
-    let(:connection) { ThinkingSphinx::Connection.new }
-
-    before :each do
-      @config = ThinkingSphinx::Configuration.instance
-      @config.address     = 'domain.url'
-      @config.port        = 3333
-      @config.configuration.searchd.max_matches = 100
-      @config.timeout = 1
-
-      pending
-    end
-
-    it "should return an instance of Riddle::Client" do
-      connection.client.should be_a(Riddle::Client)
-    end
-
-    it "should use the configuration address" do
-      connection.client.server.should == 'domain.url'
-    end
-
-    it "should use the configuration port" do
-      connection.client.port.should == 3333
-    end
-
-    it "should use the configuration max matches" do
-      connection.client.max_matches.should == 100
-    end
-
-    it "should use the configuration timeout" do
-      connection.client.timeout.should == 1
-    end
-
-    describe 'when shuffle is enabled' do
-      let(:client) { double('client', :max_matches= => nil, :timeout= => nil,
-        :open => true) }
-
-      before :each do
-        @config.shuffle = true
-      end
-
-      it "should shuffle client servers" do
-        @config.address = ['1.1.1.1', '2.2.2.2']
-        @config.address.stub!(:shuffle => ['2.2.2.2', '1.1.1.1'])
-
-        Riddle::Client.should_receive(:new) do |addresses, port, key|
-          addresses.should == ['2.2.2.2', '1.1.1.1']
-          client
-        end
-        connection.client
-      end
-    end
-
-    describe 'when shuffle is disabled' do
-      let(:client) { double('client', :max_matches= => nil, :timeout= => nil,
-        :open => true) }
-
-      before :each do
-        @config.shuffle = false
-      end
-
-      it "should not shuffle client servers" do
-        @config.address = ['1.1.1.1', '2.2.2.2.', '3.3.3.3', '4.4.4.4', '5.5.5.5']
-
-        @config.address.should_not_receive(:shuffle)
-        Riddle::Client.should_receive(:new) do |addresses, port, key|
-          addresses.should == ['1.1.1.1', '2.2.2.2.', '3.3.3.3', '4.4.4.4', '5.5.5.5']
-          client
-        end
-        connection.client
-      end
-    end
-  end
-end

data/spec/thinking_sphinx/context_spec.rb

@@ -1,127 +0,0 @@
-require 'spec_helper'
-
-describe ThinkingSphinx::Context do
-  let(:ts_context) { ThinkingSphinx::Context.new }
-
-  describe '#prepare' do
-    let(:config)           { ThinkingSphinx::Configuration.instance }
-    let(:file_name)        { 'a.rb' }
-    let(:model_name_lower) { 'a' }
-    let(:class_name)       { 'A' }
-
-    before :each do
-      config.model_directories = ['']
-
-      file_name.stub!(:gsub).and_return(model_name_lower)
-      model_name_lower.stub!(:camelize).and_return(class_name)
-      Dir.stub(:[]).and_return([file_name])
-    end
-
-    it "should load the files by guessing the file name" do
-      class_name.should_receive(:constantize).and_return(true)
-
-      ts_context.prepare
-    end
-
-    it "should not raise errors if the model name is nil" do
-      file_name.stub!(:gsub).and_return(nil)
-
-      lambda {
-        ts_context.prepare
-      }.should_not raise_error
-    end
-
-    it "should report name errors but not raise them" do
-      class_name.stub(:constantize).and_raise(NameError)
-      STDERR.stub!(:puts => '')
-      STDERR.should_receive(:puts).with('ThinkingSphinx: error loading a.rb')
-
-      lambda {
-        ts_context.prepare
-      }.should_not raise_error
-    end
-
-    it "should report load errors but not raise them" do
-      class_name.stub(:constantize).and_raise(LoadError)
-      STDERR.stub!(:puts => '')
-      STDERR.should_receive(:puts).with('ThinkingSphinx: error loading a.rb')
-
-      lambda {
-        ts_context.prepare
-      }.should_not raise_error
-    end
-
-    it "should catch database errors with a warning" do
-      class_name.should_receive(:constantize).and_raise(Mysql2::Error)
-      STDERR.stub!(:puts => '')
-      STDERR.should_receive(:puts).with('Warning: Error loading a.rb:')
-
-      lambda {
-        ts_context.prepare
-      }.should_not raise_error
-    end unless RUBY_PLATFORM == 'java'
-
-    it "should not load models if they're explicitly set in the configuration" do
-      config.indexed_models = ['Alpha', 'Beta']
-      ts_context.prepare
-
-      ts_context.indexed_models.should == ['Alpha', 'Beta']
-    end
-  end
-
-  describe '#define_indexes' do
-    it "should call define_indexes on all known indexed models" do
-      ts_context.stub!(:indexed_models => ['Alpha', 'Beta'])
-      Alpha.should_receive(:define_indexes)
-      Beta.should_receive(:define_indexes)
-
-      ts_context.define_indexes
-    end
-  end
-
-  describe '#add_indexed_model' do
-    before :each do
-      ts_context.indexed_models.clear
-    end
-
-    it "should add the model to the collection" do
-      ts_context.add_indexed_model 'Alpha'
-
-      ts_context.indexed_models.should == ['Alpha']
-    end
-
-    it "should not duplicate models in the collection" do
-      ts_context.add_indexed_model 'Alpha'
-      ts_context.add_indexed_model 'Alpha'
-
-      ts_context.indexed_models.should == ['Alpha']
-    end
-
-    it "should keep the collection in alphabetical order" do
-      ts_context.add_indexed_model 'Beta'
-      ts_context.add_indexed_model 'Alpha'
-
-      ts_context.indexed_models.should == ['Alpha', 'Beta']
-    end
-
-    it "should translate classes to their names" do
-      ts_context.add_indexed_model Alpha
-
-      ts_context.indexed_models.should == ['Alpha']
-    end
-  end
-
-  describe '#superclass_indexed_models' do
-    it "should return indexed model names" do
-      ts_context.stub!(:indexed_models => ['Alpha', 'Beta'])
-
-      ts_context.superclass_indexed_models.should == ['Alpha', 'Beta']
-    end
-
-    it "should not include classes which have indexed superclasses" do
-      ts_context.stub!(:indexed_models => ['Parent', 'Person'])
-
-      ts_context.superclass_indexed_models.should == ['Person']
-    end
-  end
-end

data/spec/thinking_sphinx/core/array_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe Array do
-  describe '.===' do
-    it "should return true if an instance of ThinkingSphinx::Search" do
-      Array.should === ThinkingSphinx::Search.new
-    end
-  end
-end

data/spec/thinking_sphinx/core/string_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe String do  
-  describe "to_crc32 instance method" do
-    it "should return an integer" do
-      'to_crc32'.to_crc32.should be_a_kind_of(Integer)
-    end
-  end
-end    

data/spec/thinking_sphinx/facet_spec.rb

@@ -1,359 +0,0 @@
-require 'spec_helper'
-
-describe ThinkingSphinx::Facet do
-  describe ".name_for" do
-    it "should remove '_facet' from provided string and return a symbol" do
-      ThinkingSphinx::Facet.name_for('attribute_facet').should == :attribute
-    end
-
-    it "should remove '_facet' from provided symbol" do
-      ThinkingSphinx::Facet.name_for(:attribute_facet).should == :attribute
-    end
-
-    it "should return the name of the facet if a Facet is passed" do
-      facet = ThinkingSphinx::Facet.new(
-        stub('attribute', :unique_name => :attribute, :columns => ['attribute'])
-      )
-      ThinkingSphinx::Facet.name_for(facet).should == :attribute
-    end
-
-    it "should return 'class' for special case name 'class_crc'" do
-      ThinkingSphinx::Facet.name_for(:class_crc).should == :class
-    end
-
-    it "should cycle" do
-      ThinkingSphinx::Facet.name_for(ThinkingSphinx::Facet.attribute_name_for(:attribute)).should == :attribute
-    end
-  end
-
-  describe ".attribute_name_for" do
-    it "should append '_facet' to provided string" do
-      ThinkingSphinx::Facet.attribute_name_for('attribute').should == 'attribute_facet'
-    end
-
-    it "should append '_facet' to provided symbol and return a string" do
-      ThinkingSphinx::Facet.attribute_name_for(:attribute).should == 'attribute_facet'
-    end
-
-    it "should return 'class_crc' for special case attribute 'class'" do
-      ThinkingSphinx::Facet.attribute_name_for(:class).should == 'class_crc'
-    end
-
-    it "should cycle" do
-      ThinkingSphinx::Facet.attribute_name_for(ThinkingSphinx::Facet.name_for('attribute_facet')).should == 'attribute_facet'
-    end
-  end
-  
-  describe ".attribute_name_from_value" do
-    it "should append _facet if the value is a string" do
-      ThinkingSphinx::Facet.attribute_name_from_value('attribute', 'string').
-        should == 'attribute_facet'
-    end
-    
-    it "should not append _facet if the value isn't a string" do
-      ThinkingSphinx::Facet.attribute_name_from_value('attribute', 1).
-        should == 'attribute'
-      ThinkingSphinx::Facet.attribute_name_from_value('attribute', Time.now).
-        should == 'attribute'
-      ThinkingSphinx::Facet.attribute_name_from_value('attribute', true).
-        should == 'attribute'
-      ThinkingSphinx::Facet.attribute_name_from_value('attribute', 1.23).
-        should == 'attribute'
-    end
-    
-    it "should append _facet is the value is an array of strings" do
-      ThinkingSphinx::Facet.attribute_name_from_value('attribute', ['a', 'b']).
-        should == 'attribute_facet'
-    end
-    
-    it "should not append _facet if the value is an array of integers" do
-      ThinkingSphinx::Facet.attribute_name_from_value('attribute', [1, 2]).
-        should == 'attribute'
-    end
-  end
-  
-  describe ".translate?" do
-    before :each do
-      @index     = ThinkingSphinx::Index.new(Alpha)
-      @source    = ThinkingSphinx::Source.new(@index)
-      @attribute = ThinkingSphinx::Attribute.new(
-        @source, ThinkingSphinx::Index::FauxColumn.new(:name)
-      )
-    end
-    
-    it "should return true if the property is a field" do
-      field = ThinkingSphinx::Field.new(
-        @source, ThinkingSphinx::Index::FauxColumn.new(:name)
-      )
-      
-      ThinkingSphinx::Facet.translate?(field).should be_true
-    end
-    
-    it "should return true if the property is a string attribute" do
-      @attribute.stub!(:type => :string)
-      
-      ThinkingSphinx::Facet.translate?(@attribute).should be_true
-    end
-    
-    it "should return false if the property is an integer attribute" do
-      @attribute.stub!(:type => :integer)
-      
-      ThinkingSphinx::Facet.translate?(@attribute).should be_false
-    end
-    
-    it "should return false if the property is a boolean attribute" do
-      @attribute.stub!(:type => :boolean)
-      
-      ThinkingSphinx::Facet.translate?(@attribute).should be_false
-    end
-    
-    it "should return false if the property is a timestamp attribute" do
-      @attribute.stub!(:type => :datetime)
-      
-      ThinkingSphinx::Facet.translate?(@attribute).should be_false
-    end
-    
-    it "should return false if the property is a float attribute" do
-      @attribute.stub!(:type => :float)
-      
-      ThinkingSphinx::Facet.translate?(@attribute).should be_false
-    end
-    
-    it "should return false if the property is an MVA of integer values" do
-      @attribute.stub!(:type => :multi, :all_ints? => true)
-      
-      ThinkingSphinx::Facet.translate?(@attribute).should be_false
-    end
-    
-    it "should return true if the property is an MVA of string values" do
-      @attribute.stub!(:type => :multi, :all_ints? => false)
-      
-      ThinkingSphinx::Facet.translate?(@attribute).should be_true
-    end
-  end
-  
-  describe "#translate?" do
-    before :each do
-      @index     = ThinkingSphinx::Index.new(Alpha)
-      @source    = ThinkingSphinx::Source.new(@index)
-      @attribute = ThinkingSphinx::Attribute.new(
-        @source, ThinkingSphinx::Index::FauxColumn.new(:name)
-      )
-    end
-    
-    it "should return true if the property is a field" do
-      field = ThinkingSphinx::Field.new(
-        @source, ThinkingSphinx::Index::FauxColumn.new(:name)
-      )
-      
-      ThinkingSphinx::Facet.new(field).translate?.should be_true
-    end
-    
-    it "should return true if the property is a string attribute" do
-      @attribute.stub!(:type => :string)
-      
-      ThinkingSphinx::Facet.new(@attribute).translate?.should be_true
-    end
-    
-    it "should return false if the property is an integer attribute" do
-      @attribute.stub!(:type => :integer)
-      
-      ThinkingSphinx::Facet.new(@attribute).translate?.should be_false
-    end
-    
-    it "should return false if the property is a boolean attribute" do
-      @attribute.stub!(:type => :boolean)
-      
-      ThinkingSphinx::Facet.new(@attribute).translate?.should be_false
-    end
-    
-    it "should return false if the property is a timestamp attribute" do
-      @attribute.stub!(:type => :datetime)
-      
-      ThinkingSphinx::Facet.new(@attribute).translate?.should be_false
-    end
-    
-    it "should return false if the property is a float attribute" do
-      @attribute.stub!(:type => :float)
-      
-      ThinkingSphinx::Facet.new(@attribute).translate?.should be_false
-    end
-    
-    it "should return false if the property is an MVA of integer values" do
-      @attribute.stub!(:type => :multi, :all_ints? => true)
-      
-      ThinkingSphinx::Facet.new(@attribute).translate?.should be_false
-    end
-    
-    it "should return true if the property is an MVA of string values" do
-      @attribute.stub!(:type => :multi, :all_ints? => false)
-      
-      ThinkingSphinx::Facet.new(@attribute).translate?.should be_true
-    end
-  end
-  
-  describe "#attribute_name" do
-    before :each do
-      @index     = ThinkingSphinx::Index.new(Alpha)
-      @source    = ThinkingSphinx::Source.new(@index)
-      @attribute = ThinkingSphinx::Attribute.new(
-        @source, ThinkingSphinx::Index::FauxColumn.new(:name)
-      )
-    end
-    
-    it "should return the attribute name if built off an integer attribute" do
-      @attribute.stub!(:type => :integer)
-      
-      ThinkingSphinx::Facet.new(@attribute).attribute_name.should == "name"
-    end
-    
-    it "should return the attribute name if built off a boolean attribute" do
-      @attribute.stub!(:type => :boolean)
-      
-      ThinkingSphinx::Facet.new(@attribute).attribute_name.should == "name"
-    end
-    
-    it "should return the attribute name if built off a float attribute" do
-      @attribute.stub!(:type => :float)
-      
-      ThinkingSphinx::Facet.new(@attribute).attribute_name.should == "name"
-    end
-    
-    it "should return the attribute name if built off a timestamp attribute" do
-      @attribute.stub!(:type => :datetime)
-      
-      ThinkingSphinx::Facet.new(@attribute).attribute_name.should == "name"
-    end
-    
-    it "should return the attribute name with _facet suffix if built off a string attribute" do
-      @attribute.stub!(:type => :string)
-      
-      ThinkingSphinx::Facet.new(@attribute).attribute_name.should == "name_facet"
-    end
-    
-    it "should return the attribute name with _facet suffix if built off a field" do
-      field = ThinkingSphinx::Field.new(
-        @source, ThinkingSphinx::Index::FauxColumn.new(:name)
-      )
-      
-      ThinkingSphinx::Facet.new(field).attribute_name.should == "name_facet"
-    end
-    
-    it "should return the attribute name if build off an integer MVA" do
-      @attribute.stub!(:type => :multi, :all_ints? => true)
-      
-      ThinkingSphinx::Facet.new(@attribute).attribute_name.should == "name"
-    end
-    
-    it "should return the attribute name with the _facet suffix if build off an non-integer MVA" do
-      @attribute.stub!(:type => :multi, :all_ints? => false)
-      
-      ThinkingSphinx::Facet.new(@attribute).attribute_name.should == "name_facet"
-    end
-  end
-  
-  describe "#type" do
-    before :each do
-      @index     = ThinkingSphinx::Index.new(Alpha)
-      @source    = ThinkingSphinx::Source.new(@index)
-    end
-    
-    it "should return :string if the property is a field" do
-      field = ThinkingSphinx::Field.new(
-        @source, ThinkingSphinx::Index::FauxColumn.new(:name)
-      )
-      
-      ThinkingSphinx::Facet.new(field).type.should == :string
-    end
-    
-    it "should return the attribute type if the property is an attribute" do
-      attribute = ThinkingSphinx::Attribute.new(
-        @source, ThinkingSphinx::Index::FauxColumn.new(:name)
-      )
-      attribute.stub!(:type => :anything)
-      
-      ThinkingSphinx::Facet.new(attribute).type.should == :anything
-    end
-  end
-  
-  describe "#value" do
-    describe 'for fields from associations' do
-      before :each do
-        @index  = ThinkingSphinx::Index.new(Friendship)
-        @source = ThinkingSphinx::Source.new(@index)
-        @field  = ThinkingSphinx::Field.new(
-          @source, ThinkingSphinx::Index::FauxColumn.new(:person, :first_name)
-        )
-        @facet  = ThinkingSphinx::Facet.new(@field)
-      end
-    
-      it "should return association values" do
-        person      = Person.find(:first)
-        friendship  = Friendship.new(:person => person)
-      
-        @facet.value(friendship, {'first_name_facet' => 1}).should == person.first_name
-      end
-    
-      it "should return nil if the association is nil" do
-        friendship = Friendship.new(:person => nil)
-      
-        @facet.value(friendship, {'first_name_facet' => 1}).should be_nil
-      end
-      
-      it "should return multi-level association values" do
-        person      = Person.find(:first)
-        tag         = person.tags.build(:name => 'buried')
-        friendship  = Friendship.new(:person => person)
-        
-        field  = ThinkingSphinx::Field.new(
-          @source, ThinkingSphinx::Index::FauxColumn.new(:person, :tags, :name)
-        )
-        ThinkingSphinx::Facet.new(field).value(friendship, {'name_facet' => 'buried'.to_crc32}).
-          should == 'buried'
-      end
-      
-      it "should not error with multi-level association values containing a nil value" do
-        person      = Person.find(:first)
-        tag         = person.tags.build(:name => nil)
-        tag         = person.tags.build(:name => "buried")
-        friendship  = Friendship.new(:person => person)
-        
-        field  = ThinkingSphinx::Field.new(
-          @source, ThinkingSphinx::Index::FauxColumn.new(:person, :tags, :name)
-        )
-        lambda{ThinkingSphinx::Facet.new(field).value(friendship, {'name_facet' => 'buried'.to_crc32})}.should_not raise_error
-      end
-    end
-    
-    describe 'for float attributes' do
-      before :each do
-        @index     = ThinkingSphinx::Index.new(Alpha)
-        @source    = ThinkingSphinx::Source.new(@index)
-        @attribute = ThinkingSphinx::Attribute.new(
-          @source, ThinkingSphinx::Index::FauxColumn.new(:cost)
-        )
-        @facet     = ThinkingSphinx::Facet.new(@attribute)
-      end
-      
-      it "should translate using the given model" do
-        alpha = Alpha.new(:cost => 10.5)
-      
-        @facet.value(alpha, {'cost' => 1093140480}).should == 10.5
-      end
-    end
-    
-    context 'manual value source' do
-      let(:index)  { ThinkingSphinx::Index.new(Alpha) }
-      let(:source) { ThinkingSphinx::Source.new(index) }
-      let(:column) { ThinkingSphinx::Index::FauxColumn.new('LOWER(name)') }
-      let(:field)  { ThinkingSphinx::Field.new(source, column) }
-      let(:facet)  { ThinkingSphinx::Facet.new(field, :name) }
-      
-      it "should use the given value source to figure out the value" do
-        alpha = Alpha.new(:name => 'Foo')
-        
-        facet.value(alpha, {'foo_facet' => 'foo'.to_crc32}).should == 'Foo'
-      end
-    end
-  end
-end