thinking-sphinx 1.2.13 → 6.0.0

data/lib/thinking_sphinx/source/sql.rb

@@ -1,128 +0,0 @@
-module ThinkingSphinx
-  class Source
-    module SQL
-      # Generates the big SQL statement to get the data back for all the fields
-      # and attributes, using all the relevant association joins. If you want
-      # the version filtered for delta values, send through :delta => true in the
-      # options. Won't do much though if the index isn't set up to support a
-      # delta sibling.
-      # 
-      # Examples:
-      # 
-      #   source.to_sql
-      #   source.to_sql(:delta => true)
-      #
-      def to_sql(options={})
-        sql = <<-SQL
-SELECT #{ sql_select_clause options[:offset] }
-FROM #{ @model.quoted_table_name }
-  #{ all_associations.collect { |assoc| assoc.to_sql }.join(' ') }
-#{ sql_where_clause(options) }
-GROUP BY #{ sql_group_clause }
-        SQL
-
-        sql += " ORDER BY NULL" if adapter.sphinx_identifier == "mysql"
-        sql
-      end
-
-      # Simple helper method for the query range SQL - which is a statement that
-      # returns minimum and maximum id values. These can be filtered by delta -
-      # so pass in :delta => true to get the delta version of the SQL.
-      # 
-      def to_sql_query_range(options={})
-        return nil if @index.options[:disable_range]
-        
-        min_statement = adapter.convert_nulls(
-          "MIN(#{quote_column(@model.primary_key_for_sphinx)})", 1
-        )
-        max_statement = adapter.convert_nulls(
-          "MAX(#{quote_column(@model.primary_key_for_sphinx)})", 1
-        )
-
-        sql = "SELECT #{min_statement}, #{max_statement} " +
-              "FROM #{@model.quoted_table_name} "
-        if self.delta? && !@index.delta_object.clause(@model, options[:delta]).blank?
-          sql << "WHERE #{@index.delta_object.clause(@model, options[:delta])}"
-        end
-
-        sql
-      end
-
-      # Simple helper method for the query info SQL - which is a statement that
-      # returns the single row for a corresponding id.
-      # 
-      def to_sql_query_info(offset)
-        "SELECT * FROM #{@model.quoted_table_name} WHERE " +
-        "#{quote_column(@model.primary_key_for_sphinx)} = (($id - #{offset}) / #{ThinkingSphinx.indexed_models.size})"
-      end
-
-      def sql_select_clause(offset)
-        unique_id_expr = ThinkingSphinx.unique_id_expression(offset)
-
-        (
-          ["#{@model.quoted_table_name}.#{quote_column(@model.primary_key_for_sphinx)} #{unique_id_expr} AS #{quote_column(@model.primary_key_for_sphinx)} "] + 
-          @fields.collect     { |field|     field.to_select_sql     } +
-          @attributes.collect { |attribute| attribute.to_select_sql }
-        ).compact.join(", ")
-      end
-
-      def sql_where_clause(options)
-        logic = []
-        logic += [
-          "#{@model.quoted_table_name}.#{quote_column(@model.primary_key_for_sphinx)} >= $start",
-          "#{@model.quoted_table_name}.#{quote_column(@model.primary_key_for_sphinx)} <= $end"
-        ] unless @index.options[:disable_range]
-
-        if self.delta? && !@index.delta_object.clause(@model, options[:delta]).blank?
-          logic << "#{@index.delta_object.clause(@model, options[:delta])}"
-        end
-
-        logic += (@conditions || [])
-        logic.empty? ? "" : "WHERE #{logic.join(' AND ')}"
-      end
-
-      def sql_group_clause
-        internal_groupings = []
-        if @model.column_names.include?(@model.inheritance_column)
-           internal_groupings << "#{@model.quoted_table_name}.#{quote_column(@model.inheritance_column)}"
-        end
-
-        (
-          ["#{@model.quoted_table_name}.#{quote_column(@model.primary_key_for_sphinx)}"] + 
-          @fields.collect     { |field|     field.to_group_sql     }.compact +
-          @attributes.collect { |attribute| attribute.to_group_sql }.compact +
-          @groupings + internal_groupings
-        ).join(", ")
-      end
-
-      def sql_query_pre_for_core
-        if self.delta? && !@index.delta_object.reset_query(@model).blank?
-          [@index.delta_object.reset_query(@model)]
-        else
-          []
-        end
-      end
-
-      def sql_query_pre_for_delta
-        [""]
-      end
-
-      def quote_column(column)
-        @model.connection.quote_column_name(column)
-      end
-
-      def crc_column
-        if @model.table_exists? &&
-          @model.column_names.include?(@model.inheritance_column)
-          
-          adapter.cast_to_unsigned(adapter.convert_nulls(
-            adapter.crc(adapter.quote_with_table(@model.inheritance_column), true),
-            @model.to_crc32
-          ))
-        else
-          @model.to_crc32.to_s
-        end
-      end
-    end
-  end
-end

