lib/thinking_sphinx/collection.rb spec/fixtures/sphinx/.gitignore @@ -4,4 +4,5 @@ coverage *.tmproj rdoc spec/fixtures/database.yml -.svn \ No newline at end of file +.svn +tmp .gitignore @@ -54,4 +54,12 @@ Since I first released this library, there's been quite a few people who have su - Andrew Bennett - Jordan Fowler - Seth Walker -- Joe Noon \ No newline at end of file +- Joe Noon +- Wolfgang Postler +- Rick Olson +- Killian Murphy +- Morten Primdahl +- Ryan Bates +- David Eisinger +- Shay Arnett +- Minh Tran README @@ -54,4 +54,12 @@ Since I first released this library, there's been quite a few people who have su * Andrew Bennett * Jordan Fowler * Seth Walker -* Joe Noon \ No newline at end of file +* Joe Noon +* Wolfgang Postler +* Rick Olson +* Killian Murphy +* Morten Primdahl +* Ryan Bates +* David Eisinger +* Shay Arnett +* Minh Tran README.textile @@ -27,6 +27,7 @@ end 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 "Generate RCov reports" @@ -38,7 +39,7 @@ Spec::Rake::SpecTask.new(:rcov) do |t| end spec = Gem::Specification.new do |s| - s.name = "thinking_sphinx" + 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." @@ -63,4 +64,9 @@ Rake::GemPackageTask.new(spec) do |p| p.gem_spec = spec p.need_tar = true p.need_zip = true -end \ No newline at end of file +end + +desc "Build gemspec file" +task :build do + File.open('thinking-sphinx.gemspec', 'w') { |f| f.write spec.to_ruby } +end Rakefile @@ -1 +1,3 @@ -require 'thinking_sphinx' \ No newline at end of file +require 'thinking_sphinx' + +ThinkingSphinx::Configuration.new.load_models \ No newline at end of file init.rb @@ -179,12 +179,12 @@ module Riddle # Example: # client.set_anchor('lat', -0.6591741, 'long', 2.530770) # - def set_anchor(lat_attr, lat, long_attr, long) + def set_anchor(lat_attr, lat, long_attr, long, units='') @anchor = { :latitude_attribute => lat_attr, - :latitude => lat, + :latitude => (units == 'degrees' ? lat * Math::PI / 180 : lat), :longitude_attribute => long_attr, - :longitude => long + :longitude => (units == 'degrees' ? long * Math::PI / 180 : long) } end lib/riddle/client.rb @@ -4,6 +4,7 @@ require 'riddle' require 'thinking_sphinx/active_record' require 'thinking_sphinx/association' require 'thinking_sphinx/attribute' +require 'thinking_sphinx/collection' require 'thinking_sphinx/configuration' require 'thinking_sphinx/field' require 'thinking_sphinx/index' @@ -20,7 +21,7 @@ module ThinkingSphinx module Version #:nodoc: Major = 0 Minor = 9 - Tiny = 8 + Tiny = 9 String = [Major, Minor, Tiny].join('.') end lib/thinking_sphinx.rb @@ -99,6 +99,10 @@ module ThinkingSphinx end result ^ 0xFFFFFFFF end + + def to_crc32s + (subclasses << self).collect { |klass| klass.to_crc32 } + end end end lib/thinking_sphinx/active_record.rb @@ -28,7 +28,14 @@ module ThinkingSphinx args << options ThinkingSphinx::Search.search(*args) end - + + def search_count(*args) + options = args.extract_options! + options[:class] = self + args << options + ThinkingSphinx::Search.count(*args) + end + def search_for_id(*args) options = args.extract_options! options[:class] = self lib/thinking_sphinx/active_record/search.rb @@ -29,10 +29,9 @@ module ThinkingSphinx # config/sphinx.yml with settings for each environment, in a similar # fashion to database.yml - using the following keys: config_file, # searchd_log_file, query_log_file, pid_file, searchd_file_path, port, - # allow_star, min_prefix_len, min_infix_len, mem_limit, max_matches, - # morphology, charset_type, charset_table, ignore_chars, html_strip, - # html_remove_elements. I think you've got - # the idea. + # allow_star, enable_star, min_prefix_len, min_infix_len, mem_limit, + # max_matches, # morphology, charset_type, charset_table, ignore_chars, + # html_strip, # html_remove_elements. I think you've got the idea. # # Each setting in the YAML file is optional - so only put in the ones you # want to change. @@ -43,10 +42,10 @@ module ThinkingSphinx # class Configuration attr_accessor :config_file, :searchd_log_file, :query_log_file, - :pid_file, :searchd_file_path, :address, :port, :allow_star, - :min_prefix_len, :min_infix_len, :mem_limit, :max_matches, :morphology, - :charset_type, :charset_table, :ignore_chars, :html_strip, - :html_remove_elements, :app_root + :pid_file, :searchd_file_path, :address, :port, :enable_star, + :allow_star, :min_prefix_len, :min_infix_len, :mem_limit, :max_matches, + :morphology, :charset_type, :charset_table, :ignore_chars, :html_strip, + :html_remove_elements, :database_yml_file, :app_root attr_reader :environment @@ -58,6 +57,7 @@ module ThinkingSphinx self.app_root = Merb.root if defined?(Merb) self.app_root ||= app_root + self.database_yml_file = "#{self.app_root}/config/database.yml" 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" @@ -66,8 +66,9 @@ module ThinkingSphinx self.address = "127.0.0.1" self.port = 3312 self.allow_star = false - self.min_prefix_len = 1 - self.min_infix_len = 1 + self.enable_star = false + self.min_prefix_len = nil + self.min_infix_len = nil self.mem_limit = "64M" self.max_matches = 1000 self.morphology = "stem_en" @@ -97,7 +98,7 @@ module ThinkingSphinx def build(file_path=nil) load_models file_path ||= "#{self.config_file}" - database_confs = YAML::load(ERB.new(IO.read("#{app_root}/config/database.yml")).result) + database_confs = YAML::load(ERB.new(IO.read("#{self.database_yml_file}")).result) database_confs.symbolize_keys! database_conf = database_confs[environment.to_sym] database_conf.symbolize_keys! @@ -122,22 +123,24 @@ searchd } CONFIG - ThinkingSphinx.indexed_models.each do |model| + ThinkingSphinx.indexed_models.each_with_index do |model, model_index| model = model.constantize sources = [] delta_sources = [] prefixed_fields = [] infixed_fields = [] - model.indexes.each_with_index do |index, i| - file.write index.to_config(i, database_conf, charset_type) + model.indexes.select { |index| index.model == model }.each_with_index do |index, i| + file.write index.to_config(model, i, database_conf, charset_type, model_index) create_array_accum if index.adapter == :postgres - sources << "#{model.indexes.first.name}_#{i}_core" - delta_sources << "#{model.indexes.first.name}_#{i}_delta" if index.delta? + sources << "#{ThinkingSphinx::Index.name(model)}_#{i}_core" + delta_sources << "#{ThinkingSphinx::Index.name(model)}_#{i}_delta" if index.delta? end - source_list = sources.collect { |s| "source = #{s}" }.join("\n") + next if sources.empty? + + source_list = sources.collect { |s| "source = #{s}" }.join("\n") delta_list = delta_sources.collect { |s| "source = #{s}" }.join("\n") file.write core_index_for_model(model, source_list) @@ -167,8 +170,7 @@ searchd begin model_name.camelize.constantize rescue LoadError - model_name.gsub!(/.*[\/\\]/, '') - retry + model_name.gsub!(/.*[\/\\]/, '').nil? ? next : retry rescue NameError next end @@ -194,10 +196,10 @@ searchd def core_index_for_model(model, sources) output = <<-INDEX -index #{model.indexes.first.name}_core +index #{ThinkingSphinx::Index.name(model)}_core { #{sources} -path = #{self.searchd_file_path}/#{model.indexes.first.name}_core +path = #{self.searchd_file_path}/#{ThinkingSphinx::Index.name(model)}_core charset_type = #{self.charset_type} INDEX @@ -209,20 +211,30 @@ INDEX output += " ignore_chars = #{self.ignore_chars}\n" unless self.ignore_chars.nil? if self.allow_star + # Ye Olde way of turning on enable_star output += " enable_star = 1\n" output += " min_prefix_len = #{self.min_prefix_len}\n" - output += " min_infix_len = #{self.min_infix_len}\n" + else + # New, better way of turning on enable_star - thanks to James Healy + output += " enable_star = 1\n" if self.enable_star + output += " min_prefix_len = #{self.min_prefix_len}\n" unless self.min_prefix_len.nil? + output += " min_infix_len = #{self.min_infix_len}\n" unless self.min_infix_len.nil? end + output += " html_strip = 1\n" if self.html_strip output += " html_remove_elements = #{self.html_remove_elements}\n" unless self.html_remove_elements.blank? unless model.indexes.collect(&:prefix_fields).flatten.empty? - output += " prefix_fields = #{model.indexes.collect(&:prefix_fields).flatten.join(', ')}\n" + output += " prefix_fields = #{model.indexes.collect(&:prefix_fields).flatten.map(&:unique_name).join(', ')}\n" + else + output += " prefix_fields = _\n" unless model.indexes.collect(&:infix_fields).flatten.empty? end unless model.indexes.collect(&:infix_fields).flatten.empty? - output += " infix_fields = #{model.indexes.collect(&:infix_fields).flatten.join(', ')}\n" + output += " infix_fields = #{model.indexes.collect(&:infix_fields).flatten.map(&:unique_name).join(', ')}\n" + else + output += " infix_fields = -\n" unless model.indexes.collect(&:prefix_fields).flatten.empty? end output + "}\n" @@ -230,22 +242,22 @@ INDEX def delta_index_for_model(model, sources) <<-INDEX -index #{model.indexes.first.name}_delta : #{model.indexes.first.name}_core +index #{ThinkingSphinx::Index.name(model)}_delta : #{ThinkingSphinx::Index.name(model)}_core { #{sources} - path = #{self.searchd_file_path}/#{model.indexes.first.name}_delta + path = #{self.searchd_file_path}/#{ThinkingSphinx::Index.name(model)}_delta } INDEX end def distributed_index_for_model(model) - sources = ["local = #{model.indexes.first.name}_core"] + sources = ["local = #{ThinkingSphinx::Index.name(model)}_core"] if model.indexes.any? { |index| index.delta? } - sources << "local = #{model.indexes.first.name}_delta" + sources << "local = #{ThinkingSphinx::Index.name(model)}_delta" end <<-INDEX -index #{model.indexes.first.name} +index #{ThinkingSphinx::Index.name(model)} { type = distributed #{ sources.join("\n ") } lib/thinking_sphinx/configuration.rb @@ -178,7 +178,9 @@ module ThinkingSphinx # figure out how to correctly reference a column in SQL. # def column_with_prefix(column) - if associations[column].empty? + if column.is_string? + column.__name + elsif associations[column].empty? "#{@model.quoted_table_name}.#{quote_column(column.__name)}" else associations[column].collect { |assoc| @@ -196,5 +198,9 @@ module ThinkingSphinx def is_many? associations.values.flatten.any? { |assoc| assoc.is_many? } end + + def is_string? + columns.all? { |col| col.is_string? } + end end end lib/thinking_sphinx/field.rb @@ -38,6 +38,10 @@ module ThinkingSphinx end def name + self.class.name(@model) + end + + def self.name(model) model.name.underscore.tr(':/\\', '_') end @@ -46,8 +50,9 @@ module ThinkingSphinx File.size?("#{config.searchd_file_path}/#{self.name}_#{part}.spa").nil? end - def to_config(index, database_conf, charset_type) + def to_config(model, index, database_conf, charset_type, offset) # Set up associations and joins + add_internal_attributes link! attr_sources = attributes.collect { |attrib| @@ -65,20 +70,21 @@ module ThinkingSphinx config = <<-SOURCE -source #{model.indexes.first.name}_#{index}_core +source #{self.class.name(model)}_#{index}_core { type = #{db_adapter} sql_host = #{database_conf[:host] || "localhost"} -sql_user = #{database_conf[:username]} -sql_pass = #{database_conf[:password]} +sql_user = #{database_conf[:username] || database_conf[:user]} +sql_pass = #{(database_conf[:password] || "").gsub('#', '\#')} sql_db = #{database_conf[:database]} +#{"sql_sock = #{database_conf[:socket]}" unless database_conf[:socket].blank? } sql_query_pre = #{charset_type == "utf-8" && adapter == :mysql ? "SET NAMES utf8" : ""} #{"sql_query_pre = SET SESSION group_concat_max_len = #{@options[:group_concat_max_len]}" if @options[:group_concat_max_len]} sql_query_pre = #{to_sql_query_pre} -sql_query = #{to_sql.gsub(/\n/, ' ')} +sql_query = #{to_sql(:offset => offset).gsub(/\n/, ' ')} sql_query_range = #{to_sql_query_range} -sql_query_info = #{to_sql_query_info} +sql_query_info = #{to_sql_query_info(offset)} #{attr_sources} } SOURCE @@ -86,12 +92,12 @@ sql_query_info = #{to_sql_query_info} if delta? config += <<-SOURCE -source #{model.indexes.first.name}_#{index}_delta : #{model.indexes.first.name}_#{index}_core +source #{self.class.name(model)}_#{index}_delta : #{self.class.name(model)}_#{index}_core { sql_query_pre = sql_query_pre = #{charset_type == "utf-8" && adapter == :mysql ? "SET NAMES utf8" : ""} #{"sql_query_pre = SET SESSION group_concat_max_len = #{@options[:group_concat_max_len]}" if @options[:group_concat_max_len]} -sql_query = #{to_sql(:delta => true).gsub(/\n/, ' ')} +sql_query = #{to_sql(:delta => true, :offset => offset).gsub(/\n/, ' ')} sql_query_range = #{to_sql_query_range :delta => true} } SOURCE @@ -149,9 +155,11 @@ sql_query_range = #{to_sql_query_range :delta => true} where_clause << " AND " << @conditions.join(" AND ") end + unique_id_expr = "* #{ThinkingSphinx.indexed_models.size} + #{options[:offset] || 0}" + sql = <<-SQL SELECT #{ ( - ["#{@model.quoted_table_name}.#{quote_column(@model.primary_key)}"] + + ["#{@model.quoted_table_name}.#{quote_column(@model.primary_key)} #{unique_id_expr} AS #{quote_column(@model.primary_key)} "] + @fields.collect { |field| field.to_select_sql } + @attributes.collect { |attribute| attribute.to_select_sql } ).join(", ") } @@ -177,9 +185,9 @@ GROUP BY #{ ( # 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 + def to_sql_query_info(offset) "SELECT * FROM #{@model.quoted_table_name} WHERE " + - " #{quote_column(@model.primary_key)} = $id" + " #{quote_column(@model.primary_key)} = (($id - #{offset}) / #{ThinkingSphinx.indexed_models.size})" end # Simple helper method for the query range SQL - which is a statement that @@ -265,17 +273,6 @@ GROUP BY #{ ( @conditions = builder.conditions @delta = builder.properties[:delta] @options = builder.properties.except(:delta) - - @attributes << Attribute.new( - FauxColumn.new(@model.to_crc32.to_s), - :type => :integer, - :as => :class_crc - ) - @attributes << Attribute.new( - FauxColumn.new("0"), - :type => :integer, - :as => :sphinx_deleted - ) end # Returns all associations used amongst all the fields and attributes. @@ -335,5 +332,43 @@ GROUP BY #{ ( val ? '1' : '0' end end + + def crc_column + if adapter == :postgres + @model.to_crc32.to_s + elsif @model.column_names.include?(@model.inheritance_column) + "IFNULL(CRC32(#{@model.quoted_table_name}.#{quote_column(@model.inheritance_column)}), #{@model.to_crc32.to_s})" + else + @model.to_crc32.to_s + end + end + + def add_internal_attributes + @attributes << Attribute.new( + FauxColumn.new(:id), + :type => :integer, + :as => :sphinx_internal_id + ) unless @attributes.detect { |attr| attr.alias == :sphinx_internal_id } + + @attributes << Attribute.new( + FauxColumn.new(crc_column), + :type => :integer, + :as => :class_crc + ) unless @attributes.detect { |attr| attr.alias == :class_crc } + + @attributes << Attribute.new( + FauxColumn.new("'" + (@model.send(:subclasses).collect { |klass| + klass.to_crc32.to_s + } << @model.to_crc32.to_s).join(",") + "'"), + :type => :multi, + :as => :subclass_crcs + ) unless @attributes.detect { |attr| attr.alias == :subclass_crcs } + + @attributes << Attribute.new( + FauxColumn.new("0"), + :type => :integer, + :as => :sphinx_deleted + ) unless @attributes.detect { |attr| attr.alias == :sphinx_deleted } + end end end lib/thinking_sphinx/index.rb @@ -81,8 +81,7 @@ module ThinkingSphinx def indexes(*args) options = args.extract_options! args.each do |columns| - columns = FauxColumn.new(columns) if columns.is_a?(Symbol) - fields << Field.new(columns, options) + fields << Field.new(FauxColumn.coerce(columns), options) if fields.last.sortable attributes << Attribute.new( @@ -137,23 +136,7 @@ module ThinkingSphinx def has(*args) options = args.extract_options! args.each do |columns| - columns = case columns - when Symbol, String - FauxColumn.new(columns) - when Array - columns.collect { |col| - case col - when Symbol, String - FauxColumn.new(col) - else - col - end - } - else - columns - end - - attributes << Attribute.new(columns, options) + attributes << Attribute.new(FauxColumn.coerce(columns), options) end end alias_method :attribute, :has lib/thinking_sphinx/index/builder.rb @@ -15,6 +15,19 @@ module ThinkingSphinx @stack = stack end + def self.coerce(columns) + case columns + when Symbol, String + FauxColumn.new(columns) + when Array + columns.collect { |col| FauxColumn.coerce(col) } + when FauxColumn + columns + else + nil + end + end + # Can't use normal method name, as that could be an association or # column name. # lib/thinking_sphinx/index/faux_column.rb @@ -5,7 +5,7 @@ module ThinkingSphinx # Most times, you will just want a specific model's results - to search and # search_for_ids methods will do the job in exactly the same manner when # called from a model. - # + # class Search class << self # Searches for results that match the parameters provided. Will only @@ -14,18 +14,25 @@ module ThinkingSphinx # def search_for_ids(*args) results, client = search_results(*args.clone) - + options = args.extract_options! page = options[:page] ? options[:page].to_i : 1 - + begin pager = WillPaginate::Collection.create(page, client.limit, results[:total_found] || 0) do |collection| - collection.replace results[:matches].collect { |match| match[:doc] } + collection.replace results[:matches].collect { |match| + match[:attributes]["sphinx_internal_id"] + } collection.instance_variable_set :@total_entries, results[:total_found] end + return (options[:include_raw] ? [pager, results] : pager) rescue - results[:matches].collect { |match| match[:doc] } + if options[:include_raw] + return results[:matches].collect{ |match| match[:attributes]["sphinx_internal_id"] }, results + else + return results[:matches].collect { |match| match[:attributes]["sphinx_internal_id"] } + end end end @@ -37,11 +44,11 @@ module ThinkingSphinx # just like paginate. The same parameters - :page and :per_page - work as # expected, and the returned result set can be used by the will_paginate # helper. - # + # # == Basic Searching # # The simplest way of searching is straight text. - # + # # ThinkingSphinx::Search.search "pat" # ThinkingSphinx::Search.search "google" # User.search "pat", :page => (params[:page] || 1) @@ -49,7 +56,7 @@ module ThinkingSphinx # # If you specify :include, like in an #find call, this will be respected # when loading the relevant models from the search results. - # + # # User.search "pat", :include => :posts # # == Advanced Searching @@ -71,10 +78,10 @@ module ThinkingSphinx # details. # # == Searching by Fields - # + # # If you want to step it up a level, you can limit your search terms to # specific fields: - # + # # User.search :conditions => {:name => "pat"} # # This uses Sphinx's extended match mode, unless you specify a different @@ -94,11 +101,11 @@ module ThinkingSphinx # (not multi-model searching). With a single model, Thinking Sphinx # can figure out what attributes and fields are available, so you can # put it all in the :conditions hash, and it will sort it out. - # + # # Node.search :conditions => {:parent_id => 10} - # + # # Filters can be single values, arrays of values, or ranges. - # + # # Article.search "East Timor", :conditions => {:rating => 3..5} # # == Excluding by Attributes @@ -107,7 +114,7 @@ module ThinkingSphinx # attribute values to exclude. This is done with the :without option: # # User.search :without => {:role_id => 1} - # + # # == Sorting # # Sphinx can only sort by attributes, so generally you will need to avoid @@ -132,13 +139,13 @@ module ThinkingSphinx # detail though. # # == Grouping - # + # # For this you can use the group_by, group_clause and group_function # options - which are all directly linked to Sphinx's expectations. No # magic from Thinking Sphinx. It can get a little tricky, so make sure # you read all the relevant # documentation[http://sphinxsearch.com/doc.html#clustering] first. - # + # # Yes this section will be expanded, but this is a start. # # == Geo/Location Searching @@ -148,11 +155,11 @@ module ThinkingSphinx # take advantage of this, you will need to have both of those values in # attributes. To search with that point, you can then use one of the # following syntax examples: - # + # # Address.search "Melbourne", :geo => [1.4, -2.217] # Address.search "Australia", :geo => [-0.55, 3.108], # :latitude_attr => "latit", :longitude_attr => "longit" - # + # # The first example applies when your latitude and longitude attributes # are named any of lat, latitude, lon, long or longitude. If that's not # the case, you will need to explicitly state them in your search, _or_ @@ -161,17 +168,17 @@ module ThinkingSphinx # define_index do # has :latit # Float column, stored in radians # has :longit # Float column, stored in radians - # + # # set_property :latitude_attr => "latit" # set_property :longitude_attr => "longit" # end - # + # # Now, geo-location searching really only has an affect if you have a # filter, sort or grouping clause related to it - otherwise it's just a # normal search. To make use of the positioning difference, use the # special attribute "@geodist" in any of your filters or sorting or grouping # clauses. - # + # # And don't forget - both the latitude and longitude you use in your # search, and the values in your indexes, need to be stored as a float in radians, # _not_ degrees. Keep in mind that if you do this conversion in SQL @@ -181,77 +188,90 @@ module ThinkingSphinx # has 'RADIANS(lat)', :as => :lat, :type => :float # # ... # end - # + # def search(*args) results, client = search_results(*args.clone) - + ::ActiveRecord::Base.logger.error( "Sphinx Error: #{results[:error]}" ) if results[:error] - + options = args.extract_options! klass = options[:class] page = options[:page] ? options[:page].to_i : 1 - - begin - pager = WillPaginate::Collection.create(page, - client.limit, results[:total] || 0) do |collection| - collection.replace instances_from_results(results[:matches], options, klass) - collection.instance_variable_set :@total_entries, results[:total_found] - end - rescue StandardError => err - instances_from_results(results[:matches], options, klass) - end + + # begin + pager = ThinkingSphinx::Collection.new(page, client.limit, + results[:total] || 0, results[:total_found] || 0) + pager.replace instances_from_results(results[:matches], options, klass) + # pager = WillPaginate::Collection.create(page, + # client.limit, results[:total] || 0) do |collection| + # collection.replace instances_from_results(results[:matches], options, klass) + # collection.instance_variable_set :@total_entries, results[:total_found] + # end + return (options[:include_raw] ? [pager, results] : pager) + # rescue StandardError => err + # if options[:include_raw] + # return instances_from_results(results[:matches], options, klass), results + # else + # return instances_from_results(results[:matches], options, klass) + # end + # end end - + + def count(*args) + results, client = search_results(*args.clone) + results[:total] || 0 + end + # Checks if a document with the given id exists within a specific index. # Expected parameters: # # - ID of the document # - Index to check within # - Options hash (defaults to {}) - # + # # Example: - # + # # ThinkingSphinx::Search.search_for_id(10, "user_core", :class => User) - # + # def search_for_id(*args) options = args.extract_options! client = client_from_options options - + query, filters = search_conditions( options[:class], options[:conditions] || {} ) client.filters += filters client.match_mode = :extended unless query.empty? client.id_range = args.first..args.first - + begin return client.query(query, args[1])[:matches].length > 0 rescue Errno::ECONNREFUSED => err raise ThinkingSphinx::ConnectionError, "Connection to Sphinx Daemon (searchd) failed." end end - + private - + # This method handles the common search functionality, and returns both # the result hash and the client. Not super elegant, but it'll do for # the moment. - # + # def search_results(*args) options = args.extract_options! client = client_from_options options - + query, filters = search_conditions( options[:class], options[:conditions] || {} ) client.filters += filters client.match_mode = :extended unless query.empty? query = args.join(" ") + query - + set_sort_options! client, options - + client.limit = options[:per_page].to_i if options[:per_page] page = options[:page] ? options[:page].to_i : 1 client.offset = (page - 1) * client.limit @@ -259,53 +279,69 @@ module ThinkingSphinx begin ::ActiveRecord::Base.logger.debug "Sphinx: #{query}" results = client.query query - ::ActiveRecord::Base.logger.debug "Sphinx Result: #{results[:matches].collect{|m| m[:doc]}.inspect}" + ::ActiveRecord::Base.logger.debug "Sphinx Result: #{results[:matches].collect{|m| m[:attributes]["sphinx_internal_id"]}.inspect}" rescue Errno::ECONNREFUSED => err raise ThinkingSphinx::ConnectionError, "Connection to Sphinx Daemon (searchd) failed." end - + return results, client end - + + # This function loops over the records and appends a 'distance' variable to each one with + # the value from Sphinx + def append_distances(instances, results, distance_name) + instances.each_with_index do |record, index| + if record + distance = (results[index][:attributes]['@geodist'] or nil) + record.instance_variable_get('@attributes')["#{distance_name}"] = distance + end + end + end + def instances_from_results(results, options = {}, klass = nil) if klass.nil? results.collect { |result| instance_from_result result, options } else - ids = results.collect { |result| result[:doc] } - instances = klass.find( + ids = results.collect { |result| result[:attributes]["sphinx_internal_id"] } + instances = ids.length > 0 ? klass.find( :all, :conditions => {klass.primary_key.to_sym => ids}, :include => options[:include], :select => options[:select] - ) - ids.collect { |obj_id| instances.detect { |obj| obj.id == obj_id } } + ) : [] + final_instances = ids.collect { |obj_id| instances.detect { |obj| obj.id == obj_id } } + + final_instances = append_distances(final_instances, results, options[:distance_name]) if options[:distance_name] && (results.collect { |result| result[:attributes]['@geodist'] }.length > 0) + + return final_instances end end - + # Either use the provided class to instantiate a result from a model, or # get the result's CRC value and determine the class from that. - # + # def instance_from_result(result, options) class_from_crc(result[:attributes]["class_crc"]).find( - result[:doc], :include => options[:include], :select => options[:select] + result[:attributes]["sphinx_internal_id"], + :include => options[:include], :select => options[:select] ) end - + # Convert a CRC value to the corresponding class. - # + # def class_from_crc(crc) unless @models_by_crc Configuration.new.load_models - + @models_by_crc = ThinkingSphinx.indexed_models.inject({}) do |hash, model| hash[model.constantize.to_crc32] = model hash end end - + @models_by_crc[crc].constantize end - + # Set all the appropriate settings for the client, using the provided # options hash. # @@ -314,7 +350,7 @@ module ThinkingSphinx client = Riddle::Client.new config.address, config.port klass = options[:class] index_options = klass ? klass.indexes.last.options : {} - + [ :max_matches, :match_mode, :sort_mode, :sort_by, :id_range, :group_by, :group_function, :group_clause, :group_distinct, :cut_off, @@ -327,29 +363,32 @@ module ThinkingSphinx ) end - client.anchor = anchor_conditions(klass, options) || {} if client.anchor.empty? + options[:classes] = [klass] if klass + client.anchor = anchor_conditions(klass, options) || {} if client.anchor.empty? + client.filters << Riddle::Client::Filter.new( "sphinx_deleted", [0] ) + # class filters client.filters << Riddle::Client::Filter.new( - "class_crc", options[:classes].collect { |klass| klass.to_crc32 } + "class_crc", options[:classes].collect { |k| k.to_crc32s }.flatten ) if options[:classes] - + # normal attribute filters client.filters += options[:with].collect { |attr,val| Riddle::Client::Filter.new attr.to_s, filter_value(val) } if options[:with] - + # exclusive attribute filters client.filters += options[:without].collect { |attr,val| Riddle::Client::Filter.new attr.to_s, filter_value(val), true } if options[:without] - + client end - + def filter_value(value) case value when Range @@ -360,70 +399,65 @@ module ThinkingSphinx Array(value) end end - + # Translate field and attribute conditions to the relevant search string # and filters. - # + # def search_conditions(klass, conditions={}) attributes = klass ? klass.indexes.collect { |index| index.attributes.collect { |attrib| attrib.unique_name } }.flatten : [] - + search_string = "" filters = [] - + conditions.each do |key,val| if attributes.include?(key.to_sym) filters << Riddle::Client::Filter.new( - key.to_s, - val.is_a?(Range) ? val : Array(val) + key.to_s, filter_value(val) ) else search_string << "@#{key} #{val} " end end - filters << Riddle::Client::Filter.new( - "class_crc", [klass.to_crc32] - ) if klass - return search_string, filters end - + # Return the appropriate latitude and longitude values, depending on # whether the relevant attributes have been defined, and also whether # there's actually any values. - # + # def anchor_conditions(klass, options) attributes = klass ? klass.indexes.collect { |index| index.attributes.collect { |attrib| attrib.unique_name } }.flatten : [] - + lat_attr = klass ? klass.indexes.collect { |index| index.options[:latitude_attr] }.compact.first : nil - + lon_attr = klass ? klass.indexes.collect { |index| index.options[:longitude_attr] }.compact.first : nil - + lat_attr = options[:latitude_attr] if options[:latitude_attr] lat_attr ||= :lat if attributes.include?(:lat) lat_attr ||= :latitude if attributes.include?(:latitude) - + lon_attr = options[:longitude_attr] if options[:longitude_attr] lon_attr ||= :lon if attributes.include?(:lon) lon_attr ||= :long if attributes.include?(:long) lon_attr ||= :longitude if attributes.include?(:longitude) - + lat = options[:lat] lon = options[:lon] - + if options[:geo] lat = options[:geo].first lon = options[:geo].last end - + lat && lon ? { :latitude_attribute => lat_attr, :latitude => lat, @@ -431,16 +465,16 @@ module ThinkingSphinx :longitude => lon } : nil end - + # Set the sort options using the :order key as well as the appropriate # Riddle settings. - # + # def set_sort_options!(client, options) klass = options[:class] fields = klass ? klass.indexes.collect { |index| index.fields.collect { |field| field.unique_name } }.flatten : [] - + case order = options[:order] when Symbol client.sort_mode = :attr_asc if client.sort_mode == :relevance || client.sort_mode.nil? @@ -455,23 +489,23 @@ module ThinkingSphinx else # do nothing end - + client.sort_mode = :attr_asc if client.sort_mode == :asc client.sort_mode = :attr_desc if client.sort_mode == :desc end - + # Search through a collection of fields and translate any appearances # of them in a string to their attribute equivalent for sorting. - # + # def sorted_fields_to_attributes(string, fields) fields.each { |field| string.gsub!(/(^|\s)#{field}(,?\s|$)/) { |match| match.gsub field.to_s, field.to_s.concat("_sort") } } - + string end end end -end +end \ No newline at end of file lib/thinking_sphinx/search.rb @@ -3,15 +3,23 @@ $:.unshift File.dirname(__FILE__) + '/../lib' require 'rubygems' require 'fileutils' require 'not_a_mock' +require 'will_paginate' require 'lib/thinking_sphinx' require 'spec/sphinx_helper' +ActiveRecord::Base.logger = Logger.new(StringIO.new) + Spec::Runner.configure do |config| - # config.mock_with NotAMock::RspecMockFrameworkAdapter + %w( tmp tmp/config tmp/log tmp/db ).each do |path| + FileUtils.mkdir_p "#{Dir.pwd}/#{path}" + end + + Kernel.const_set :RAILS_ROOT, "#{Dir.pwd}/tmp" unless defined?(RAILS_ROOT) sphinx = SphinxHelper.new sphinx.setup_mysql + require 'spec/fixtures/models' config.before :all do @@ -19,19 +27,18 @@ Spec::Runner.configure do |config| FileUtils.mkdir_p "#{Dir.pwd}/#{path}" end - Kernel.const_set :RAILS_ROOT, "#{Dir.pwd}/tmp" unless defined?(RAILS_ROOT) - - # sphinx.start + sphinx.setup_sphinx + sphinx.start end - config.before :each do + config.after :each do NotAMock::CallRecorder.instance.reset NotAMock::Stubber.instance.reset end config.after :all do - # sphinx.stop + sphinx.stop - FileUtils.rm_r "#{Dir.pwd}/tmp" + FileUtils.rm_r "#{Dir.pwd}/tmp" rescue nil end end spec/spec_helper.rb @@ -1,6 +1,10 @@ require 'active_record' require 'active_record/connection_adapters/mysql_adapter' -require 'active_record/connection_adapters/postgresql_adapter' +begin + require 'active_record/connection_adapters/postgresql_adapter' +rescue LoadError + # No postgres? no prob... +end require 'yaml' class SphinxHelper @@ -30,7 +34,7 @@ class SphinxHelper :password => @password, :host => @host ) - # ActiveRecord::Base.logger = nil + ActiveRecord::Base.logger = Logger.new(File.open("tmp/activerecord.log", "a")) structure = File.open("spec/fixtures/structure.sql") { |f| f.read.chomp } structure.split(';').each { |table| @@ -44,7 +48,62 @@ class SphinxHelper } end + def setup_sphinx + @configuration = ThinkingSphinx::Configuration.new + File.open("spec/fixtures/sphinx/database.yml", "w") do |file| + YAML.dump({@configuration.environment => { + :adapter => 'mysql', + :host => @host, + :database => "thinking_sphinx", + :username => @username, + :password => @password + }}, file) + end + FileUtils.mkdir_p(@configuration.searchd_file_path) + + @configuration.database_yml_file = "spec/fixtures/sphinx/database.yml" + @configuration.build + + index + end + def reset setup_mysql end + + def index + cmd = "indexer --config #{@configuration.config_file} --all" + cmd << " --rotate" if running? + `#{cmd}` + end + + def start + return if running? + + cmd = "searchd --config #{@configuration.config_file}" + `#{cmd}` + + sleep(1) + + unless running? + puts "Failed to start searchd daemon. Check #{@configuration.searchd_log_file}." + end + end + + def stop + return unless running? + `kill #{pid}` + end + + def pid + if File.exists?("#{@configuration.pid_file}") + `cat #{@configuration.pid_file}`[/\d+/] + else + nil + end + end + + def running? + pid && `ps #{pid} | wc -l`.to_i > 1 + end end spec/sphinx_helper.rb @@ -9,6 +9,10 @@ describe "ThinkingSphinx::ActiveRecord::Search" do ActiveRecord::Base.methods.should include("search") end + it "should add search_count to ActiveRecord::Base" do + ActiveRecord::Base.methods.should include("search_count") + end + it "should add search_for_id to ActiveRecord::Base" do ActiveRecord::Base.methods.should include("search_for_id") end @@ -78,4 +82,26 @@ describe "ThinkingSphinx::ActiveRecord::Search" do ) end end + + describe "search_count method" do + before :each do + ThinkingSphinx::Search.stub_method(:count => true) + end + + it "should call ThinkingSphinx::Search#search with the class option set" do + Person.search_count("search") + + ThinkingSphinx::Search.should have_received(:count).with( + "search", :class => Person + ) + end + + it "should override the class option" do + Person.search_count("search", :class => Friendship) + + ThinkingSphinx::Search.should have_received(:count).with( + "search", :class => Person + ) + end + end end spec/unit/thinking_sphinx/active_record/search_spec.rb @@ -21,7 +21,7 @@ describe "ThinkingSphinx::ActiveRecord" do # Remove the class so we can redefine it TestModule.send(:remove_const, :TestModel) - ThinkingSphinx::Index.unstub_method(:new) + ThinkingSphinx.indexed_models.delete "TestModule::TestModel" end it "should return nil and do nothing if indexes are disabled" do spec/unit/thinking_sphinx/active_record_spec.rb @@ -36,7 +36,7 @@ describe ThinkingSphinx::Configuration do ThinkingSphinx::Configuration.stub_method(:environment => "spec") ThinkingSphinx::Configuration.new.environment.should == "spec" ThinkingSphinx::Configuration.should have_received(:environment) - end + end end describe "build method" do @@ -59,13 +59,16 @@ describe ThinkingSphinx::Configuration do }) @person_index_a = ThinkingSphinx::Index.stub_instance( - :to_config => "", :adapter => :mysql, :delta? => false, :name => "person" + :to_config => "", :adapter => :mysql, :delta? => false, + :name => "person", :model => Person ) @person_index_b = ThinkingSphinx::Index.stub_instance( - :to_config => "", :adapter => :mysql, :delta? => false, :name => "person" + :to_config => "", :adapter => :mysql, :delta? => false, + :name => "person", :model => Person ) @friendship_index_a = ThinkingSphinx::Index.stub_instance( - :to_config => "", :adapter => :mysql, :delta? => false, :name => "friendship" + :to_config => "", :adapter => :mysql, :delta? => false, + :name => "friendship", :model => Friendship ) Person.stub_method(:indexes => [@person_index_a, @person_index_b]) @@ -81,15 +84,15 @@ describe ThinkingSphinx::Configuration do Person.unstub_method :indexes Friendship.unstub_method :indexes - - FileUtils.rm_rf "#{@config.app_root}/config" + # + # FileUtils.rm_rf "#{@config.app_root}/config" end - it "should load the models" do - @config.build - - @config.should have_received(:load_models) - end + # it "should load the models" do + # @config.build + # + # @config.should have_received(:load_models) + # end it "should load in the database YAML configuration" do @config.build @@ -137,13 +140,13 @@ describe ThinkingSphinx::Configuration do @config.build @person_index_a.should have_received(:to_config).with( - 0, {:option => "value"}, @config.charset_type + Person, 0, {:option => "value"}, @config.charset_type, 0 ) @person_index_b.should have_received(:to_config).with( - 1, {:option => "value"}, @config.charset_type + Person, 1, {:option => "value"}, @config.charset_type, 0 ) @friendship_index_a.should have_received(:to_config).with( - 0, {:option => "value"}, @config.charset_type + Friendship, 0, {:option => "value"}, @config.charset_type, 1 ) end @@ -204,7 +207,7 @@ describe ThinkingSphinx::Configuration do before :each do @settings = { "development" => { - "config_file" => "my_conf_file.conf", + "config_file" => "tmp/config/development.sphinx.conf", "searchd_log_file" => "searchd_log_file.log", "query_log_file" => "query_log_file.log", "pid_file" => "pid_file.pid", @@ -222,7 +225,7 @@ describe ThinkingSphinx::Configuration do "ignore_chars" => "e" } } - # puts YAML.dump(settings) + open("#{RAILS_ROOT}/config/sphinx.yml", "w") do |f| f.write YAML.dump(@settings) end @@ -234,14 +237,16 @@ describe ThinkingSphinx::Configuration do config.send(key).should == value end end + + after :each do + FileUtils.rm "#{RAILS_ROOT}/config/sphinx.yml" + end end describe "core_index_for_model method" do before :each do @config = ThinkingSphinx::Configuration.new - @model = Class.stub_instance( - :indexes => [ThinkingSphinx::Index.new(Person)] - ) + @model = Person end it "should take its name from the model, with _core appended" do @@ -312,12 +317,13 @@ describe ThinkingSphinx::Configuration do end it "should include the star-related settings when allow_star is true" do - @config.allow_star = true + @config.allow_star = true + @config.min_prefix_len = 1 text = @config.send(:core_index_for_model, @model, "my sources") text.should match(/enable_star\s+= 1/) text.should match(/min_prefix_len\s+= 1/) - text.should match(/min_infix_len\s+= 1/) + # text.should match(/min_infix_len\s+= 1/) end it "should use the configuration's infix and prefix length values if set" do @@ -327,7 +333,7 @@ describe ThinkingSphinx::Configuration do text = @config.send(:core_index_for_model, @model, "my sources") text.should match(/min_prefix_len\s+= 3/) - text.should match(/min_infix_len\s+= 2/) + # text.should match(/min_infix_len\s+= 2/) end it "should not include the star-related settings when allow_star is false" do @@ -341,8 +347,16 @@ describe ThinkingSphinx::Configuration do it "should set prefix_fields if any fields are flagged explicitly" do @model.indexes.first.stub_methods( - :prefix_fields => ["a", "b", "c"], - :infix_fields => ["d", "e", "f"] + :prefix_fields => [ + ThinkingSphinx::Field.stub_instance(:unique_name => "a"), + ThinkingSphinx::Field.stub_instance(:unique_name => "b"), + ThinkingSphinx::Field.stub_instance(:unique_name => "c") + ], + :infix_fields => [ + ThinkingSphinx::Field.stub_instance(:unique_name => "d"), + ThinkingSphinx::Field.stub_instance(:unique_name => "e"), + ThinkingSphinx::Field.stub_instance(:unique_name => "f") + ] ) @config.send(:core_index_for_model, @model, "my sources").should match( @@ -358,8 +372,16 @@ describe ThinkingSphinx::Configuration do it "should set infix_fields if any fields are flagged explicitly" do @model.indexes.first.stub_methods( - :prefix_fields => ["a", "b", "c"], - :infix_fields => ["d", "e", "f"] + :prefix_fields => [ + ThinkingSphinx::Field.stub_instance(:unique_name => "a"), + ThinkingSphinx::Field.stub_instance(:unique_name => "b"), + ThinkingSphinx::Field.stub_instance(:unique_name => "c") + ], + :infix_fields => [ + ThinkingSphinx::Field.stub_instance(:unique_name => "d"), + ThinkingSphinx::Field.stub_instance(:unique_name => "e"), + ThinkingSphinx::Field.stub_instance(:unique_name => "f") + ] ) @config.send(:core_index_for_model, @model, "my sources").should match( @@ -399,9 +421,7 @@ describe ThinkingSphinx::Configuration do describe "delta_index_for_model method" do before :each do @config = ThinkingSphinx::Configuration.new - @model = Class.stub_instance( - :indexes => [ThinkingSphinx::Index.new(Person)] - ) + @model = Person end it "should take its name from the model, with _delta appended" do @@ -427,9 +447,7 @@ describe ThinkingSphinx::Configuration do describe "distributed_index_for_model method" do before :each do @config = ThinkingSphinx::Configuration.new - @model = Class.stub_instance( - :indexes => [ThinkingSphinx::Index.new(Person)] - ) + @model = Person end it "should take its name from the model" do spec/unit/thinking_sphinx/configuration_spec.rb @@ -166,6 +166,11 @@ describe ThinkingSphinx::Field do ) end + it "should return the column name if the column is a string" do + @field.columns = [ThinkingSphinx::Index::FauxColumn.new("string")] + @field.send(:column_with_prefix, @field.columns.first).should == "string" + end + it "should return the column with model's table prefix if there's no associations for the column" do @field.send(:column_with_prefix, @field.columns.first).should == "`people`.`col_name`" end spec/unit/thinking_sphinx/field_spec.rb @@ -17,6 +17,33 @@ describe ThinkingSphinx::Index::FauxColumn do # end + describe "coerce class method" do + before :each do + @column = ThinkingSphinx::Index::FauxColumn.stub_instance + ThinkingSphinx::Index::FauxColumn.stub_method(:new => @column) + end + + it "should return a single faux column if passed a string" do + ThinkingSphinx::Index::FauxColumn.coerce("string").should == @column + end + + it "should return a single faux column if passed a symbol" do + ThinkingSphinx::Index::FauxColumn.coerce(:string).should == @column + end + + it "should return an array of faux columns if passed an array of strings" do + ThinkingSphinx::Index::FauxColumn.coerce(["one", "two"]).should == [ + @column, @column + ] + end + + it "should return an array of faux columns if passed an array of symbols" do + ThinkingSphinx::Index::FauxColumn.coerce([:one, :two]).should == [ + @column, @column + ] + end + end + describe "method_missing calls with no arguments" do it "should push any further method calls into name, and the old name goes into the stack" do # spec/unit/thinking_sphinx/index/faux_column_spec.rb @@ -28,7 +28,7 @@ describe ThinkingSphinx::Index do end it "should call link!" do - @index.to_config(0, @database, "utf-8") + @index.to_config(Person, 0, @database, "utf-8", 0) @index.should have_received(:link!) end @@ -36,17 +36,17 @@ describe ThinkingSphinx::Index do it "should raise an exception if the adapter isn't mysql or postgres" do @index.stub_method(:adapter => :sqlite) - lambda { @index.to_config(0, @database, "utf-8") }.should raise_error + lambda { @index.to_config(Person, 0, @database, "utf-8", 0) }.should raise_error end it "should set the core source name to {model}_{index}_core" do - @index.to_config(0, @database, "utf-8").should match( + @index.to_config(Person, 0, @database, "utf-8", 0).should match( /source person_0_core/ ) end it "should include the database config supplied" do - conf = @index.to_config(0, @database, "utf-8") + conf = @index.to_config(Person, 0, @database, "utf-8", 0) conf.should match(/type\s+= mysql/) conf.should match(/sql_host\s+= localhost/) conf.should match(/sql_user\s+= username/) @@ -54,71 +54,89 @@ describe ThinkingSphinx::Index do conf.should match(/sql_db\s+= db/) end + it "should use 'user' if 'username' doesn't exist in database configuration" do + conf = @index.to_config(Person, 0, + @database.except(:username).merge(:user => "username"), + "utf-8", 0 + ) + conf.should match(/sql_user\s+= username/) + end + + it "should include the database socket if set" do + conf = @index.to_config(Person, 0, @database.merge(:socket => "dbsocket"), "utf-8", 0) + conf.should match(/sql_sock\s+= dbsocket/) + end + + it "should not include the database socket if not set" do + conf = @index.to_config(Person, 0, @database, "utf-8", 0) + conf.should_not match(/sql_sock/) + end + it "should have a pre query 'SET NAMES utf8' if using mysql and utf8 charset" do - @index.to_config(0, @database, "utf-8").should match( + @index.to_config(Person, 0, @database, "utf-8", 0).should match( /sql_query_pre\s+= SET NAMES utf8/ ) @index.stub_method(:delta? => true) - @index.to_config(0, @database, "utf-8").should match( + @index.to_config(Person, 0, @database, "utf-8", 0).should match( /source person_0_delta.+sql_query_pre\s+= SET NAMES utf8/m ) @index.stub_method(:delta? => false) - @index.to_config(0, @database, "non-utf-8").should_not match( + @index.to_config(Person, 0, @database, "non-utf-8", 0).should_not match( /SET NAMES utf8/ ) @index.stub_method(:adapter => :postgres) - @index.to_config(0, @database, "utf-8").should_not match( + @index.to_config(Person, 0, @database, "utf-8", 0).should_not match( /SET NAMES utf8/ ) end it "should use the pre query from the index" do - @index.to_config(0, @database, "utf-8").should match( + @index.to_config(Person, 0, @database, "utf-8", 0).should match( /sql_query_pre\s+= sql_query_pre/ ) end it "should not set group_concat_max_len if not specified" do - @index.to_config(0, @database, "utf-8").should_not match( + @index.to_config(Person, 0, @database, "utf-8", 0).should_not match( /group_concat_max_len/ ) end it "should set group_concat_max_len if specified" do @index.options.merge! :group_concat_max_len => 2056 - @index.to_config(0, @database, "utf-8").should match( + @index.to_config(Person, 0, @database, "utf-8", 0).should match( /sql_query_pre\s+= SET SESSION group_concat_max_len = 2056/ ) @index.stub_method(:delta? => true) - @index.to_config(0, @database, "utf-8").should match( + @index.to_config(Person, 0, @database, "utf-8", 0).should match( /source person_0_delta.+sql_query_pre\s+= SET SESSION group_concat_max_len = 2056/m ) end it "should use the main query from the index" do - @index.to_config(0, @database, "utf-8").should match( + @index.to_config(Person, 0, @database, "utf-8", 0).should match( /sql_query\s+= SQL/ ) end it "should use the range query from the index" do - @index.to_config(0, @database, "utf-8").should match( + @index.to_config(Person, 0, @database, "utf-8", 0).should match( /sql_query_range\s+= sql_query_range/ ) end - + it "should use the info query from the index" do - @index.to_config(0, @database, "utf-8").should match( + @index.to_config(Person, 0, @database, "utf-8", 0).should match( /sql_query_info\s+= sql_query_info/ ) end it "should include the attribute sources" do - @index.to_config(0, @database, "utf-8").should match( + @index.to_config(Person, 0, @database, "utf-8", 0).should match( /attr a\n\s+attr b/ ) end @@ -126,13 +144,13 @@ describe ThinkingSphinx::Index do it "should add a delta index with name {model}_{index}_delta if requested" do @index.stub_method(:delta? => true) - @index.to_config(0, @database, "utf-8").should match( + @index.to_config(Person, 0, @database, "utf-8", 0).should match( /source person_0_delta/ ) end it "should not add a delta index unless requested" do - @index.to_config(0, @database, "utf-8").should_not match( + @index.to_config(Person, 0, @database, "utf-8", 0).should_not match( /source person_0_delta/ ) end @@ -140,7 +158,7 @@ describe ThinkingSphinx::Index do it "should have the delta index inherit from the core index" do @index.stub_method(:delta? => true) - @index.to_config(0, @database, "utf-8").should match( + @index.to_config(Person, 0, @database, "utf-8", 0).should match( /source person_0_delta : person_0_core/ ) end @@ -148,7 +166,7 @@ describe ThinkingSphinx::Index do it "should redefine the main query for the delta index" do @index.stub_method(:delta? => true) - @index.to_config(0, @database, "utf-8").should match( + @index.to_config(Person, 0, @database, "utf-8", 0).should match( /source person_0_delta.+sql_query\s+= SQL/m ) end @@ -156,7 +174,7 @@ describe ThinkingSphinx::Index do it "should redefine the range query for the delta index" do @index.stub_method(:delta? => true) - @index.to_config(0, @database, "utf-8").should match( + @index.to_config(Person, 0, @database, "utf-8", 0).should match( /source person_0_delta.+sql_query_range\s+= sql_query_range/m ) end @@ -164,7 +182,7 @@ describe ThinkingSphinx::Index do it "should redefine the pre query for the delta index" do @index.stub_method(:delta? => true) - @index.to_config(0, @database, "utf-8").should match( + @index.to_config(Person, 0, @database, "utf-8", 0).should match( /source person_0_delta.+sql_query_pre\s+=\s*\n/m ) end @@ -238,7 +256,7 @@ describe ThinkingSphinx::Index do end after :each do - `rm #{@file_path}` if File.exists?(@file_path) + FileUtils.rm(@file_path, :force => true) end it "should return true if the core index files are empty" do spec/unit/thinking_sphinx/index_spec.rb @@ -1,6 +1,11 @@ require 'spec/spec_helper' +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( @@ -57,21 +62,29 @@ describe ThinkingSphinx::Search do it "should honour the :include option" do ThinkingSphinx::Search.send( :instance_from_result, - {:doc => 1, :attributes => {"class_crc" => 123}}, + { + :doc => 1, :attributes => { + "sphinx_internal_id" => 2, "class_crc" => 123 + } + }, {:include => :assoc} ) - Person.should have_received(:find).with(1, :include => :assoc, :select => nil) + 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 => {"class_crc" => 123}}, + { + :doc => 1, :attributes => { + "sphinx_internal_id" => 2, "class_crc" => 123 + } + }, {:select => :columns} ) - Person.should have_received(:find).with(1, :include => nil, :select => :columns) + Person.should have_received(:find).with(2, :include => nil, :select => :columns) end end @@ -82,10 +95,14 @@ describe ThinkingSphinx::Search do @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 = [ - {:doc => @person_a.id}, - {:doc => @person_b.id}, - {:doc => @person_c.id} + {:attributes => {"sphinx_internal_id" => @person_a.id}}, + {:attributes => {"sphinx_internal_id" => @person_b.id}}, + {:attributes => {"sphinx_internal_id" => @person_c.id}} ] Person.stub_method( @@ -105,13 +122,13 @@ describe ThinkingSphinx::Search do ) ThinkingSphinx::Search.should have_received(:instance_from_result).with( - {:doc => @person_a.id}, {} + {:attributes => {"sphinx_internal_id" => @person_a.id}}, {} ) ThinkingSphinx::Search.should have_received(:instance_from_result).with( - {:doc => @person_b.id}, {} + {:attributes => {"sphinx_internal_id" => @person_b.id}}, {} ) ThinkingSphinx::Search.should have_received(:instance_from_result).with( - {:doc => @person_c.id}, {} + {:attributes => {"sphinx_internal_id" => @person_c.id}}, {} ) end @@ -159,5 +176,83 @@ describe ThinkingSphinx::Search do :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 + + 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 end end spec/unit/thinking_sphinx/search_spec.rb @@ -99,6 +99,10 @@ describe ThinkingSphinx do describe "if not using MySQL" do before :each do + unless ::ActiveRecord::ConnectionAdapters.const_defined?(:PostgreSQLAdapter) + pending "No PostgreSQL" + return + end @connection = ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.stub_instance( :select_all => true ) spec/unit/thinking_sphinx_spec.rb @@ -3,7 +3,7 @@ require 'fileutils' namespace :thinking_sphinx do task :app_env do Rake::Task[:environment].invoke if defined?(RAILS_ROOT) - Rake::Task[:merb_env].invoke if defined?(Merb) + Rake::Task[:merb_init].invoke if defined?(Merb) end desc "Start a Sphinx searchd daemon using Thinking Sphinx's settings" tasks/thinking_sphinx_tasks.rb @@ -1,15 +1,21 @@ Gem::Specification.new do |s| - s.name = "thinking-sphinx" - s.version = "0.9.8" - 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 = ["spec/unit/thinking_sphinx/active_record/delta_spec.rb", "spec/unit/thinking_sphinx/active_record/has_many_association_spec.rb", "spec/unit/thinking_sphinx/active_record/search_spec.rb", "spec/unit/thinking_sphinx/active_record_spec.rb", "spec/unit/thinking_sphinx/association_spec.rb", "spec/unit/thinking_sphinx/attribute_spec.rb", "spec/unit/thinking_sphinx/configuration_spec.rb", "spec/unit/thinking_sphinx/field_spec.rb", "spec/unit/thinking_sphinx/index/builder_spec.rb", "spec/unit/thinking_sphinx/index/faux_column_spec.rb", "spec/unit/thinking_sphinx/index_spec.rb", "spec/unit/thinking_sphinx/search_spec.rb", "spec/unit/thinking_sphinx_spec.rb"] - s.files = ["lib/riddle/client/filter.rb", "lib/riddle/client/message.rb", "lib/riddle/client/response.rb", "lib/riddle/client.rb", "lib/riddle.rb", "lib/test.rb", "lib/thinking_sphinx/active_record/delta.rb", "lib/thinking_sphinx/active_record/has_many_association.rb", "lib/thinking_sphinx/active_record/search.rb", "lib/thinking_sphinx/active_record.rb", "lib/thinking_sphinx/association.rb", "lib/thinking_sphinx/attribute.rb", "lib/thinking_sphinx/configuration.rb", "lib/thinking_sphinx/field.rb", "lib/thinking_sphinx/index/builder.rb", "lib/thinking_sphinx/index/faux_column.rb", "lib/thinking_sphinx/index.rb", "lib/thinking_sphinx/rails_additions.rb", "lib/thinking_sphinx/search.rb", "lib/thinking_sphinx.rb", "LICENCE", "README", "tasks/thinking_sphinx_tasks.rb", "tasks/thinking_sphinx_tasks.rake"] -end \ No newline at end of file + s.name = %q{thinking-sphinx} + s.version = "0.9.9" + + s.specification_version = 2 if s.respond_to? :specification_version= + + s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version= + s.authors = ["Pat Allan"] + s.date = %q{2008-08-22} + s.description = %q{A concise and easy-to-use Ruby library that connects ActiveRecord to the Sphinx search daemon, managing configuration, indexing and searching.} + s.email = %q{pat@freelancing-gods.com} + s.files = ["lib/riddle/client/filter.rb", "lib/riddle/client/message.rb", "lib/riddle/client/response.rb", "lib/riddle/client.rb", "lib/riddle.rb", "lib/test.rb", "lib/thinking_sphinx/active_record/delta.rb", "lib/thinking_sphinx/active_record/has_many_association.rb", "lib/thinking_sphinx/active_record/search.rb", "lib/thinking_sphinx/active_record.rb", "lib/thinking_sphinx/association.rb", "lib/thinking_sphinx/attribute.rb", "lib/thinking_sphinx/collection.rb", "lib/thinking_sphinx/configuration.rb", "lib/thinking_sphinx/field.rb", "lib/thinking_sphinx/index/builder.rb", "lib/thinking_sphinx/index/faux_column.rb", "lib/thinking_sphinx/index.rb", "lib/thinking_sphinx/rails_additions.rb", "lib/thinking_sphinx/search.rb", "lib/thinking_sphinx.rb", "LICENCE", "README", "tasks/thinking_sphinx_tasks.rb", "tasks/thinking_sphinx_tasks.rake", "spec/unit/thinking_sphinx/active_record/delta_spec.rb", "spec/unit/thinking_sphinx/active_record/has_many_association_spec.rb", "spec/unit/thinking_sphinx/active_record/search_spec.rb", "spec/unit/thinking_sphinx/active_record_spec.rb", "spec/unit/thinking_sphinx/association_spec.rb", "spec/unit/thinking_sphinx/attribute_spec.rb", "spec/unit/thinking_sphinx/configuration_spec.rb", "spec/unit/thinking_sphinx/field_spec.rb", "spec/unit/thinking_sphinx/index/builder_spec.rb", "spec/unit/thinking_sphinx/index/faux_column_spec.rb", "spec/unit/thinking_sphinx/index_spec.rb", "spec/unit/thinking_sphinx/search_spec.rb", "spec/unit/thinking_sphinx_spec.rb"] + s.has_rdoc = true + s.homepage = %q{http://ts.freelancing-gods.com} + s.rdoc_options = ["--title", "Thinking Sphinx -- Rails/Merb Sphinx Plugin", "--line-numbers"] + s.require_paths = ["lib"] + s.rubyforge_project = %q{thinking-sphinx} + s.rubygems_version = %q{1.1.1} + s.summary = %q{A concise and easy-to-use Ruby library that connects ActiveRecord to the Sphinx search daemon, managing configuration, indexing and searching.} + s.test_files = ["spec/unit/thinking_sphinx/active_record/delta_spec.rb", "spec/unit/thinking_sphinx/active_record/has_many_association_spec.rb", "spec/unit/thinking_sphinx/active_record/search_spec.rb", "spec/unit/thinking_sphinx/active_record_spec.rb", "spec/unit/thinking_sphinx/association_spec.rb", "spec/unit/thinking_sphinx/attribute_spec.rb", "spec/unit/thinking_sphinx/configuration_spec.rb", "spec/unit/thinking_sphinx/field_spec.rb", "spec/unit/thinking_sphinx/index/builder_spec.rb", "spec/unit/thinking_sphinx/index/faux_column_spec.rb", "spec/unit/thinking_sphinx/index_spec.rb", "spec/unit/thinking_sphinx/search_spec.rb", "spec/unit/thinking_sphinx_spec.rb"] +end thinking-sphinx.gemspec 4287a978cecace1ceb10e4bb1b2a9e4270a512aa Ed Hickey ed@ed-new-laptop.local http://github.com/bassnode/thinking-sphinx/commit/ce42541709dd65b0c031802091d950a776cc3084 ce42541709dd65b0c031802091d950a776cc3084 2008-08-28T13:42:24-07:00 2008-08-28T13:42:24-07:00 merged in DrMark's branch 1ec795ef79e088d7ed1bfaaea4b6e82b3edd24b2 Ed Hickey ed@ed-new-laptop.local