ultrasphinx 1.5.3 → 1.6

data/CHANGELOG

@@ -1,5 +1,11 @@
 
-v1.5.3. 90% test coverage; support multiple spelling dictionaries per machine (configurable in the .base file); association_name key is right out; some bugfixes.
+vTODO. Use Pat Allan's association configurator.
+
+v1.6. API changes! Drop Sphinx 0.9.7 compatibility; switch to Pat Allan's 0.9.8 client plugin; remove legacy keynames; fix string sorting bug; improve error handling.
+
+v1.5.4. Various things.
+
+v1.5.3. 90% test coverage; support multiple spelling dictionaries per machine (configurable in the .base file); association_name key is right out.
 
 v1.5.2. Fix association reloading issue; support float attributes on Sphinx 0.9.8; fix date range filters; import and update sample app (Mark Lane); start a comprehensive integration suite.
 

data/Manifest

@@ -124,12 +124,12 @@ test/integration/spell_test.rb
 test/setup.rb
 test/test_all.rb
 test/test_helper.rb
-test/ts.multi
 test/unit/parser_test.rb
 TODO
-vendor/sphinx/init.rb
-vendor/sphinx/lib/client.rb
-vendor/sphinx/LICENSE
-vendor/sphinx/Rakefile
-vendor/sphinx/README
+vendor/riddle/MIT-LICENSE
+vendor/riddle/riddle/client/filter.rb
+vendor/riddle/riddle/client/message.rb
+vendor/riddle/riddle/client/response.rb
+vendor/riddle/riddle/client.rb
+vendor/riddle/riddle.rb
 vendor/will_paginate/LICENSE

data/README

@@ -5,14 +5,14 @@ Ruby on Rails configurator and client to the Sphinx full text search engine.
 
 == License
 
-Copyright 2007 Cloudburst, LLC. Licensed under the AFL 3. See the included LICENSE file. Some portions copyright Dmytro Shteflyuk and Alexey Kovyrin, distributed under the Ruby License, and used with permission. Some portions copyright PJ Hyett and Mislav Marohnić, distributed under the MIT license, and used with permission.
+Copyright 2007 Cloudburst, LLC. Licensed under the AFL 3. See the included LICENSE file. Some portions copyright Pat Allan, distributed under the MIT license, and used with permission. Some portions copyright PJ Hyett and Mislav Marohnić, distributed under the MIT license, and used with permission.
 
 The public certificate for the gem is at http://rubyforge.org/frs/download.php/25331/evan_weaver-original-public_cert.pem.
 
 == Requirements
 
 * MySQL (or Postgres, experimental)
-* Sphinx 0.97 or greater
+* Sphinx 0.9.8-dev r877 or greater
 * Rails 1.2.3 or greater
 
 == Features
@@ -43,7 +43,7 @@ And some other things.
 
 == Installation
   
