freelancing-god-thinking-sphinx 0.9.6 → 0.9.7

data/README

@@ -4,6 +4,26 @@
 
 First, if you haven't done so already, check out the main usage[http://ts.freelancing-gods.com/usage.html] page. Once you've done that, the next place to look for information is the specific method docs - ThinkingSphinx::Search and ThinkingSphinx::Index::Builder in particular.
 
+== Contributing
+
+Fork on GitHub and after you've committed tested patches, send a pull request.
+
+To get the spec suite running, you will need to install the not-a-mock gem if you don't already have it:
+
+  git clone git://github.com/freelancing-god/not-a-mock.git
+  cd not-a-mock
+  rake gem
+  gem install pkg/not_a_mock-1.1.0.gem
+
+Then set up your database
+
+  cp spec/fixtures/database.yml.default spec/fixtures/database.yml
+  mysqladmin -u root create thinking_sphinx
+
+You should now have a passing test suite from which to build your patch on.
+
+  rake spec
+
 == Contributors
 
 Since I first released this library, there's been quite a few people who have submitted patches, to my immense gratitude. Others have suggested syntax changes and general improvements. So my thanks to the following people:
@@ -22,4 +42,6 @@ Since I first released this library, there's been quite a few people who have su
 - Patrick Lenz
 - Björn Andreasson
 - James Healy
-- Jae-Jun Hwang
+- Jae-Jun Hwang
+- Xavier Shay
+- Jason Rust

data/lib/thinking_sphinx.rb

@@ -20,7 +20,7 @@ module ThinkingSphinx
   module Version #:nodoc:
     Major = 0
     Minor = 9
-    Tiny  = 6
+    Tiny  = 7
     
     String = [Major, Minor, Tiny].join('.')
   end
@@ -67,6 +67,9 @@ module ThinkingSphinx
     @@deltas_enabled = value
   end
   
+  # Checks to see if MySQL will allow simplistic GROUP BY statements. If not,
+  # or if not using MySQL, this will return false.
+  # 
   def self.use_group_by_shortcut?
     ::ActiveRecord::ConnectionAdapters.constants.include?("MysqlAdapter") &&
     ::ActiveRecord::Base.connection.is_a?(

data/lib/thinking_sphinx/active_record.rb

@@ -78,6 +78,8 @@ module ThinkingSphinx
               after_commit  :index_delta
             end
             
+            after_destroy :toggle_deleted
+            
             index
           end
           alias_method :sphinx_index, :define_index
@@ -111,5 +113,22 @@ module ThinkingSphinx
         :include, ThinkingSphinx::ActiveRecord::HasManyAssociation
       )
     end
+    
+    def toggle_deleted
+      config = ThinkingSphinx::Configuration.new
+      client = Riddle::Client.new config.address, config.port
+      
+      client.update(
+        "#{self.class.name.downcase}_core",
+        ['sphinx_deleted'],
+        {self.id => 1}
+      )
+      
+      client.update(
+        "#{self.class.name.downcase}_delta",
+        ['sphinx_deleted'],
+        {self.id => 1}
+      ) if self.class.indexes.any? { |index| index.delta? }
+    end
   end
 end

data/lib/thinking_sphinx/active_record/delta.rb

@@ -27,6 +27,10 @@ module ThinkingSphinx
             end
           end
           
+          def after_commit
+            # Deliberately blank.
+          end
+          
           # Normal boolean save wrapped in a handler for the after_commit
           # callback.
           # 

data/lib/thinking_sphinx/association.rb

@@ -122,16 +122,16 @@ module ThinkingSphinx
       options[:class_name]    = klass.name
       options[:foreign_key] ||= "#{ref.name}_id"
       
-      foreign_type = klass.connection.quote_column_name ref.options[:foreign_type]
+      quoted_foreign_type = klass.connection.quote_column_name ref.options[:foreign_type]
       case options[:conditions]
       when nil
-        options[:conditions] = "::ts_join_alias::.#{foreign_type} = '#{klass.name}'"
+        options[:conditions] = "::ts_join_alias::.#{quoted_foreign_type} = '#{klass.name}'"
       when Array
-        options[:conditions] << "::ts_join_alias::.#{foreign_type} = '#{klass.name}'"
+        options[:conditions] << "::ts_join_alias::.#{quoted_foreign_type} = '#{klass.name}'"
       when Hash
-        options[:conditions].merge!(foreign_type => klass.name)
+        options[:conditions].merge!(ref.options[:foreign_type] => klass.name)
       else
-        options[:conditions] << " AND ::ts_join_alias::.#{foreign_type} = '#{klass.name}'"
+        options[:conditions] << " AND ::ts_join_alias::.#{quoted_foreign_type} = '#{klass.name}'"
       end
       
       options