data/lib/thinking_sphinx/source.rb

@@ -1,150 +0,0 @@
-require 'thinking_sphinx/source/internal_properties'
-require 'thinking_sphinx/source/sql'
-
-module ThinkingSphinx
-  class Source
-    include ThinkingSphinx::Source::InternalProperties
-    include ThinkingSphinx::Source::SQL
-    
-    attr_accessor :model, :fields, :attributes, :conditions, :groupings,
-      :options
-    attr_reader :base, :index
-    
-    def initialize(index, options = {})
-      @index        = index
-      @model        = index.model
-      @fields       = []
-      @attributes   = []
-      @conditions   = []
-      @groupings    = []
-      @options      = options
-      @associations = {}
-      
-      @base = ::ActiveRecord::Associations::ClassMethods::JoinDependency.new(
-        @model, [], nil
-      )
-      
-      unless @model.descends_from_active_record?
-        stored_class = @model.store_full_sti_class ? @model.name : @model.name.demodulize
-        @conditions << "#{@model.quoted_table_name}.#{quote_column(@model.inheritance_column)} = '#{stored_class}'"
-      end
-      
-      add_internal_attributes_and_facets
-    end
-    
-    def name
-      @model.sphinx_name
-    end
-    
-    def to_riddle_for_core(offset, index)
-      source = Riddle::Configuration::SQLSource.new(
-        "#{name}_core_#{index}", adapter.sphinx_identifier
-      )
-      
-      set_source_database_settings  source
-      set_source_attributes         source, offset
-      set_source_sql                source, offset
-      set_source_settings           source
-      
-      source
-    end
-    
-    def to_riddle_for_delta(offset, index)
-      source = Riddle::Configuration::SQLSource.new(
-        "#{name}_delta_#{index}", adapter.sphinx_identifier
-      )
-      source.parent = "#{name}_core_#{index}"
-      
-      set_source_database_settings  source
-      set_source_attributes         source, offset, true
-      set_source_sql                source, offset, true
-      
-      source
-    end
-    
-    def delta?
-      !@index.delta_object.nil?
-    end
-    
-    # Gets the association stack for a specific key.
-    # 
-    def association(key)
-      @associations[key] ||= Association.children(@model, key)
-    end
-    
-    private
-    
-    def adapter
-      @adapter ||= @model.sphinx_database_adapter
-    end
-    
-    def set_source_database_settings(source)
-      config = @model.connection.instance_variable_get(:@config)
-      
-      source.sql_host = config[:host]           || "localhost"
-      source.sql_user = config[:username]       || config[:user] || 'root'
-      source.sql_pass = (config[:password].to_s || "").gsub('#', '\#')
-      source.sql_db   = config[:database]
-      source.sql_port = config[:port]
-      source.sql_sock = config[:socket]
-    end
-    
-    def set_source_attributes(source, offset, delta = false)
-      attributes.each do |attrib|
-        source.send(attrib.type_to_config) << attrib.config_value(offset, delta)
-      end
-    end
-    
-    def set_source_sql(source, offset, delta = false)
-      source.sql_query        = to_sql(:offset => offset, :delta => delta).gsub(/\n/, ' ')
-      source.sql_query_range  = to_sql_query_range(:delta => delta)
-      source.sql_query_info   = to_sql_query_info(offset)
-      
-      source.sql_query_pre += send(!delta ? :sql_query_pre_for_core : :sql_query_pre_for_delta)
-      
-      if @index.local_options[:group_concat_max_len]
-        source.sql_query_pre << "SET SESSION group_concat_max_len = #{@index.local_options[:group_concat_max_len]}"
-      end
-      
-      source.sql_query_pre += [adapter.utf8_query_pre].compact if utf8?
-    end
-    
-    def set_source_settings(source)
-      config = ThinkingSphinx::Configuration.instance
-      config.source_options.each do |key, value|
-        source.send("#{key}=".to_sym, value)
-      end
-      
-      source_options = ThinkingSphinx::Configuration::SourceOptions
-      @options.each do |key, value|
-        if source_options.include?(key.to_s) && !value.nil?
-          source.send("#{key}=".to_sym, value)
-        end
-      end
-    end
-    
-    # Returns all associations used amongst all the fields and attributes.
-    # This includes all associations between the model and what the actual
-    # columns are from.
-    # 
-    def all_associations
-      @all_associations ||= (
-        # field associations
-        @fields.collect { |field|
-          field.associations.values
-        }.flatten +
-        # attribute associations
-        @attributes.collect { |attrib|
-          attrib.associations.values if attrib.include_as_association?
-        }.compact.flatten
-      ).uniq.collect { |assoc|
-        # get ancestors as well as column-level associations
-        assoc.ancestors
-      }.flatten.uniq
-    end
-    
-    def utf8?
-      @index.options[:charset_type] == "utf-8"
-    end
-  end
-end