-First, compile and install Sphinx itself (http://www.sphinxsearch.com). 
+First, compile and install Sphinx itself using the 0.9.8 development snapshot (http://www.sphinxsearch.com). 
 
 You also need the <tt>chronic</tt> gem:
   sudo gem install chronic

data/TODO

@@ -2,4 +2,5 @@
 * Finish unifying filters and textfields
 * Support exclude filters
 * Make sure filters can be set to nil
-
+* Geolocation search
+* Use Treetop for the query parser instead of regexes

data/examples/default.base

@@ -53,6 +53,7 @@ index
   morphology = stem_en
   stopwords = # /path/to/stopwords.txt
   min_word_len = 1
+  enable_star = 1
   charset_type = utf-8 # or sbcs (Single Byte Character Set)
   charset_table = 0..9, A..Z->a..z, -, _, ., &, a..z, U+410..U+42F->U+430..U+44F, U+430..U+44F,U+C5->U+E5, U+E5, U+C4->U+E4, U+E4, U+D6->U+F6, U+F6, U+16B, U+0c1->a, U+0c4->a, U+0c9->e, U+0cd->i, U+0d3->o, U+0d4->o, U+0da->u, U+0dd->y, U+0e1->a, U+0e4->a, U+0e9->e, U+0ed->i, U+0f3->o, U+0f4->o, U+0fa->u, U+0fd->y, U+104->U+105, U+105, U+106->U+107, U+10c->c, U+10d->c, U+10e->d, U+10f->d, U+116->U+117, U+117, U+118->U+119, U+11a->e, U+11b->e, U+12E->U+12F, U+12F, U+139->l, U+13a->l, U+13d->l, U+13e->l, U+141->U+142, U+142, U+143->U+144, U+144,U+147->n, U+148->n, U+154->r, U+155->r, U+158->r, U+159->r, U+15A->U+15B, U+15B, U+160->s, U+160->U+161, U+161->s, U+164->t, U+165->t, U+16A->U+16B, U+16B, U+16e->u, U+16f->u, U+172->U+173, U+173, U+179->U+17A, U+17A, U+17B->U+17C, U+17C, U+17d->z, U+17e->z,
 }

data/lib/ultrasphinx.rb

@@ -10,7 +10,8 @@ if defined? RAILS_ENV and RAILS_ENV == "development"
   end
 end
 
-require "#{File.dirname(__FILE__)}/../vendor/sphinx/lib/client"
+$LOAD_PATH << "#{File.dirname(__FILE__)}/../vendor/riddle/"
+require 'riddle'
 
 require 'ultrasphinx/ultrasphinx'
 require 'ultrasphinx/core_extensions'

data/lib/ultrasphinx/configure.rb

@@ -93,9 +93,8 @@ module Ultrasphinx
         
         column_strings = [
           "(#{klass.table_name}.#{klass.primary_key} * #{MODEL_CONFIGURATION.size} + #{class_id}) AS id", 
-          "#{class_id} AS class_id", "'#{klass.name}' AS class", 
-          "'#{EMPTY_SEARCHABLE}' AS empty_searchable"]
-        remaining_columns = fields.types.keys - ["class", "class_id", "empty_searchable"]        
+          "#{class_id} AS class_id", "'#{klass.name}' AS class"]
+        remaining_columns = fields.types.keys - ["class", "class_id"]        
         [column_strings, [], condition_strings, remaining_columns]
       end
       
@@ -162,7 +161,7 @@ module Ultrasphinx
 
       def build_regular_fields(klass, fields, entries, column_strings, join_strings, remaining_columns)          
         entries.to_a.each do |entry|
-          source_string = "#{klass.table_name}.#{entry['field']}"
+          source_string = "#{entry['table']}.#{entry['field']}"
           column_strings, remaining_columns = install_field(fields, source_string, entry['as'], entry['function_sql'], entry['facet'], column_strings, remaining_columns)
         end
         
@@ -179,17 +178,17 @@ module Ultrasphinx
           raise ConfigurationError, "Unknown association from #{klass} to #{entry['class_name']}" if not association and not entry['association_sql']
           
           join_strings = install_join_unless_association_sql(entry['association_sql'], nil, join_strings) do 
-            "LEFT OUTER JOIN #{join_klass.table_name} ON " + 
+            "LEFT OUTER JOIN #{join_klass.table_name} AS #{entry['table']} ON " + 
             if (macro = association.macro) == :belongs_to 
-              "#{join_klass.table_name}.#{join_klass.primary_key} = #{klass.table_name}.#{association.primary_key_name}" 
+              "#{entry['table']}.#{join_klass.primary_key} = #{klass.table_name}.#{association.primary_key_name}" 
             elsif macro == :has_one
-              "#{klass.table_name}.#{klass.primary_key} = #{join_klass.table_name}.#{association.primary_key_name}" 
+              "#{klass.table_name}.#{klass.primary_key} = #{entry['table']}.#{association.primary_key_name}" 
             else
               raise ConfigurationError, "Unidentified association macro #{macro.inspect}. Please use the :association_sql key to manually specify the JOIN syntax."
             end
           end
           
-          source_string = "#{join_klass.table_name}.#{entry['field']}"
+          source_string = "#{entry['table']}.#{entry['field']}"
           column_strings, remaining_columns = install_field(fields, source_string, entry['as'], entry['function_sql'], entry['facet'], column_strings, remaining_columns)                         
         end
         
@@ -207,17 +206,17 @@ module Ultrasphinx
             join_strings = install_join_unless_association_sql(entry['association_sql'], nil, join_strings) do 
               # XXX make sure foreign key is right for polymorphic relationships
               association = association_by_class_name(klass, entry['class_name'])
-              "LEFT OUTER JOIN #{join_klass.table_name} ON #{klass.table_name}.#{klass.primary_key} = #{join_klass.table_name}.#{association.primary_key_name}" + 
+              "LEFT OUTER JOIN #{join_klass.table_name} AS #{entry['table']} ON #{klass.table_name}.#{klass.primary_key} = #{entry['table']}.#{association.primary_key_name}" + 
                 (entry['conditions'] ? " AND (#{entry['conditions']})" : "")
             end
             
