ultrasphinx 1 → 1.5

data/lib/ultrasphinx/search/internals.rb

@@ -0,0 +1,204 @@
+
+module Ultrasphinx
+  class Search
+    module Internals
+
+      # These methods are kept stateless to ease debugging
+      
+      private
+      
+      def build_request_with_options opts
+      
+        request = Sphinx::Client.new
+      
+        request.SetServer(
+          Ultrasphinx::CLIENT_SETTINGS['server_host'], 
+          Ultrasphinx::CLIENT_SETTINGS['server_port']
+        )
+        
+        # Force extended query mode
+        request.SetMatchMode(Sphinx::Client::SPH_MATCH_EXTENDED) 
+      
+        offset, limit = opts['per_page'] * (opts['page'] - 1), opts['per_page']
+        
+        request.SetLimits offset, limit, [offset + limit, MAX_MATCHES].min
+        request.SetSortMode SPHINX_CLIENT_PARAMS['sort_mode'][opts['sort_mode']], opts['sort_by'].to_s
+      
+        if weights = opts['weight']
+          # Order the weights hash according to the field order for Sphinx, and set the missing fields to 1.0
+          request.SetWeights(Fields.instance.types.select{|n,t| t == 'text'}.map(&:first).sort.inject([]) do |array, field|
+            array << (weights[field] || 1.0)
+          end)
+        end
+      
+        unless opts['class_name'].compact.empty?
+          request.SetFilter 'class_id', opts['class_name'].map{|m| MODELS_TO_IDS[m.to_s]}
+        end        
+      
+        # Extract ranged raw filters 
+        # Some of this mangling might not be necessary
+        opts['filter'].each do |field, value|
+          begin
+            case value
+              when Fixnum, Float, BigDecimal, NilClass, Array
+                request.SetFilter field, Array(value)
+              when Range
+                min, max = [value.begin, value.end].map do |x|
+                  x._to_numeric
+                end
+                raise NoMethodError unless min <=> max and max <=> min
+                min, max = max, min if min > max
+                request.SetFilterRange field, min, max
+              when String
+                opts['parsed_query'] << " @#{field} #{value}"
+              else
+                raise NoMethodError
+            end
+          rescue NoMethodError => e
+            raise Sphinx::SphinxArgumentError, "filter: #{field.inspect}:#{value.inspect} is invalid"
+          end
+        end
+        
+        request
+      end    
+      
+      def get_subtotals(original_request, query)
+        request = original_request._deep_dup
+        request.instance_eval { @filters.delete_if {|f| f['attr'] == 'class_id'} }
+        
+        facets = get_facets(request, query, 'class_id')
+        
+        # Not using the standard facet caching here
+        Hash[*(MODELS_TO_IDS.map do |klass, id|
+          [klass, facets[id] || 0]
+        end.flatten)]
+      end
+      
+      def get_facets(original_request, query, original_facet)
+        request, facet = original_request._deep_dup, original_facet        
+        facet += "_facet" if Fields.instance.types[original_facet] == 'text'            
+        
+        raise UsageError, "Field #{original_facet} does not exist or was not configured for faceting" unless Fields.instance.types[facet]
+
+        # Set the facet query parameter and modify per-page setting so we snag all the facets
+        request.SetGroupBy(facet, Sphinx::Client::SPH_GROUPBY_ATTR, '@count desc')
+        limit = self.class.client_options['max_facets']
+        request.SetLimits 0, limit, [limit, MAX_MATCHES].min
+        
+        # Run the query
+        matches = request.Query(query)['matches']
+                
+        # Map the facets back to something sane
+        facets = {}
+        matches.each do |match|
+          match = match.last['attrs'] # :(
+          raise ResponseError if facets[match['@groupby']]
+          facets[match['@groupby']] = match['@count']
+        end
+                
+        # Invert crc's, if we have them
+        reverse_map_facets(facets, original_facet)
+      end
+      
+      def reverse_map_facets(facets, facet) 
+        facets = facets.dup
+      
+        if Fields.instance.types[facet] == 'text'        
+          unless FACET_CACHE[facet]
+            # Cache the reverse CRC map for the textual facet if it hasn't been done yet
+            # XXX not necessarily optimal since it requires a direct DB hit once per mongrel
+            Ultrasphinx.say "caching crc reverse map for text facet #{facet}"
+            
+            Fields.instance.classes[facet].each do |klass|
+              # you can only use a facet from your own self right now; no includes allowed
+              field = (MODEL_CONFIGURATION[klass.name]['fields'].detect do |field_hash|
+                field_hash['as'] == facet
+              end)['field']
+          
+              klass.connection.execute("SELECT #{field} AS value, CRC32(#{field}) AS crc FROM #{klass.table_name} GROUP BY #{field}").each_hash do |hash|
+                (FACET_CACHE[facet] ||= {})[hash['crc'].to_i] = hash['value']
+              end                            
+            end
+          end
+          
+          # Apply the map
+          facets = Hash[*(facets.map do |crc, value|
+            [FACET_CACHE[facet][crc], value]
+          end.flatten)]
+        end
+        
+        facets        
+      end
+
+      def reify_results(sphinx_ids)
+    
+        # Order by position and then toss the rest of the data
+        sphinx_ids = sphinx_ids.sort_by do |key, value| 
+          value['index'] or raise ConfigurationError, "Your Sphinx client is not properly patched."
+        end.map(&:first)
+    
+        # Inverse-modulus map the sphinx ids to the table-specific ids
+        ids = Hash.new([])
+        sphinx_ids.each do |id|
+          ids[MODELS_TO_IDS.invert[id % MODELS_TO_IDS.size]] += [id / MODELS_TO_IDS.size] # yay math
+        end
+        raise Sphinx::SphinxResponseError, "impossible document id in query result" unless ids.values.flatten.size == sphinx_ids.size
+    
+        # Fetch them for real
+        results = []
+        ids.each do |model, id_set|
+          klass = model.constantize
+          
+          finder = self.class.client_options['finder_methods'].detect do |method_name|
+            klass.respond_to? method_name
+          end
+          
+          logger.debug "** ultrasphinx: using #{klass.name}.#{finder} as finder method"
+    
+          begin
+            # XXX Does not use Memcached's multiget
+            results += case instances = id_set.map { |id| klass.send(finder, id) }
+              when Hash
+                instances.values
+              when Array
+                instances
+              else
+                Array(instances)
+            end
+          rescue ActiveRecord::ActiveRecordError => e
+            raise Sphinx::SphinxResponseError, e.inspect
+          end
+        end
+    
+        # Put them back in order
+        results.sort_by do |r| 
+          raise Sphinx::SphinxResponseError, "Bogus ActiveRecord id for #{r.class}:#{r.id}" unless r.id
+          index = (sphinx_ids.index(sphinx_id = r.id * MODELS_TO_IDS.size + MODELS_TO_IDS[r.class.base_class.name]))
+          raise Sphinx::SphinxResponseError, "Bogus reverse id for #{r.class}:#{r.id} (Sphinx:#{sphinx_id})" unless index
+          index / sphinx_ids.size.to_f
+        end
+        
+        # Add an accessor for absolute search rank for each record
+        results.each_with_index do |r, index|
+          i = per_page * (current_page - 1) + index
+          r._metaclass.send('define_method', 'result_index') { i }
+        end
+        
+        results        
+      end  
+
+      
+      def strip_bogus_characters(s)
+        # Used to remove some garbage before highlighting
+        s.gsub(/<.*?>|\.\.\.|\342\200\246|\n|\r/, " ").gsub(/http.*?( |$)/, ' ') if s
+      end
+      
+      def strip_query_commands(s)
+        # XXX Hack for query commands, since sphinx doesn't intelligently parse the query in excerpt mode
+        # Also removes apostrophes in the middle of words so that they don't get split in two.
+        s.gsub(/(^|\s)(AND|OR|NOT|\@\w+)(\s|$)/i, "").gsub(/(\w)\'(\w)/, '\1\2')
+      end 
+    
+    end
+  end  
+end

data/lib/ultrasphinx/search/parser.rb

@@ -0,0 +1,115 @@
+
+module Ultrasphinx
+  class Search
+    module Parser
+      
+      class Error < RuntimeError; end
+
+      OPERATORS = {
+        'OR' => '|',
+        'AND' => '',
+        'NOT' => '-',
+        'or' => '|',
+        'and' => '',
+        'not' => '-'
+      }
+            
+      private
+      
+      def parse query
+        # Alters a Google query string into Sphinx 0.97 style
+        return "" if query.blank?
+        # Parse
+        token_hash = token_stream_to_hash(query_to_token_stream(query))  
+        # Join everything up and remove some spaces
+        token_hash_to_array(token_hash).join(" ").squeeze(" ").strip
+      end
+      
+
+      def token_hash_to_array(token_hash)              
+        query = []
+        
+        token_hash.sort_by do |key, value| 
+          key or ""
+        end.each do |field, contents|
+          # first operator always goes outside
+          query << contents.first.first 
+          
+          query << "@#{field}" if field
+          query << "(" if field and contents.size > 1
+          
+          contents.each_with_index do |op_and_content, index|
+            op, content = op_and_content
+            query << op unless index == 0
+            query << content
+          end
+          
+          query << ")" if field and contents.size > 1        
+        end
+        
+        # XXX swap the first pair if the order is reversed
+        if [OPERATORS['NOT'], OPERATORS['OR']].include? query.first.upcase
+          query[0], query[1] = query[1], query[0]
+        end
+        
+        query
+      end
+      
+
+      def query_to_token_stream(query)      
+        # First, split query on spaces that are not inside sets of quotes or parens
+        query = query.scan(/[^"() ]*["(][^")]*[")]|[^"() ]+/) 
+      
+        token_stream = []
+        has_operator = false
+        
+        query.each_with_index do |subtoken, index|
+      
+          # recurse for parens, if necessary
+          if subtoken =~ /^(.*?)\((.*)\)(.*?$)/
+            subtoken = query[index] = "#{$1}(#{parse $2})#{$3}"
+          end       
+          
+          # add to the stream, converting the operator
+          if !has_operator
+            if OPERATORS.to_a.flatten.include? subtoken and index != (query.size - 1) # operators at the end of the string are not parsed
+              token_stream << OPERATORS[subtoken] || subtoken
+              has_operator = true # flip
+            else
+              token_stream << ""
+              token_stream << subtoken
+            end
+          else
+            if OPERATORS.to_a.flatten.include? subtoken
+              # drop extra operator
+            else
+              token_stream << subtoken
+              has_operator = false # flop
+            end
+          end        
+        end
+        
+        raise Error, "#{token_stream.inspect} is not a valid token stream" unless token_stream.size % 2 == 0        
+        token_stream.in_groups_of(2) 
+      end
+      
+      
+      def token_stream_to_hash(token_stream)
+        token_hash = Hash.new([])        
+        token_stream.map do |operator, content|
+          # remove some spaces
+          content.gsub!(/^"\s+|\s+"$/, '"')
+          # convert fields into sphinx style, reformat the stream object
+          if content =~ /(.*?):(.*)/
+            token_hash[$1] += [[operator, $2]]
+          else
+            token_hash[nil] += [[operator, content]]
+          end        
+        end
+        token_hash
+      end
+
+
+    end
+  end
+end

data/lib/ultrasphinx/spell.rb

@@ -3,19 +3,26 @@
 module Ultrasphinx
 
 =begin rdoc
-== Spelling support
 
-In order to spellcheck your user's query, Ultrasphinx bundles a small spelling module. First, make sure Aspell 0.6, an appropriate Aspell dictionary, and the Rubygem 'raspell' are all installed.
+In order to spellcheck your user's query, Ultrasphinx bundles a small spelling module. 
+
+== Setup
+
+Make sure Aspell and the Rubygem <tt>raspell</tt> are installed. See http://blog.evanweaver.com/files/doc/fauna/raspell/ for detailed instructions.
   
-Then, copy <tt>examples/app.multi</tt> into your Aspell dictionary folder. It allows you to use Sphinx to generate a custom wordlist for your app. Modify it if you don't want to also use the default American English dictionary.
+Copy the <tt>examples/app.multi</tt> file into your Aspell dictionary folder (<tt>/opt/local/share/aspell/</tt> on Mac, <tt>/usr/lib/aspell-0.60/</tt> on Linux). This file lets Aspell load a custom wordlist generated by Sphinx from your app data. Modify the file if you don't want to also use the default American English dictionary.
   
-Then, to build the custom wordlist, run:  
-  rake ultrasphinx:spelling:build    
+Finally, to build the custom wordlist, run:  
+  sudo rake ultrasphinx:spelling:build  
+
+You need to use <tt>sudo</tt> because Ultrasphinx needs to write to the Aspell dictionary folder. Also note that Aspell, <tt>raspell</tt>, and the custom dictionary must be available on each application server, not on the Sphinx daemon server.
+
+== Usage
 
 Now you can see if a query is correctly spelled as so:
   @correction = Ultrasphinx::Spell.correct(@search.query)
 
-If @correction is not nil, go ahead and suggest it to the user. Otherwise, the query was already correct.
+If <tt>@correction</tt> is not <tt>nil</tt>, go ahead and suggest it to the user. 
 
 =end
 

data/lib/ultrasphinx/ultrasphinx.rb

@@ -7,6 +7,8 @@ module Ultrasphinx
   end  
   class DaemonError < Exception #:nodoc:
   end
+  class UsageError < Exception #:nodoc:
+  end
 
   # internal file paths
   
@@ -30,247 +32,82 @@ module Ultrasphinx
 
   MAX_WORDS = 2**16 # maximum number of stopwords built  
   
+  EMPTY_SEARCHABLE = "__empty_searchable__"
+  
   UNIFIED_INDEX_NAME = "complete"
 
-  COLUMN_TYPES = {:string => 'text', :text => 'text', :integer => 'numeric', :date => 'date', :datetime => 'date' }
-
-  CONFIG_MAP = {:username => 'sql_user',
+  CONFIG_MAP = {
+    # These must be symbols for key mapping against Rails itself
+    :username => 'sql_user',
     :password => 'sql_pass',
     :host => 'sql_host',
     :database => 'sql_db',
     :port => 'sql_port',
-    :socket => 'sql_sock'}
-
-  OPTIONAL_SPHINX_KEYS = ['morphology', 'stopwords', 'min_word_len', 'charset_type', 'charset_table', 'docinfo']
-  
-  # some default settings for the sphinx conf files
+    :socket => 'sql_sock'
+  }
   
-  SOURCE_DEFAULTS = %(
-strip_html = 0
-index_html_attrs =
-sql_query_post =
-sql_range_step = 20000
-  )
+  CONNECTION_DEFAULTS = {
+    :host => 'localhost'
+  }
   
   ADAPTER_DEFAULTS = {
-    "mysql" => %(
+    'mysql' => %(
 type = mysql
 sql_query_pre = SET SESSION group_concat_max_len = 65535
 sql_query_pre = SET NAMES utf8
   ), 
-    "postgresql" => %(
+    'postgresql' => %(
 type = pgsql
   )}
- 
+     
+  # Logger.
+  def self.say msg
+    STDERR.puts "** ultrasphinx: #{msg}"
+  end
   
   # Configuration file parser.
   def self.options_for(heading, path)
+    section = open(path).read[/^#{heading}\s*?\{(.*?)\}/m, 1]    
     
-    section = open(path).read[/^#{heading}.*?\{(.*?)\}/m, 1]    
     unless section
-      Ultrasphinx.say "#{path} appears to be corrupted; please delete file"
-      raise ConfigurationError, "Missing heading #{heading.inspect}" 
-    end
-    
-    options = section.split("\n").map do |line|
-      line =~ /\s*(.*?)\s*=\s*([^\#]*)/
-      $1 ? [$1, $2.strip] : []
+      Ultrasphinx.say "warning; heading #{heading} not found in #{path}; it may be corrupted. "
+      {}
+    else      
+      options = section.split("\n").map do |line|
+        line =~ /\s*(.*?)\s*=\s*([^\#]*)/
+        $1 ? [$1, $2.strip] : []
+      end      
+      Hash[*options.flatten] 
     end
     
-    Hash[*options.flatten] 
   end
 
   # introspect on the existing generated conf files
 
-  PLUGIN_SETTINGS = options_for('ultrasphinx', BASE_PATH)
-
+  INDEXER_SETTINGS = options_for('indexer', BASE_PATH)
+  CLIENT_SETTINGS = options_for('client', BASE_PATH)
   DAEMON_SETTINGS = options_for('searchd', BASE_PATH)
-
-  STOPWORDS_PATH = "#{Ultrasphinx::PLUGIN_SETTINGS['path']}/stopwords.txt}"
-
-  MODEL_CONFIGURATION = {}
-
-
-
-  class << self    
-  
-    # Logger.
-    def say msg
-      $stderr.puts "** ultrasphinx: #{msg}"
-    end
-
-    # Force all the indexed models to load and fill the MODEL_CONFIGURATION hash.
-    def load_constants
-
-      Dir["#{RAILS_ROOT}/app/models/**/*.rb"].each do |filename|
-        next if filename =~ /\/(\.svn|CVS|\.bzr)\//
-        begin
-          open(filename) {|file| load filename if file.grep(/is_indexed/).any?}
-        rescue Object => e
-          say "warning; possibly critical autoload error on #{filename}"
-          say e.inspect
-        end
-      end 
-
-      # build the field-to-type mappings
-      Fields.instance.configure(MODEL_CONFIGURATION)
-    end
-    
-    # Complain if the database names go out of sync.
-    def verify_database_name
-      if File.exist? CONF_PATH
-        if options_for("source", CONF_PATH)['sql_db'] != ActiveRecord::Base.connection.instance_variable_get("@config")[:database]
-           say "warning; configured database name is out-of-date"
-           say "please run 'rake ultrasphinx:configure'"
-        end rescue nil
-      end
-    end
-         
-                  
-    # Main SQL builder.
-    def configure       
-      load_constants
-            
-      puts "Rebuilding Ultrasphinx configurations for #{ENV['RAILS_ENV']} environment" 
-      puts "Available models are #{MODEL_CONFIGURATION.keys.to_sentence}"
-      File.open(CONF_PATH, "w") do |conf|
-        conf.puts "\n# Auto-generated at #{Time.now}.\n# Hand modifications will be overwritten.\n"
-        
-        conf.puts "\n# #{BASE_PATH}"
-        conf.puts open(BASE_PATH).read.sub(/^ultrasphinx.*?\{.*?\}/m, '') + "\n"
-        
-        sphinx_source_list = []
-        
-        conf.puts "\n# Source configuration\n\n"
-
-        puts "Generating SQL"
-        MODEL_CONFIGURATION.each_with_index do |model_options, class_id|
-          model, options = model_options
-          klass, source = model.constantize, model.tableize
-
-#          puts "SQL for #{model}"
-          
-          sphinx_source_list << source
+  SOURCE_SETTINGS = options_for('source', BASE_PATH)
+  INDEX_SETTINGS = options_for('index', BASE_PATH)
   
-          conf.puts "source #{source}\n{"
-          conf.puts SOURCE_DEFAULTS
-                    
-          # apparently we're supporting postgres now
-          connection_settings = klass.connection.instance_variable_get("@config")
-
-          adapter_defaults = ADAPTER_DEFAULTS[connection_settings[:adapter]]
-          raise ConfigurationError, "Unsupported database adapter" unless adapter_defaults
-          conf.puts adapter_defaults
-                    
-          connection_settings.each do |key, value|
-            conf.puts "#{CONFIG_MAP[key]} = #{value}" if CONFIG_MAP[key]          
-          end          
-          
-          table, pkey = klass.table_name, klass.primary_key
-          condition_strings, join_strings = Array(options[:conditions]).map{|condition| "(#{condition})"}, []
-          column_strings = ["(#{table}.#{pkey} * #{MODEL_CONFIGURATION.size} + #{class_id}) AS id", 
-                                       "#{class_id} AS class_id", "'#{klass.name}' AS class"]   
-          remaining_columns = Fields.instance.keys - ["class", "class_id"]
-          
-          conf.puts "\nsql_query_range = SELECT MIN(#{pkey}), MAX(#{pkey}) FROM #{table}"
-          
-          options[:fields].to_a.each do |f|
-            column, as = f.is_a?(Hash) ? [f[:field], f[:as]] : [f, f]
-            column_strings << Fields.instance.cast("#{table}.#{column}", as)
-            remaining_columns.delete(as)
-          end
-          
-          options[:includes].to_a.each do |join|
-            join_klass = join[:model].constantize
-            association = klass.reflect_on_association(join[:model].underscore.to_sym)
-            if not association 
-              if not join[:association_sql]
-                raise ConfigurationError, "Unknown association from #{klass} to #{join[:model]}"
-              else
-                join_strings << join[:association_sql]
-              end
-            else
-              join_strings << "LEFT OUTER JOIN #{join_klass.table_name} ON " + 
-                if (macro = association.macro) == :belongs_to 
-                  "#{join_klass.table_name}.#{join_klass.primary_key} = #{table}.#{association.primary_key_name}" 
-                elsif macro == :has_one
-                  "#{table}.#{klass.primary_key} = #{join_klass.table_name}.#{association.instance_variable_get('@foreign_key_name')}" 
-                else
-                  raise ConfigurationError, "Unidentified association macro #{macro.inspect}"
-                end
-            end
-            column_strings << "#{join_klass.table_name}.#{join[:field]} AS #{join[:as] or join[:field]}"
-            remaining_columns.delete(join[:as] || join[:field])
-          end
-          
-          options[:concats].to_a.select{|concat| concat[:model] and concat[:field]}.each do |group|
-            # only has_many's or explicit sql right now
-            join_klass = group[:model].constantize
-            if group[:association_sql]
-              join_strings << group[:association_sql]
-            else
-              association = klass.reflect_on_association(group[:association_name] ? group[:association_name].to_sym :  group[:model].underscore.pluralize.to_sym)
-              join_strings << "LEFT OUTER JOIN #{join_klass.table_name} ON #{table}.#{klass.primary_key} = #{join_klass.table_name}.#{association.primary_key_name}" + (" AND (#{group[:conditions]})" if group[:conditions]).to_s # XXX make sure foreign key is right for polymorphic relationships
-            end
-            column_strings << Fields.instance.cast("GROUP_CONCAT(#{join_klass.table_name}.#{group[:field]} SEPARATOR ' ')", group[:as])
-            remaining_columns.delete(group[:as])
-          end
-          
-          options[:concats].to_a.select{|concat| concat[:fields]}.each do |concat|
-            column_strings << Fields.instance.cast("CONCAT_WS(' ', #{concat[:fields].map{|field| "#{table}.#{field}"}.join(', ')})", concat[:as])
-            remaining_columns.delete(concat[:as])
-          end
-            
-#          puts "#{model} has #{remaining_columns.inspect} remaining"
-          remaining_columns.each do |field|
-            column_strings << Fields.instance.null(field)
-          end
-          
-          query_strings = ["SELECT", column_strings.sort_by do |string| 
-            # sphinx wants them always in the same order, but "id" must be first
-            (field = string[/.*AS (.*)/, 1]) == "id" ? "*" : field
-          end.join(", ")] 
-          query_strings << "FROM #{table}"                      
-          query_strings += join_strings.uniq
-          query_strings << "WHERE #{table}.#{pkey} >= $start AND #{table}.#{pkey} <= $end"
-          query_strings += condition_strings.uniq.map{|s| "AND #{s}"}
-          query_strings << "GROUP BY id"
-          
-          conf.puts "sql_query = #{query_strings.join(" ")}"
-          
-          groups = []
-          # group and date sorting params... this really only would have to be run once
-          Fields.instance.each do |field, type|
-            case type
-              when 'numeric'
-                groups << "sql_group_column = #{field}"
-              when 'date'
-                groups << "sql_date_column = #{field}"
-            end
-          end
-          conf.puts "\n" + groups.sort_by{|s| s[/= (.*)/, 1]}.join("\n")
-          conf.puts "\nsql_query_info = SELECT * FROM #{table} WHERE #{table}.#{pkey} = (($id - #{class_id}) / #{MODEL_CONFIGURATION.size})"           
-          conf.puts "}\n\n"                
-        end
-        
-        conf.puts "\n# Index configuration\n\n"
-        
-
-        # only output the unified index; no one uses the individual ones anyway        
-
-        conf.puts "index #{UNIFIED_INDEX_NAME}"
-        conf.puts "{"
-        conf.puts sphinx_source_list.map {|s| "source = #{s}" }
-
-        OPTIONAL_SPHINX_KEYS.each do |key|
-          conf.puts "#{key} = #{PLUGIN_SETTINGS[key]}" if PLUGIN_SETTINGS[key]
-        end
-        
-        conf.puts "path = #{PLUGIN_SETTINGS["path"]}/sphinx_index_#{UNIFIED_INDEX_NAME}"
-        conf.puts "}\n\n"
-      end
-            
+  # Make sure there's a trailing slash
+  INDEX_SETTINGS['path'] = INDEX_SETTINGS['path'].chomp("/") + "/" 
+
+  STOPWORDS_PATH = "#{Ultrasphinx::INDEX_SETTINGS['path']}/stopwords.txt"
+
+  MODEL_CONFIGURATION = {}     
+
+  # Complain if the database names go out of sync.
+  def self.verify_database_name
+    if File.exist? CONF_PATH
+      if options_for(
+        "source #{MODEL_CONFIGURATION.keys.first.tableize}", 
+        CONF_PATH
+      )['sql_db'] != ActiveRecord::Base.connection.instance_variable_get("@config")[:database]
+        say "warning; configured database name is out-of-date"
+        say "please run 'rake ultrasphinx:configure'"
+      end rescue nil
     end
-        
   end
+        
 end