data/rails/init.rb

@@ -1,14 +0,0 @@
-require 'thinking_sphinx'
-require 'action_controller/dispatcher'
-
-ActionController::Dispatcher.to_prepare :thinking_sphinx do
-  # Force internationalisation to be loaded.
-  if Rails::VERSION::STRING.to_f > 2.2
-    I18n.backend.reload!
-    I18n.backend.available_locales
-  elsif Rails::VERSION::STRING.to_f > 2.1
-    I18n.backend.load_translations(*I18n.load_path)
-  end
-  
-  ThinkingSphinx::Configuration.instance.load_models
-end

data/spec/lib/thinking_sphinx/active_record/delta_spec.rb

@@ -1,130 +0,0 @@
-require 'spec/spec_helper'
-
-describe "ThinkingSphinx::ActiveRecord::Delta" do
-  it "should call the toggle_delta method after a save" do
-    @beta = Beta.new(:name => 'beta')
-    @beta.should_receive(:toggle_delta).and_return(true)
-    
-    @beta.save
-  end
-  
-  it "should call the toggle_delta method after a save!" do
-    @beta = Beta.new(:name => 'beta')
-    @beta.should_receive(:toggle_delta).and_return(true)
-    
-    @beta.save!
-  end
-  
-  describe "suspended_delta method" do
-    before :each do
-      ThinkingSphinx.deltas_enabled = true
-      Person.sphinx_indexes.first.delta_object.stub!(:` => "")
-    end
-
-    it "should execute the argument block with deltas disabled" do
-      ThinkingSphinx.should_receive(:deltas_enabled=).once.with(false)
-      ThinkingSphinx.should_receive(:deltas_enabled=).once.with(true)
-      lambda { Person.suspended_delta { raise 'i was called' } }.should(
-        raise_error(Exception)
-      )
-    end
-
-    it "should restore deltas_enabled to its original setting" do
-      ThinkingSphinx.deltas_enabled = false
-      ThinkingSphinx.should_receive(:deltas_enabled=).twice.with(false)
-      Person.suspended_delta { 'no-op' }
-    end
-
-    it "should restore deltas_enabled to its original setting even if there was an exception" do
-      ThinkingSphinx.deltas_enabled = false
-      ThinkingSphinx.should_receive(:deltas_enabled=).twice.with(false)
-      lambda { Person.suspended_delta { raise 'bad error' } }.should(
-        raise_error(Exception)
-      )
-    end
-
-    it "should reindex by default after the code block is run" do
-      Person.should_receive(:index_delta)
-      Person.suspended_delta { 'no-op' }
-    end
-    
-    it "should not reindex after the code block if false is passed in" do
-      Person.should_not_receive(:index_delta)
-      Person.suspended_delta(false) { 'no-op' }
-    end
-  end
-  
-  describe "toggle_delta method" do
-    it "should set the delta value to true" do
-      @person = Person.new
-      
-      @person.delta.should be_false
-      @person.send(:toggle_delta)
-      @person.delta.should be_true
-    end
-  end
-  
-  describe "index_delta method" do
-    before :each do
-      ThinkingSphinx::Configuration.stub!(:environment => "spec")
-      ThinkingSphinx.deltas_enabled   = true
-      ThinkingSphinx.updates_enabled  = true
-      ThinkingSphinx.stub!(:sphinx_running? => true)
-      Person.delta_object.stub!(:` => "", :toggled => true)
-      
-      @person = Person.new
-      @person.stub!(
-        :in_both_indexes?     => false,
-        :sphinx_document_id => 1
-      )
-      
-      @client = Riddle::Client.new
-      @client.stub!(:update => true)
-      Riddle::Client.stub!(:new => @client)
-    end
-    
-    it "shouldn't index if delta indexing is disabled" do
-      ThinkingSphinx.deltas_enabled = false
-      Person.sphinx_indexes.first.delta_object.should_not_receive(:`)
-      @client.should_not_receive(:update)
-      
-      @person.send(:index_delta)
-    end
-    
-    it "shouldn't index if index updating is disabled" do
-      ThinkingSphinx.updates_enabled = false
-      Person.sphinx_indexes.first.delta_object.should_not_receive(:`)
-      
-      @person.send(:index_delta)
-    end
-    
-    it "shouldn't index if the environment is 'test'" do
-      ThinkingSphinx.deltas_enabled = nil
-      ThinkingSphinx::Configuration.stub!(:environment => "test")
-      Person.sphinx_indexes.first.delta_object.should_not_receive(:`)
-      
-      @person.send(:index_delta)
-    end
-    
-    it "should call indexer for the delta index" do
-      Person.sphinx_indexes.first.delta_object.should_receive(:`).with(
-        "#{ThinkingSphinx::Configuration.instance.bin_path}indexer --config #{ThinkingSphinx::Configuration.instance.config_file} --rotate person_delta"
-      )
-      
-      @person.send(:index_delta)
-    end
-    
-    it "shouldn't update the deleted attribute if not in the index" do
-      @client.should_not_receive(:update)
-      
-      @person.send(:index_delta)
-    end
-    
-    it "should update the deleted attribute if in the core index" do
-      @person.stub!(:in_both_indexes? => true)
-      @client.should_receive(:update)
-      
-      @person.send(:index_delta)
-    end
-  end
-end