-            source_string = "GROUP_CONCAT(#{join_klass.table_name}.#{entry['field']} SEPARATOR ' ')"
+            source_string = "GROUP_CONCAT(DISTINCT #{entry['table']}.#{entry['field']} SEPARATOR ' ')"
             column_strings, remaining_columns = install_field(fields, source_string, entry['as'], entry['function_sql'], entry['facet'], column_strings, remaining_columns)
             
           elsif entry['fields']
             # regular concats
             source_string = "CONCAT_WS(' ', " + entry['fields'].map do |subfield| 
-              "#{klass.table_name}.#{subfield}"
+              "#{entry['table']}.#{subfield}"
             end.join(', ') + ")"
             
             column_strings, remaining_columns = install_field(fields, source_string, entry['as'], entry['function_sql'], entry['facet'], column_strings, remaining_columns)              

data/lib/ultrasphinx/core_extensions.rb

@@ -62,6 +62,7 @@ end
 ### Filter type coercion methods
 
 class String
+  # XXX Not used enough to justify such a strange abstraction
   def _to_numeric
     zeroless = self.squeeze(" ").strip.sub(/^0+(\d)/, '\1')
     zeroless.sub!(/(\...*?)0+$/, '\1')
@@ -69,7 +70,7 @@ class String
       zeroless.to_i
     elsif zeroless.to_f.to_s == zeroless
       zeroless.to_f
-    elsif date = Chronic.parse(self)
+    elsif date = Chronic.parse(self.gsub(/(\d)([^\d\:\s])/, '\1 \2')) # Improve Chronic's flexibility a little
       date.to_i
     else
       raise Ultrasphinx::UsageError, "#{self.inspect} could not be coerced into a numeric value"

data/lib/ultrasphinx/fields.rb

@@ -18,9 +18,7 @@ This is a special singleton configuration class that stores the index field conf
       'float' => 'float',
       'boolean' => 'integer'
     }
-    
-    VERSIONS_REQUIRED = {'float' => '0.9.8'}
-    
+        
     attr_accessor :classes, :types
     
     def initialize
@@ -37,7 +35,6 @@ This is a special singleton configuration class that stores the index field conf
   
     def save_and_verify_type(field, new_type, string_sortable, klass)
       # Smoosh fields together based on their name in the Sphinx query schema
-      check_version(new_type.to_s)
       field, new_type = field.to_s, TYPE_MAP[new_type.to_s]
 
       if types[field]
@@ -88,16 +85,6 @@ This is a special singleton configuration class that stores the index field conf
       end + " AS #{field}"
     end
     
-    def check_version(field)
-      # XXX Awkward location for the compatibility check
-      if req = VERSIONS_REQUIRED[field]
-        unless SPHINX_VERSION.include? req
-          # Will we eventually need to check version ranges?
-          Ultrasphinx.say "warning: '#{field}' type requires Sphinx #{req}, but you have #{SPHINX_VERSION}"
-        end
-      end
-    end
-    
     def configure(configuration)
 
       configuration.each do |model, options|        
@@ -112,7 +99,9 @@ This is a special singleton configuration class that stores the index field conf
           # We destructively canonicize them back onto the configuration hash
           options['fields'] = options['fields'].to_a.map do |entry|
             entry = {'field' => entry} unless entry.is_a? Hash
-            entry['as'] = entry['field'] unless entry['as']
+
+            extract_table_alias!(entry, klass)
+            extract_field_alias!(entry, klass)
             
             unless klass.columns_hash[entry['field']]
               Ultrasphinx.say "warning: field #{entry['field']} is not present in #{model}"
@@ -130,15 +119,18 @@ This is a special singleton configuration class that stores the index field conf
           
           # Joins are whatever they are in the target       
           options['include'].to_a.each do |entry|
-            entry['as'] = entry['field'] unless entry['as']
-            
+            extract_table_alias!(entry, klass)
+            extract_field_alias!(entry, klass)
+
             save_and_verify_type(entry['as'] || entry['field'], entry['class_name'].constantize.columns_hash[entry['field']].type, entry['sortable'], klass)
           end  
           
           # Regular concats are CHAR, group_concats are BLOB and need to be cast to CHAR
           options['concatenate'].to_a.each do |entry|