data/lib/thinking_sphinx/attribute.rb

@@ -57,6 +57,8 @@ module ThinkingSphinx
       @columns      = Array(columns)
       @associations = {}
       
+      raise "Cannot define a field with no columns. Maybe you are trying to index a field with a reserved name (id, name). You can fix this error by using a symbol rather than a bare name (:id instead of id)." if @columns.empty? || @columns.any? { |column| !column.respond_to?(:__stack) }
+      
       @alias        = options[:as]
       @type         = options[:type]
     end
@@ -139,7 +141,7 @@ module ThinkingSphinx
       when "ActiveRecord::ConnectionAdapters::MysqlAdapter"
         "CONCAT_WS('#{separator}', #{clause})"
       when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
-        clause.split(', ').join(" || #{separator} || ")
+        clause.split(', ').join(" || '#{separator}' || ")
       else
         clause
       end
@@ -271,7 +273,8 @@ module ThinkingSphinx
         klasses = @associations[col].empty? ? [@model] :
           @associations[col].collect { |assoc| assoc.reflection.klass }
         klasses.all? { |klass|
-          klass.columns.detect { |column| column.name == col.__name.to_s }.type == :integer
+          column = klass.columns.detect { |column| column.name == col.__name.to_s }
+          !column.nil? && column.type == :integer
         }
       }
     end

data/lib/thinking_sphinx/configuration.rb

@@ -49,11 +49,12 @@ module ThinkingSphinx
       self.app_root          = Merb.root  if defined?(Merb)
       self.app_root        ||= app_root
       
-      self.config_file       = "#{app_root}/config/#{environment}.sphinx.conf"
-      self.searchd_log_file  = "#{app_root}/log/searchd.log"
-      self.query_log_file    = "#{app_root}/log/searchd.query.log"
-      self.pid_file          = "#{app_root}/log/searchd.#{environment}.pid"
-      self.searchd_file_path = "#{app_root}/db/sphinx/#{environment}"
+      self.config_file       = "#{self.app_root}/config/#{environment}.sphinx.conf"
+      self.searchd_log_file  = "#{self.app_root}/log/searchd.log"
+      self.query_log_file    = "#{self.app_root}/log/searchd.query.log"
+      self.pid_file          = "#{self.app_root}/log/searchd.#{environment}.pid"
+      self.searchd_file_path = "#{self.app_root}/db/sphinx/#{environment}"
+      self.address           = "0.0.0.0"
       self.port              = 3312
       self.allow_star        = false
       self.mem_limit         = "64M"