data/spec/lib/thinking_sphinx/active_record/has_many_association_spec.rb

@@ -1,49 +0,0 @@
-require 'spec/spec_helper'
-
-describe 'ThinkingSphinx::ActiveRecord::HasManyAssociation' do
-  describe "search method" do
-    before :each do
-      Friendship.stub!(:search => true)
-      
-      @person = Person.find(:first)
-      @index  = Friendship.sphinx_indexes.first
-    end
-    
-    it "should raise an error if the required attribute doesn't exist" do
-      @index.stub!(:attributes => [])
-      
-      lambda { @person.friendships.search "test" }.should raise_error(RuntimeError)
-    end
-    
-    it "should add a filter for the attribute into a normal search call" do
-      Friendship.should_receive(:search) do |query, options|
-        options[:with][:person_id].should == @person.id
-      end
-      
-      @person.friendships.search "test"
-    end    
-  end
-  
-  describe "search method for has_many :through" do
-    before :each do
-      Person.stub!(:search => true)
-      
-      @person = Person.find(:first)
-      @index  = Person.sphinx_indexes.first
-    end
-    
-    it "should raise an error if the required attribute doesn't exist" do
-      @index.stub!(:attributes => [])
-      
-      lambda { @person.friends.search "test" }.should raise_error(RuntimeError)
-    end
-    
-    it "should add a filter for the attribute into a normal search call" do
-      Person.should_receive(:search).with do |query, options|
-        options[:with][:friendly_ids].should == @person.id
-      end
-      
-      @person.friends.search "test"
-    end
-  end
-end