-            save_and_verify_type(entry['as'], 'text', entry['sortable'], klass)
+            extract_table_alias!(entry, klass) # XXX Doesn't actually do anything useful
+            save_and_verify_type(entry['as'], 'text', entry['sortable'], klass) 
           end          
+          
         rescue ActiveRecord::StatementInvalid
           Ultrasphinx.say "warning: model #{model} does not exist in the database yet"
         end  
@@ -147,6 +139,25 @@ This is a special singleton configuration class that stores the index field conf
       self
     end
     
+    def extract_field_alias!(entry, klass)
+      unless entry['as']    
+        entry['as'] = entry['field'] 
+      end
+    end
+    
+    def extract_table_alias!(entry, klass)
+      unless entry['table']
+        # Getting run twice; don't know why
+        if entry['field'] and entry['field'].include? "."
+          # This field is referenced by a table alias
+          entry['table'], entry['field'] = entry['field'].split(".")
+        else
+          klass = entry['class_name'].constantize if entry['class_name']         
+          entry['table'] = klass.table_name
+        end
+      end
+    end
+    
   end
 end
     

data/lib/ultrasphinx/search.rb

@@ -97,13 +97,13 @@ Note that your database is never changed by anything Ultrasphinx does.
     self.query_defaults ||= HashWithIndifferentAccess.new({
       :query => nil,
       :page => 1,
-      :class_names => nil,
       :per_page => 20,
-      :sort_by => 'created_at',
+      :sort_by => nil,
       :sort_mode => 'relevance',
-      :weights => nil,
-      :filters => nil,
-      :facets => nil
+      :weights => {},
+      :class_names => [],
+      :filters => {},
+      :facets => []
     })
     
     cattr_accessor :excerpting_options
@@ -112,38 +112,35 @@ Note that your database is never changed by anything Ultrasphinx does.
       :chunk_separator => "...",
       :limit => 256,
       :around => 3,
-      # results should respond to one in each group of these, in precedence order, for the excerpting to fire
+      # Results should respond to one in each group of these, in precedence order, for the excerpting to fire
       :content_methods => [['title', 'name'], ['body', 'description', 'content'], ['metadata']] 
     })
     
     cattr_accessor :client_options
     self.client_options ||= HashWithIndifferentAccess.new({ 
       :with_subtotals => false, 
+      :ignore_missing_records => false,
       :max_retries => 4,
-      :retry_sleep_time => 3,
+      :retry_sleep_time => 0.5,
       :max_facets => 100,
       :finder_methods => ['get_cache', 'find']
     })
     
-    # mode to integer mappings    
+    # Friendly sort mode mappings    
     SPHINX_CLIENT_PARAMS = HashWithIndifferentAccess.new({ 
       :sort_mode => HashWithIndifferentAccess.new({
-        'relevance' => Sphinx::Client::SPH_SORT_RELEVANCE, 
-        'descending' => Sphinx::Client::SPH_SORT_ATTR_DESC, 
-        'ascending' => Sphinx::Client::SPH_SORT_ATTR_ASC, 
-        'time' => Sphinx::Client::SPH_SORT_TIME_SEGMENTS,
-        'extended' => Sphinx::Client::SPH_SORT_EXTENDED,
-        'desc' => Sphinx::Client::SPH_SORT_ATTR_DESC, # legacy compatibility
-        'asc' => Sphinx::Client::SPH_SORT_ATTR_ASC
+        'relevance' => :relevance,
+        'descending' => :attr_desc, 
+        'ascending' => :attr_asc, 
+        'time' => :time_segments,
+        'extended' => :extended,
       })
     })
     
-    LEGACY_QUERY_KEYS = ['raw_filters', 'filter', 'weight', 'class_name'] #:nodoc:
-    
     INTERNAL_KEYS = ['parsed_query'] #:nodoc:
 
     def self.get_models_to_class_ids #:nodoc:
-      # reading the conf file makes sure that we are in sync with the actual sphinx index,
+      # Reading the conf file makes sure that we are in sync with the actual Sphinx index,
       # not whatever you happened to change your models to most recently
       unless File.exist? CONF_PATH
         Ultrasphinx.say "configuration file not found for #{RAILS_ENV.inspect} environment"
@@ -199,54 +196,45 @@ Note that your database is never changed by anything Ultrasphinx does.
     
     # Returns an array of result objects.
     def results
-      run?(true)
+      require_run
       @results
     end
     
     # Returns the facet map for this query, if facets were used.
     def facets
-      run?(true)
       raise UsageError, "No facet field was configured" unless @options['facets']