@@ -97,6 +98,7 @@ indexer
 
 searchd
 {
+  address = #{self.address}
   port = #{self.port}
   log = #{self.searchd_log_file}
   query_log = #{self.query_log_file}
@@ -110,107 +112,27 @@ searchd
         ThinkingSphinx.indexed_models.each do |model|
           model           = model.constantize
           sources         = []
+          delta_sources   = []
           prefixed_fields = []
           infixed_fields  = []
           
           model.indexes.each_with_index do |index, i|
-            # Set up associations and joins
-            index.link!
+            file.write index.to_config(i, database_conf, charset_type)
             
-            attr_sources = index.attributes.collect { |attrib|
-              attrib.to_sphinx_clause
-            }.join("\n  ")
-            
-            adapter = case index.adapter
-            when :postgres
-              create_array_accum
-              "pgsql"
-            when :mysql
-              "mysql"
-            else
-              raise "Unsupported Database Adapter: Sphinx only supports MySQL and PosgreSQL"
-            end
-            
-            file.write <<-SOURCE
-
-source #{model.name.downcase}_#{i}_core
-{
-  type     = #{adapter}
-  sql_host = #{database_conf[:host] || "localhost"}
-  sql_user = #{database_conf[:username]}
-  sql_pass = #{database_conf[:password]}
-  sql_db   = #{database_conf[:database]}
-
-  sql_query_pre    = #{charset_type == "utf-8" && adapter == "mysql" ? "SET NAMES utf8" : ""}
-  sql_query_pre    = #{index.to_sql_query_pre}
-  sql_query        = #{index.to_sql.gsub(/\n/, ' ')}
-  sql_query_range  = #{index.to_sql_query_range}
-  sql_query_info   = #{index.to_sql_query_info}
-  #{attr_sources}
-}
-            SOURCE
-            
-            if index.delta?
-              file.write <<-SOURCE
-
-source #{model.name.downcase}_#{i}_delta : #{model.name.downcase}_#{i}_core
-{
-  sql_query_pre    = #{charset_type == "utf-8" && adapter == "mysql" ? "SET NAMES utf8" : ""}
-  sql_query        = #{index.to_sql(:delta => true).gsub(/\n/, ' ')}
-  sql_query_range  = #{index.to_sql_query_range :delta => true}
-}
-              SOURCE
-            end
+            create_array_accum if index.adapter == :postgres
             sources << "#{model.name.downcase}_#{i}_core"
+            delta_sources << "#{model.name.downcase}_#{i}_delta" if index.delta?
           end
           
           source_list = sources.collect { |s| "source = #{s}" }.join("\n")
-          delta_list  = source_list.gsub(/_core$/, "_delta")
-          file.write <<-INDEX
-
-index #{model.name.downcase}_core
-{
-  #{source_list}
-  path = #{self.searchd_file_path}/#{model.name.downcase}_core
-  charset_type = #{self.charset_type}
-  INDEX
-          file.puts "  morphology = #{self.morphology}"        unless self.morphology.blank?
-          file.puts "  charset_table  = #{self.charset_table}" unless self.charset_table.nil?
-          file.puts "  ignore_chars   = #{self.ignore_chars}"  unless self.ignore_chars.nil?
+          delta_list  = delta_sources.collect { |s| "source = #{s}" }.join("\n")
           
-          if self.allow_star
-            file.puts "  enable_star    = 1"
-            file.puts "  min_prefix_len = 1"
+          file.write core_index_for_model(model, source_list)
+          unless delta_list.blank?
+            file.write delta_index_for_model(model, delta_list)
           end
           
-          file.write("}\n")
-          
-          if model.indexes.any? { |index| index.delta? }
-            file.write <<-INDEX
-
-index #{model.name.downcase}_delta : #{model.name.downcase}_core
-{
-  #{delta_list}
-  path = #{self.searchd_file_path}/#{model.name.downcase}_delta
-}
-
-index #{model.name.downcase}
-{
-  type = distributed
-  local = #{model.name.downcase}_core
-  local = #{model.name.downcase}_delta
-  charset_type = #{self.charset_type}
-}
-            INDEX
-          else
-            file.write <<-INDEX
-index #{model.name.downcase}
-{
-  type = distributed
-  local = #{model.name.downcase}_core
-}
-            INDEX
-          end
+          file.write distributed_index_for_model(model)
         end
       end
     end
@@ -220,8 +142,9 @@ index #{model.name.downcase}
     # messy dependencies issues).
     # 
     def load_models
-      Dir["#{app_root}/app/models/**/*.rb"].each do |file|
-        model_name = file.gsub(/^.*\/([\w_]+)\.rb/, '\1')
+      base = "#{app_root}/app/models/"
+      Dir["#{base}**/*.rb"].each do |file|
+        model_name = file.gsub(/^#{base}([\w_\/\\]+)\.rb/, '\1')
         
         next if model_name.nil?
         next if ::ActiveRecord::Base.send(:subclasses).detect { |model|
@@ -229,8 +152,10 @@ index #{model.name.downcase}
         }
         
         begin
-          model_name.camelize.constantize
-        rescue NameError, LoadError
+          model_name.classify.constantize
+        rescue LoadError
+          model_name.gsub(/.*[\/\\]/, '').classify.constantize
+        rescue NameError
           next
         end
       end
@@ -252,11 +177,68 @@ index #{model.name.downcase}
       end unless conf.nil?
     end
     
+    def core_index_for_model(model, sources)
+      output = <<-INDEX
+
+index #{model.name.downcase}_core
+{
+#{sources}
+path = #{self.searchd_file_path}/#{model.name.downcase}_core
+charset_type = #{self.charset_type}
+INDEX
+      
+      output += "  morphology     = #{self.morphology}\n"    unless self.morphology.blank?
+      output += "  charset_table  = #{self.charset_table}\n" unless self.charset_table.nil?
+      output += "  ignore_chars   = #{self.ignore_chars}\n"  unless self.ignore_chars.nil?
+      
+      if self.allow_star
+        output += "  enable_star    = 1\n"
+        output += "  min_prefix_len = 1\n"
+        output += "  min_infix_len  = 1\n"
+      end
+      
+      unless model.indexes.collect(&:prefix_fields).flatten.empty?
+        output += "  prefix_fields = #{model.indexes.collect(&:prefix_fields).flatten.join(', ')}\n"
+      end
+      
+      unless model.indexes.collect(&:infix_fields).flatten.empty?
+        output += "  infix_fields  = #{model.indexes.collect(&:infix_fields).flatten.join(', ')}\n"
+      end
+      
+      output + "}\n"
+    end
+    
+    def delta_index_for_model(model, sources)
+      <<-INDEX
+index #{model.name.downcase}_delta : #{model.name.downcase}_core
+{
+  #{sources}
+  path = #{self.searchd_file_path}/#{model.name.downcase}_delta
+}
+      INDEX
+    end
+    
+    def distributed_index_for_model(model)
+      sources = ["local = #{model.name.downcase}_core"]
+      if model.indexes.any? { |index| index.delta? }
+        sources << "local = #{model.name.downcase}_delta"
+      end
+      
+      <<-INDEX
+index #{model.name.downcase}
+{
+  type = distributed
+  #{ sources.join("\n  ") }
+  charset_type = #{self.charset_type}
+}
+      INDEX
+    end
+    
     def create_array_accum
-      execute "begin"
-      execute "savepoint ts"
+      ::ActiveRecord::Base.connection.execute "begin"
+      ::ActiveRecord::Base.connection.execute "savepoint ts"
       begin
-        execute <<-SQL
+        ::ActiveRecord::Base.connection.execute <<-SQL
           CREATE AGGREGATE array_accum (anyelement)
           (
               sfunc = array_append,
@@ -266,10 +248,10 @@ index #{model.name.downcase}
         SQL
       rescue
         raise unless $!.to_s =~ /already exists with same argument types/
-        execute "rollback to savepoint ts"
+        ::ActiveRecord::Base.connection.execute "rollback to savepoint ts"
       end
-      execute "release savepoint foo"
-      execute "commit"
+      ::ActiveRecord::Base.connection.execute "release savepoint ts"
+      ::ActiveRecord::Base.connection.execute "commit"
     end
   end
 end

data/lib/thinking_sphinx/field.rb

@@ -8,7 +8,7 @@ module ThinkingSphinx
   # associations. Which can get messy. Use Index.link!, it really helps.
   # 
   class Field
-    attr_accessor :alias, :columns, :sortable, :associations, :model
+    attr_accessor :alias, :columns, :sortable, :associations, :model, :infixes, :prefixes
     
     # To create a new field, you'll need to pass in either a single Column
     # or an array of them, and some (optional) options. The columns are
@@ -17,6 +17,8 @@ module ThinkingSphinx
     # Valid options are:
     # - :as       => :alias_name 
     # - :sortable => true
+    # - :infixes  => true
+    # - :prefixes => true
     #
     # Alias is only required in three circumstances: when there's
     # another attribute or field with the same name, when the column name is
@@ -27,6 +29,12 @@ module ThinkingSphinx
     # to an integer value), which can be sorted by. Thinking Sphinx is smart
     # enough to realise that when you specify fields in sort statements, you
     # mean their respective attributes.
+    # 
+    # If you have partial matching enabled (ie: enable_star), then you can
+    # specify certain fields to have their prefixes and infixes indexed. Keep
+    # in mind, though, that Sphinx's default is _all_ fields - so once you
+    # highlight a particular field, no other fields in the index will have
+    # these partial indexes.
     #
     # Here's some examples:
     #
@@ -41,15 +49,19 @@ module ThinkingSphinx
     # 
     #   Field.new(
     #     [Column.new(:posts, :subject), Column.new(:posts, :content)],
-    #     :as => :posts
+    #     :as => :posts, :prefixes => true
     #   )
     # 
     def initialize(columns, options = {})
       @columns      = Array(columns)
       @associations = {}
+
+      raise "Cannot define a field with no columns. Maybe you are trying to index a field with a reserved name (id, name). You can fix this error by using a symbol rather than a bare name (:id instead of id)." if @columns.empty? || @columns.any? { |column| !column.respond_to?(:__stack) }
       
       @alias        = options[:as]
       @sortable     = options[:sortable] || false
+      @infixes      = options[:infixes]  || false
+      @prefixes     = options[:prefixes] || false
     end
     
     # Get the part of the SELECT clause related to this field. Don't forget
@@ -105,7 +117,7 @@ module ThinkingSphinx
       when "ActiveRecord::ConnectionAdapters::MysqlAdapter"
         "CONCAT_WS(' ', #{clause})"
       when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
-        clause.split(', ').join(" || #{separator} || ")
+        clause.split(', ').join(" || ' ' || ")
       else
         clause
       end
@@ -116,7 +128,7 @@ module ThinkingSphinx
       when "ActiveRecord::ConnectionAdapters::MysqlAdapter"
         "GROUP_CONCAT(#{clause} SEPARATOR ' ')"
       when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
-        "array_to_string(array_accum(#{clause}), '#{separator}')"
+        "array_to_string(array_accum(#{clause}), ' ')"
       else
         clause
       end
@@ -183,4 +195,4 @@ module ThinkingSphinx
       associations.values.flatten.any? { |assoc| assoc.is_many? }
     end
   end
-end
+end