data/spec/lib/thinking_sphinx/active_record/scopes_spec.rb

@@ -1,96 +0,0 @@
-require 'spec/spec_helper'
-
-describe ThinkingSphinx::ActiveRecord::Scopes do
-  after :each do
-    Alpha.remove_sphinx_scopes
-  end
-  
-  it "should be included into models with indexes" do
-    Alpha.included_modules.should include(ThinkingSphinx::ActiveRecord::Scopes)
-  end
-  
-  it "should not be included into models without indexes" do
-    Gamma.included_modules.should_not include(
-      ThinkingSphinx::ActiveRecord::Scopes
-    )
-  end
-  
-  describe '.sphinx_scope' do
-    before :each do
-      Alpha.sphinx_scope(:by_name) { |name| {:conditions => {:name => name}} }
-    end
-    
-    it "should define a method on the model" do
-      Alpha.should respond_to(:by_name)
-    end
-  end
-  
-  describe '.sphinx_scopes' do
-    before :each do
-      Alpha.sphinx_scope(:by_name) { |name| {:conditions => {:name => name}} }
-    end
-    
-    it "should return an array of defined scope names as symbols" do
-      Alpha.sphinx_scopes.should == [:by_name]
-    end
-  end
-  
-  describe '.remove_sphinx_scopes' do
-    before :each do
-      Alpha.sphinx_scope(:by_name) { |name| {:conditions => {:name => name}} }
-      Alpha.remove_sphinx_scopes
-    end
-    
-    it "should remove sphinx scope methods" do
-      Alpha.should_not respond_to(:by_name)
-    end
-    
-    it "should empty the list of sphinx scopes" do
-      Alpha.sphinx_scopes.should be_empty
-    end
-  end
-  
-  describe '.example_scope' do
-    before :each do
-      Alpha.sphinx_scope(:by_name) { |name| {:conditions => {:name => name}} }
-      Alpha.sphinx_scope(:by_foo)  { |foo|  {:conditions => {:foo  => foo}}  }
-      Alpha.sphinx_scope(:with_betas) { {:classes => [Beta]} }
-    end
-    
-    it "should return a ThinkingSphinx::Search object" do
-      Alpha.by_name('foo').should be_a(ThinkingSphinx::Search)
-    end
-    
-    it "should set the classes option" do
-      Alpha.by_name('foo').options[:classes].should == [Alpha]
-    end
-    
-    it "should be able to be called on a ThinkingSphinx::Search object" do
-      search = ThinkingSphinx::Search.new(:classes => [Alpha])
-      lambda {
-        search.by_name('foo')
-      }.should_not raise_error
-    end
-    
-    it "should return the search object it gets called upon" do
-      search = ThinkingSphinx::Search.new(:classes => [Alpha])
-      search.by_name('foo').should == search
-    end
-    
-    it "should apply the scope options to the underlying search object" do
-      search = ThinkingSphinx::Search.new(:classes => [Alpha])
-      search.by_name('foo').options[:conditions].should == {:name => 'foo'}
-    end
-    
-    it "should combine hash option scopes such as :conditions" do
-      search = ThinkingSphinx::Search.new(:classes => [Alpha])
-      search.by_name('foo').by_foo('bar').options[:conditions].
-        should == {:name => 'foo', :foo => 'bar'}
-    end
-    
-    it "should combine array option scopes such as :classes" do
-      search = ThinkingSphinx::Search.new(:classes => [Alpha])
-      search.with_betas.options[:classes].should == [Alpha, Beta]
-    end
-  end
-end