+      require_run
       @facets
     end      
           
     # Returns the raw response from the Sphinx client.
     def response
-      run?(true)
+      require_run
       @response
     end
     
-    def class_name #:nodoc:
-      # Legacy accessor
-      @options['class_names']
-    end
-    
     # Returns a hash of total result counts, scoped to each available model. This requires extra queries against the search daemon right now. Set <tt>Ultrasphinx::Search.client_options[:with_subtotals] = true</tt> to enable the extra queries. Most of the overhead is in instantiating the AR result sets, so the performance hit is not usually significant.
     def subtotals
-      run?(true)
-      raise UsageError, "Subtotals are not enabled" unless self.class.client_options['with_subtotals']
+      raise UsageError, "Subtotals are not enabled" unless Ultrasphinx::Search.client_options['with_subtotals']
+      require_run
       @subtotals
     end
 
     # Returns the total result count.
     def total_entries
-      run?(true)
-      [response['total_found'] || 0, MAX_MATCHES].min
+      require_run
+      [response[:total_found] || 0, MAX_MATCHES].min
     end  
   
     # Returns the response time of the query, in milliseconds.
     def time
-      run?(true)
-      response['time']
+      require_run
+      response[:time]
     end
 
     # Returns whether the query has been run.  
-    def run?(should_raise = false)
-      if @response.blank? and should_raise
-        raise UsageError, "Search has not yet been run" unless run?
-      else
-        !@response.blank?
-      end
+    def run?
+      !@response.blank?
     end
  
     # Returns the current page number of the result set. (Page indexes begin at 1.) 
@@ -261,8 +249,8 @@ Note that your database is never changed by anything Ultrasphinx does.
         
     # Returns the last available page number in the result set.  
     def page_count
-      run?(true)    
-      (total_entries / per_page) + (total_entries % per_page == 0 ? 0 : 1)
+      require_run    
+      (total_entries / per_page.to_f).ceil
     end
             
     # Returns the previous page number.
@@ -283,65 +271,48 @@ Note that your database is never changed by anything Ultrasphinx does.
     # Builds a new command-interface Search object.
     def initialize opts = {} 
       opts = HashWithIndifferentAccess.new(opts)            
-      @options = self.class.query_defaults.merge(opts._deep_dup._coerce_basic_types)
+      @options = Ultrasphinx::Search.query_defaults.merge(opts._deep_dup._coerce_basic_types)            
 
-      # Legacy compatibility
-      @options['filters'] ||= @options['filter'] || @options['raw_filters'] || {}
-      @options['class_names'] ||= @options['class_name']
-      @options['weights'] ||= @options['weight']
-            
-      @options._delete(*LEGACY_QUERY_KEYS)
-      
-      # Coerce some special types
       @options['query'] = @options['query'].to_s
       @options['class_names'] = Array(@options['class_names'])
+      @options['facets'] = Array(@options['facets'])
+            
+      raise UsageError, "Weights must be a Hash" unless @options['weights'].is_a? Hash
+      raise UsageError, "Filters must be a Hash" unless @options['filters'].is_a? Hash
       
-      @options['parsed_query'] = if query.blank? 
-         "@empty_searchable #{EMPTY_SEARCHABLE}"
-        else
-          parse(query)
-        end
+      @options['parsed_query'] = parse(query)
   
       @results, @subtotals, @facets, @response = [], {}, {}, {}
         
-      extra_keys = @options.keys - (SPHINX_CLIENT_PARAMS.merge(self.class.query_defaults).keys + LEGACY_QUERY_KEYS + INTERNAL_KEYS)
+      extra_keys = @options.keys - (SPHINX_CLIENT_PARAMS.merge(Ultrasphinx::Search.query_defaults).keys + INTERNAL_KEYS)
       say "discarded invalid keys: #{extra_keys * ', '}" if extra_keys.any? and RAILS_ENV != "test" 
     end
     
     # Run the search, filling results with an array of ActiveRecord objects. Set the parameter to false if you only want the ids returned.
     def run(reify = true)
       @request = build_request_with_options(@options)
-      @paginate = nil # clear cache
-      tries = 0
 
       say "searching for #{@options.inspect}"
 
-      begin
-        @response = @request.Query(parsed_query)
-        say "search returned, error #{@request.GetLastError.inspect}, warning #{@request.GetLastWarning.inspect}, returned #{total_entries}/#{response['total_found']} in #{time} seconds."  
-
-        @subtotals = get_subtotals(@request, parsed_query) if self.class.client_options['with_subtotals']
+      perform_action_with_retries do
+        @response = @request.query(parsed_query, UNIFIED_INDEX_NAME)
+        say "search returned #{total_entries}/#{response[:total_found].to_i} in #{time.to_f} seconds."
+          
+        if Ultrasphinx::Search.client_options['with_subtotals']        
+          @subtotals = get_subtotals(@request, parsed_query) 
+        end
         
         Array(@options['facets']).each do |facet|
           @facets[facet] = get_facets(@request, parsed_query, facet)
-        end
-        
-        @results = response['matches']
+        end        
         
-        # if you don't reify, you'll have to do the modulus reversal yourself to get record ids
+        @results = convert_sphinx_ids(response[:matches])
         @results = reify_results(@results) if reify
-                                
-      rescue Sphinx::SphinxConnectError, Sphinx::SphinxResponseError, Sphinx::SphinxTemporaryError, Errno::ECONNRESET, Errno::EPIPE => e
-        if (tries += 1) <= self.class.client_options['max_retries']
-          say "restarting query (#{tries} attempts already) (#{e})"
-          sleep(self.class.client_options['retry_sleep_time']) if tries == self.class.client_options['max_retries']
-          retry
-        else
-          say "query failed"
-          raise Sphinx::SphinxConnectError, e.to_s
-        end
-      end
-      
+        
+        say "warning; #{response[:warning]}" if response[:warning]
+        raise UsageError, response[:error] if response[:error]
+        
+      end      
       self
     end
   
@@ -350,30 +321,38 @@ Note that your database is never changed by anything Ultrasphinx does.
     # Runs run if it hasn't already been done.
     def excerpt
     
-      run unless run?         
+      require_run         
       return if results.empty?
     
-      # see what fields each result might respond to for our excerpting
+      # See what fields each result might respond to for our excerpting
       results_with_content_methods = results.map do |result|
-        [result] << self.class.excerpting_options['content_methods'].map do |methods|
+        [result] << Ultrasphinx::Search.excerpting_options['content_methods'].map do |methods|
           methods.detect { |x| result.respond_to? x }
         end
       end
   
-      # fetch the actual field contents
-      texts = results_with_content_methods.map do |result, methods|
+      # Fetch the actual field contents
+      docs = results_with_content_methods.map do |result, methods|
         methods.map do |method| 
           method and strip_bogus_characters(result.send(method)) or ""
         end
       end.flatten
-  
-      # ship to sphinx to highlight and excerpt
-      responses = @request.BuildExcerpts(
-        texts, 
-        UNIFIED_INDEX_NAME, 
-        strip_query_commands(parsed_query),
-        self.class.excerpting_options.except('content_methods')
-      ).in_groups_of(self.class.excerpting_options['content_methods'].size)
+      
+      excerpting_options = {
+        :docs => docs, 
+        :index => UNIFIED_INDEX_NAME, 
+        :words => strip_query_commands(parsed_query)}
+      Ultrasphinx::Search.excerpting_options.except('content_methods').each do |key, value|
+        # Riddle only wants symbols
+        excerpting_options[key.to_sym] ||= value
+      end
+      
+      responses = perform_action_with_retries do 
+        # Ship to Sphinx to highlight and excerpt
+        @request.excerpts(excerpting_options)
+      end
+      
+      responses = responses.in_groups_of(Ultrasphinx::Search.excerpting_options['content_methods'].size)
       
       results_with_content_methods.each_with_index do |result_and_methods, i|
         # override the individual model accessors with the excerpted data
@@ -391,7 +370,7 @@ Note that your database is never changed by anything Ultrasphinx does.
     end  
     
             
-    # Delegates enumerable methods to @results, if possible. This allows us to behave directly like a WillPaginate::Collection. Failing that, we delegate to the options hash if a key is set. This lets us use the <tt>self</tt> directly in view helpers.
+    # Delegates enumerable methods to @results, if possible. This allows us to behave directly like a WillPaginate::Collection. Failing that, we delegate to the options hash if a key is set. This lets us use <tt>self</tt> directly in view helpers.
     def method_missing(*args, &block)
       if @results.respond_to? args.first
         @results.send(*args, &block)
@@ -406,5 +385,11 @@ Note that your database is never changed by anything Ultrasphinx does.
       Ultrasphinx.say msg
     end
     
+    private
+    
+    def require_run
+      run unless run?
+    end
+    
   end
 end