thinking-sphinx 2.1.0 → 3.0.0.pre

data/lib/thinking_sphinx/real_time/attribute.rb

@@ -0,0 +1,5 @@
+class ThinkingSphinx::RealTime::Attribute < ThinkingSphinx::RealTime::Property
+  def type
+    @options[:type]
+  end
+end

data/lib/thinking_sphinx/real_time/callbacks/real_time_callbacks.rb

@@ -0,0 +1,48 @@
+class ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks <
+  ThinkingSphinx::Callbacks
+
+  callbacks :after_save
+
+  def after_save
+    return unless real_time_indices?
+
+    real_time_indices.each do |index|
+      columns, values = ['id'], [index.document_id_for_key(instance.id)]
+      (index.fields + index.attributes).each do |property|
+        columns << property.name
+        values  << property.translate(instance)
+      end
+
+      sphinxql = Riddle::Query::Insert.new(index.name, columns, values).replace!
+      connection.query sphinxql.to_sql
+    end
+  end
+
+  private
+
+  def config
+    ThinkingSphinx::Configuration.instance
+  end
+
+  def connection
+    connection = config.connection
+  end
+
+  def indices
+    @indices ||= config.indices_for_references reference
+  end
+
+  def real_time_indices?
+    real_time_indices.any?
+  end
+
+  def real_time_indices
+    @real_time_indices ||= indices.select { |index|
+      index.is_a? ThinkingSphinx::RealTime::Index
+    }
+  end
+
+  def reference
+    instance.class.name.underscore.to_sym
+  end
+end

data/lib/thinking_sphinx/real_time/field.rb

@@ -0,0 +1,3 @@
+class ThinkingSphinx::RealTime::Field < ThinkingSphinx::RealTime::Property
+  #
+end

data/lib/thinking_sphinx/real_time/index.rb

@@ -0,0 +1,47 @@
+class ThinkingSphinx::RealTime::Index < Riddle::Configuration::RealtimeIndex
+  include ThinkingSphinx::Core::Index
+
+  attr_accessor :fields, :attributes
+
+  def initialize(reference, options = {})
+    @fields     = []
+    @attributes = []
+
+    Template.new(self).apply
+
+    super reference, options
+  end
+
+  def unique_attribute_names
+    attributes.collect(&:name)
+  end
+
+  private
+
+  def interpreter
+    ThinkingSphinx::RealTime::Interpreter
+  end
+
+  def pre_render
+    super
+
+    @rt_field = fields.collect &:name
+
+    attributes.each do |attribute|
+      case attribute.type
+      when :integer, :boolean
+        @rt_attr_uint << attribute.name unless @rt_attr_uint.include?(attribute.name)
+      when :string
+        @rt_attr_string << attribute.name unless @rt_attr_string.include?(attribute.name)
+      when :timestamp
+        @rt_attr_timestamp << attribute.name unless @rt_attr_timestamp.include?(attribute.name)
+      when :float
+        @rt_attr_float << attribute.name unless @rt_attr_float.include?(attribute.name)
+      else
+        raise "Unknown attribute type '#{attribute.type(model)}'"
+      end
+    end
+  end
+end
+
+require 'thinking_sphinx/real_time/index/template'

data/lib/thinking_sphinx/real_time/index/template.rb

@@ -0,0 +1,33 @@
+class ThinkingSphinx::RealTime::Index::Template
+  attr_reader :index
+
+  def initialize(index)
+    @index = index
+  end
+
+  def apply
+    add_field class_column, :sphinx_internal_class
+
+    add_attribute :id, :sphinx_internal_id, :integer
+    add_attribute 0,   :sphinx_deleted,     :integer
+  end
+
+  private
+
+  def add_attribute(column, name, type)
+    index.attributes << ThinkingSphinx::RealTime::Attribute.new(
+      ThinkingSphinx::ActiveRecord::Column.new(*column),
+      :as => name, :type => type
+    )
+  end
+
+  def add_field(column, name)
+    index.fields << ThinkingSphinx::RealTime::Field.new(
+      ThinkingSphinx::ActiveRecord::Column.new(*column), :as => name
+    )
+  end
+
+  def class_column
+    [:class, :name]
+  end
+end

data/lib/thinking_sphinx/real_time/interpreter.rb

@@ -0,0 +1,23 @@
+class ThinkingSphinx::RealTime::Interpreter <
+  ::ThinkingSphinx::Core::Interpreter
+
+  def has(*columns)
+    options = columns.extract_options!
+    @index.attributes += columns.collect { |column|
+      ::ThinkingSphinx::RealTime::Attribute.new column, options
+    }
+  end
+
+  def indexes(*columns)
+    options = columns.extract_options!
+    @index.fields += columns.collect { |column|
+      ::ThinkingSphinx::RealTime::Field.new column, options
+    }
+  end
+
+  def set_property(properties)
+    properties.each do |key, value|
+      @index.send("#{key}=", value)   if @index.class.settings.include?(key)
+    end
+  end
+end

data/lib/thinking_sphinx/real_time/property.rb

@@ -0,0 +1,16 @@
+class ThinkingSphinx::RealTime::Property
+  def initialize(column, options = {})
+    @column, @options = column, options
+  end
+
+  def name
+    (@options[:as] || @column.__name).to_s
+  end
+
+  def translate(object)
+    return @column.__name unless @column.__name.is_a?(Symbol)
+
+    base = @column.__stack.inject(object) { |base, node| base.try(node) }
+    base.try(@column.__name)
+  end
+end

data/lib/thinking_sphinx/scopes.rb

@@ -0,0 +1,22 @@
+module ThinkingSphinx::Scopes
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def sphinx_scope(name, &block)
+      sphinx_scopes[name] = block
+    end
+
+    def sphinx_scopes
+      @sphinx_scopes ||= {}
+    end
+
+    private
+
+    def method_missing(method, *args, &block)
+      return super unless sphinx_scopes.keys.include?(method)
+
+      query, options = sphinx_scopes[method].call(*args)
+      search query, (options || {})
+    end
+  end
+end

data/lib/thinking_sphinx/search.rb

@@ -1,1054 +1,116 @@
-# encoding: UTF-8
-module ThinkingSphinx
-  # Once you've got those indexes in and built, this is the stuff that
-  # matters - how to search! This class provides a generic search
-  # interface - which you can use to search all your indexed models at once.
-  # 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 < Array
-    CoreMethods = %w( == class class_eval extend frozen? id instance_eval
-      instance_of? instance_values instance_variable_defined?
-      instance_variable_get instance_variable_set instance_variables is_a?
-      kind_of? member? method methods nil? object_id respond_to?
-      respond_to_missing? send should tap type )
-    SafeMethods = %w( partition private_methods protected_methods
-      public_methods send class )
-
-    instance_methods.select { |method|
-      method.to_s[/^__/].nil? && !CoreMethods.include?(method.to_s)
-    }.each { |method|
-      undef_method method
-    }
-
-    HashOptions   = [:conditions, :with, :without, :with_all, :without_any]
-    ArrayOptions  = [:classes, :without_ids]
-
-    attr_reader :args, :options
-
-    # Deprecated. Use ThinkingSphinx.search
-    def self.search(*args)
-      warn 'ThinkingSphinx::Search.search is deprecated. Please use ThinkingSphinx.search instead.'
-      ThinkingSphinx.search(*args)
-    end
-
-    # Deprecated. Use ThinkingSphinx.search_for_ids
-    def self.search_for_ids(*args)
-      warn 'ThinkingSphinx::Search.search_for_ids is deprecated. Please use ThinkingSphinx.search_for_ids instead.'
-      ThinkingSphinx.search_for_ids(*args)
-    end
-
-    # Deprecated. Use ThinkingSphinx.search_for_ids
-    def self.search_for_id(*args)
-      warn 'ThinkingSphinx::Search.search_for_id is deprecated. Please use ThinkingSphinx.search_for_id instead.'
-      ThinkingSphinx.search_for_id(*args)
-    end
-
-    # Deprecated. Use ThinkingSphinx.count
-    def self.count(*args)
-      warn 'ThinkingSphinx::Search.count is deprecated. Please use ThinkingSphinx.count instead.'
-      ThinkingSphinx.count(*args)
-    end
-
-    # Deprecated. Use ThinkingSphinx.facets
-    def self.facets(*args)
-      warn 'ThinkingSphinx::Search.facets is deprecated. Please use ThinkingSphinx.facets instead.'
-      ThinkingSphinx.facets(*args)
-    end
-
-    def self.warn(message)
-      ::ActiveSupport::Deprecation.warn message
-    end
-
-    def self.bundle_searches(enum = nil)
-      bundle = ThinkingSphinx::BundledSearch.new
-
-      if enum.nil?
-        yield bundle
-      else
-        enum.each { |item| yield bundle, item }
-      end
-
-      bundle.searches
-    end
-
-    def self.matching_fields(fields, bitmask)
-      matches   = []
-      bitstring = bitmask.to_s(2).rjust(32, '0').reverse
-
-      fields.each_with_index do |field, index|
-        matches << field if bitstring[index, 1] == '1'
-      end
-      matches
-    end
-
-    def initialize(*args)
-      ThinkingSphinx.context.define_indexes
-
-      @array    = []
-      @options  = args.extract_options!
-      @args     = args
-
-      add_default_scope unless options[:ignore_default]
-
-      populate if @options[:populate]
-    end
-
-    def ==(object)
-      populate
-      super
-    end
-
-    def to_a
-      populate
-      @array
-    end
-
-    # Populates the search result set
-    def all
-      populate
-      self
-    end
-
-    def freeze
-      populate
-      @array.freeze
-      self
-    end
-
-    def as_json(*args)
-      populate
-      @array.as_json(*args)
-    end
-
-    # Indication of whether the request has been made to Sphinx for the search
-    # query.
-    #
-    # @return [Boolean] true if the results have been requested.
-    #
-    def populated?
-      !!@populated
-    end
-
-    # Indication of whether the request resulted in an error from Sphinx.
-    #
-    # @return [Boolean] true if Sphinx reports query error
-    #
-    def error?
-      !!error
-    end
-
-    # The Sphinx-reported error, if any.
-    #
-    # @return [String, nil]
-    #
-    def error
-      populate
-      @results[:error]
-    end
-
-    # Indication of whether the request resulted in a warning from Sphinx.
-    #
-    # @return [Boolean] true if Sphinx reports query warning
-    #
-    def warning?
-      !!warning
-    end
-
-    # The Sphinx-reported warning, if any.
-    #
-    # @return [String, nil]
-    #
-    def warning
-      populate
-      @results[:warning]
-    end
-
-    # The query result hash from Riddle.
-    #
-    # @return [Hash] Raw Sphinx results
-    #
-    def results
-      populate
-      @results
-    end
-
-    def method_missing(method, *args, &block)
-      if is_scope?(method)
-        add_scope(method, *args, &block)
-        return self
-      elsif method == :search_count
-        merge_search one_class.search(*args), self.args, options
-        return scoped_count
-      elsif method.to_s[/^each_with_.*/].nil? && !@array.respond_to?(method)
-        super
-      elsif !SafeMethods.include?(method.to_s)
-        populate
-      end
-
-      if method.to_s[/^each_with_.*/] && !@array.respond_to?(method)
-        each_with_attribute method.to_s.gsub(/^each_with_/, ''), &block
-      else
-        @array.send(method, *args, &block)
-      end
-    end
-
-    # Returns true if the Search object or the underlying Array object respond
-    # to the requested method.
-    #
-    # @param [Symbol] method The method name
-    # @return [Boolean] true if either Search or Array responds to the method.
-    #
-    def respond_to?(method, include_private = false)
-      super || @array.respond_to?(method, include_private)
-    end
-
-    # The current page number of the result set. Defaults to 1 if no page was
-    # explicitly requested.
-    #
-    # @return [Integer]
-    #
-    def current_page
-      @options[:page].blank? ? 1 : @options[:page].to_i
-    end
-
-    def first_page?
-      current_page == 1
-    end
-
-    # Kaminari support
-    def page(page_number)
-      @options[:page] = page_number
-      self
-    end
-
-    # The next page number of the result set. If there are no more pages
-    # available, nil is returned.
-    #
-    # @return [Integer, nil]
-    #
-    def next_page
-      current_page >= total_pages ? nil : current_page + 1
-    end
-
-    def next_page?
-      !next_page.nil?
-    end
-
-    def last_page?
-      next_page.nil?
-    end
-
-    # The previous page number of the result set. If this is the first page,
-    # then nil is returned.
-    #
-    # @return [Integer, nil]
-    #
-    def previous_page
-      current_page == 1 ? nil : current_page - 1
-    end
-
-    # The amount of records per set of paged results. Defaults to 20 unless a
-    # specific page size is requested.
-    #
-    # @return [Integer]
-    #
-    def per_page
-      @options[:limit] ||= @options[:per_page]
-      @options[:limit] ||= 20
-      @options[:limit].to_i
-    end
-    # Kaminari support
-    alias_method :limit_value, :per_page
-
-    # Kaminari support
-    def per(limit)
-      @options[:limit] = limit
-      self
-    end
-
-    # The total number of pages available if the results are paginated.
-    #
-    # @return [Integer]
-    #
-    def total_pages
-      populate
-      return 0 if @results.nil? || @results[:total].nil?
-
-      @total_pages ||= (@results[:total] / per_page.to_f).ceil
-    end
-    # Compatibility with kaminari and older versions of will_paginate
-    alias_method :page_count, :total_pages
-    alias_method :num_pages,  :total_pages
-
-    # Query time taken
-    #
-    # @return [Integer]
-    #
-    def query_time
-      populate
-      return 0 if @results[:time].nil?
-
-      @query_time ||= @results[:time]
-    end
-
-    # The total number of search results available.
-    #
-    # @return [Integer]
-    #
-    def total_entries
-      populate
-      return 0 if @results.nil? || @results[:total_found].nil?
-
-      @total_entries ||= @results[:total_found]
-    end
-
-    # Compatibility with kaminari
-    alias_method :total_count, :total_entries
-
-    # The current page's offset, based on the number of records per page.
-    # Or explicit :offset if given.
-    #
-    # @return [Integer]
-    #
-    def offset
-      @options[:offset] || ((current_page - 1) * per_page)
-    end
-
-    alias_method :offset_value, :offset
-
-    def indexes
-      return options[:index] if options[:index]
-      return '*' if classes.empty?
-
-      classes.collect { |klass|
-        klass.sphinx_index_names
-      }.flatten.uniq.join(',')
-    end
-
-    def each_with_groupby_and_count(&block)
-      populate
-      results[:matches].each_with_index do |match, index|
-        yield self[index],
-          match[:attributes]["@groupby"],
-          match[:attributes]["@count"]
-      end
-    end
-    alias_method :each_with_group_and_count, :each_with_groupby_and_count
-
-    def each_with_weighting(&block)
-      populate
-      results[:matches].each_with_index do |match, index|
-        yield self[index], match[:weight]
-      end
-    end
-
-    def each_with_match(&block)
-      populate
-      results[:matches].each_with_index do |match, index|
-        yield self[index], match
-      end
-    end
-
-    def excerpt_for(string, model = nil)
-      if model.nil? && one_class
-        model ||= one_class
-      end
-
-      populate
-
-      index = options[:index] || "#{model.core_index_names.first}"
-      take_client do |client|
-        client.excerpts(
-          {
-            :docs   => [string.to_s],
-            :words  => query,
-            :index  => index.split(',').first.strip
-          }.merge(options[:excerpt_options] || {})
-        ).first
-      end
-    end
-
-    def search(*args)
-      args << args.extract_options!.merge(:ignore_default => true)
-      merge_search ThinkingSphinx::Search.new(*args), self.args, options
-      self
-    end
-
-    def search_for_ids(*args)
-      args << args.extract_options!.merge(
-        :ignore_default => true,
-        :ids_only       => true
-      )
-      merge_search ThinkingSphinx::Search.new(*args), self.args, options
-      self
-    end
-
-    def facets(*args)
-      options = args.extract_options!
-      merge_search self, args, options
-      args << options
-
-      ThinkingSphinx::FacetSearch.new(*args)
-    end
-
-    def take_client
-      if options[:client]
-        prepare options[:client]
-        yield options[:client]
-      else
-        ThinkingSphinx::Connection.take do |client|
-          prepare client
-          yield client
-        end
-      end
-    end
-
-    def append_to(client)
-      prepare client
-      client.append_query query, indexes, comment
-      client.reset
-    end
-
-    def populate_from_queue(results)
-      return if @populated
-      @populated = true
-      @results   = results
-
-      compose_results
-    end
-
-    private
+class ThinkingSphinx::Search < Array
+  CORE_METHODS = %w( == class class_eval extend frozen? id instance_eval
+    instance_of? instance_values instance_variable_defined?
+    instance_variable_get instance_variable_set instance_variables is_a?
+    kind_of? member? method methods nil? object_id respond_to?
+    respond_to_missing? send should should_not type )
+  SAFE_METHODS = %w( partition private_methods protected_methods public_methods
+    send class )
+  DEFAULT_MASKS = [
+    ThinkingSphinx::Masks::PaginationMask,
+    ThinkingSphinx::Masks::ScopesMask
+  ]
+
+  instance_methods.select { |method|
+    method.to_s[/^__/].nil? && !CORE_METHODS.include?(method.to_s)
+  }.each { |method|
+    undef_method method
+  }
+
+  attr_reader   :options, :masks
+  attr_accessor :query
+
+  def initialize(query = nil, options = {})
+    query, options   = nil, query if query.is_a?(Hash)
+    @query, @options = query, options
+    @masks           = @options.delete(:masks) || DEFAULT_MASKS
+    @middleware      = @options.delete(:middleware)
+
+    populate if options[:populate]
+  end
 
-    def config
+  def context
+    @context ||= ThinkingSphinx::Search::Context.new self,
       ThinkingSphinx::Configuration.instance
-    end
-
-    def populate
-      return if @populated
-      @populated = true
-      retries    = hard_retries
-
-      begin
-        retry_on_stale_index do
-          begin
-            @results = nil
-            log query do
-              take_client do |client|
-                @results = client.query query, indexes, comment
-              end
-            end
-            total = @results[:total_found].to_i
-            log "Found #{total} result#{'s' unless total == 1}"
-            log "Sphinx Daemon returned warning: #{warning}" if warning?
-
-            if error?
-              log "Sphinx Daemon returned error: #{error}"
-              raise SphinxError.new(error, @results) unless options[:ignore_errors]
-            end
-          rescue Errno::ECONNREFUSED => err
-            raise ThinkingSphinx::ConnectionError,
-              'Connection to Sphinx Daemon (searchd) failed.'
-          end
-
-          compose_results
-        end
-      rescue => e
-        log 'Caught Sphinx exception: %s (%s %s left)' % [
-          e.message, retries, (retries == 1 ? 'try' : 'tries')
-        ]
-        retries -= 1
-        if retries >= 0
-          retry
-        else
-          raise e
-        end
-      end
-    end
-
-    def compose_results
-      if options[:ids_only]
-        compose_ids_results
-      elsif options[:attributes_only]
-        compose_attributes_results
-      elsif options[:only]
-        compose_only_results
-      else
-        replace instances_from_matches
-        add_excerpter
-        add_sphinx_attributes
-        add_matching_fields if options[:rank_mode] == :fieldmask
-      end
-    end
-
-    def compose_ids_results
-      replace @results[:matches].collect { |match|
-        match[:attributes]['sphinx_internal_id']
-      }
-    end
-
-    def compose_attributes_results
-      replace @results[:matches].collect { |match|
-        attributes = {}
-        match[:attributes].each do |name, value|
-          attributes[name.to_sym] = match[:attributes][name]
-        end
-        attributes
-      }
-    end
-
-    def compose_only_results
-      replace @results[:matches].collect { |match|
-        case only = options[:only]
-        when String, Symbol
-          match[:attributes][only.to_s]
-        when Array
-          only.inject({}) do |hash, attribute|
-            hash[attribute.to_sym] = match[:attributes][attribute.to_s]
-            hash
-          end
-        else
-          raise "Unexpected object for :only argument. String or Array is expected, #{only.class} was received."
-        end
-      }
-    end
-
-    def add_excerpter
-      each do |object|
-        next if object.nil?
-
-        object.excerpts = ThinkingSphinx::Excerpter.new self, object
-      end
-    end
-
-    def add_sphinx_attributes
-      each do |object|
-        next if object.nil?
-
-        match = match_hash object
-        next if match.nil?
-
-        object.sphinx_attributes = match[:attributes]
-      end
-    end
-
-    def add_matching_fields
-      each do |object|
-        next if object.nil?
-
-        match = match_hash object
-        next if match.nil?
-        object.matching_fields = ThinkingSphinx::Search.matching_fields(
-          @results[:fields], match[:weight]
-        )
-      end
-    end
-
-    def match_hash(object)
-      @results[:matches].detect { |match|
-        class_crc = object.class.name
-        class_crc = object.class.to_crc32 if Riddle.loaded_version.to_i < 2
-
-        match[:attributes]['sphinx_internal_id'] == object.
-          primary_key_for_sphinx &&
-        match[:attributes][crc_attribute] == class_crc
-      }
-    end
-
-    def self.log(message, &block)
-      if ThinkingSphinx::ActiveRecord::LogSubscriber.logger.nil?
-        yield if block_given?
-        return
-      end
-
-      if block_given?
-        ::ActiveSupport::Notifications.
-          instrument('query.thinking_sphinx', :query => message, &block)
-      else
-        ::ActiveSupport::Notifications.
-          instrument('message.thinking_sphinx', :message => message)
-      end
-    end
-
-    def log(query, &block)
-      self.class.log(query, &block)
-    end
-
-    def prepare(client)
-      index_options = {}
-      if one_class && one_class.sphinx_indexes && one_class.sphinx_indexes.first
-        index_options = one_class.sphinx_indexes.first.local_options
-      end
-
-      [
-        :max_matches, :group_by, :group_function, :group_clause,
-        :group_distinct, :id_range, :cut_off, :retry_count, :retry_delay,
-        :rank_mode, :rank_expr, :max_query_time, :field_weights
-      ].each do |key|
-        value = options[key] || index_options[key]
-        client.send("#{key}=", value) if value
-      end
-
-      # treated non-standard as :select is already used for AR queries
-      client.select = options[:sphinx_select] || '*'
-
-      client.limit      = per_page
-      client.offset     = offset
-      client.match_mode = match_mode
-      client.filters    = filters
-      client.sort_mode  = sort_mode
-      client.sort_by    = sort_by
-      client.group_by   = group_by if group_by
-      client.group_function = group_function if group_function
-      client.index_weights  = index_weights
-      client.anchor     = anchor
-
-      client
-    end
-
-    def retry_on_stale_index(&block)
-      stale_ids = []
-      retries   = stale_retries
-
-      begin
-        options[:raise_on_stale] = retries > 0
-        block.call
-
-        # If ThinkingSphinx::Search#instances_from_matches found records in
-        # Sphinx but not in the DB and the :raise_on_stale option is set, this
-        # exception is raised. We retry a limited number of times, excluding the
-        # stale ids from the search.
-      rescue StaleIdsException => err
-        retries -= 1
-
-        # For logging
-        stale_ids |= err.ids
-        # ID exclusion
-        options[:without_ids] = Array(options[:without_ids]) | err.ids
-
-        log 'Stale Ids (%s %s left): %s' % [
-          retries, (retries == 1 ? 'try' : 'tries'), stale_ids.join(', ')
-        ]
-        retry
-      end
-    end
-
-    def classes
-      @classes ||= options[:classes] || []
-    end
-
-    def one_class
-      @one_class ||= classes.length != 1 ? nil : classes.first
-    end
-
-    def query
-      @query ||= begin
-        q = @args.join(' ') << conditions_as_query
-        (options[:star] ? star_query(q) : q).strip
-      end
-    end
-
-    def conditions_as_query
-      return '' if @options[:conditions].blank?
-
-      ' ' + @options[:conditions].keys.collect { |key|
-        search_key = key.is_a?(::Array) ? "(#{key.join(',')})" : key
-        "@#{search_key} #{options[:conditions][key]}"
-      }.join(' ')
-    end
-
-    def star_query(query)
-      token = options[:star].is_a?(Regexp) ? options[:star] : default_star_token
-
-      query.gsub(/("#{token}(.*?#{token})?"|(?![!-])#{token})/u) do
-        pre, proper, post = $`, $&, $'
-        # E.g. "@foo", "/2", "~3", but not as part of a token
-        is_operator = pre.match(%r{(\W|^)[@~/]\Z}) ||
-                      pre.match(%r{(\W|^)@\([^\)]*$})
-        # E.g. "foo bar", with quotes
-        is_quote    = proper.starts_with?('"') && proper.ends_with?('"')
-        has_star    = pre.ends_with?("*") || post.starts_with?("*")
-        if is_operator || is_quote || has_star
-          proper
-        else
-          "*#{proper}*"
-        end
-      end
-    end
-
-    if Regexp.instance_methods.include?(:encoding)
-      DefaultStarToken = Regexp.new('\p{Word}+')
-    else
-      DefaultStarToken = Regexp.new('\w+', nil, 'u')
-    end
-
-    def default_star_token
-      DefaultStarToken
-    end
-
-    def comment
-      options[:comment] || ''
-    end
-
-    def match_mode
-      options[:match_mode] || (options[:conditions].blank? ? :all : :extended)
-    end
-
-    def sort_mode
-      @sort_mode ||= case options[:sort_mode]
-      when :asc
-        :attr_asc
-      when :desc
-        :attr_desc
-      when nil
-        case options[:order]
-        when String
-          :extended
-        when Symbol
-          :attr_asc
-        else
-          :relevance
-        end
-      else
-        options[:sort_mode]
-      end
-    end
-
-    def sort_by
-      case @sort_by = (options[:sort_by] || options[:order])
-      when String
-        sorted_fields_to_attributes(@sort_by.clone)
-      when Symbol
-        field_names.include?(@sort_by) ?
-          @sort_by.to_s.concat('_sort') : @sort_by.to_s
-      else
-        ''
-      end
-    end
-
-    def field_names
-      return [] unless one_class
-
-      one_class.sphinx_indexes.collect { |index|
-        index.fields.collect { |field| field.unique_name }
-      }.flatten
-    end
-
-    def sorted_fields_to_attributes(order_string)
-      field_names.each { |field|
-        order_string.gsub!(/(^|\s)#{field}(,?\s|$)/) { |match|
-          match.gsub field.to_s, field.to_s.concat("_sort")
-        }
-      }
-
-      order_string
-    end
-
-    # Turn :index_weights => { "foo" => 2, User => 1 } into :index_weights =>
-    # { "foo" => 2, "user_core" => 1, "user_delta" => 1 }
-    #
-    def index_weights
-      weights = options[:index_weights] || {}
-      weights.keys.inject({}) do |hash, key|
-        if key.is_a?(Class)
-          name = ThinkingSphinx::Index.name_for(key)
-          hash["#{name}_core"]  = weights[key]
-          hash["#{name}_delta"] = weights[key]
-        else
-          hash[key] = weights[key]
-        end
-
-        hash
-      end
-    end
-
-    def group_by
-      options[:group] ? options[:group].to_s : nil
-    end
-
-    def group_function
-      options[:group] ? :attr : nil
-    end
-
-    def internal_filters
-      filters = [Riddle::Client::Filter.new('sphinx_deleted', [0])]
-
-      class_crcs = classes.collect { |klass|
-        klass.to_crc32s
-      }.flatten
-
-      unless class_crcs.empty?
-        filters << Riddle::Client::Filter.new('class_crc', class_crcs)
-      end
-
-      filters << Riddle::Client::Filter.new(
-        'sphinx_internal_id', filter_value(options[:without_ids]), true
-      ) unless options[:without_ids].nil? || options[:without_ids].empty?
-
-      filters
-    end
-
-    def filters
-      internal_filters +
-      (options[:with] || {}).collect { |attrib, value|
-        Riddle::Client::Filter.new attrib.to_s, filter_value(value)
-      } +
-      (options[:without] || {}).collect { |attrib, value|
-        Riddle::Client::Filter.new attrib.to_s, filter_value(value), true
-      } +
-      (options[:with_all] || {}).collect { |attrib, values|
-        Array(values).collect { |value|
-          Riddle::Client::Filter.new attrib.to_s, filter_value(value)
-        }
-      }.flatten +
-      (options[:without_any] || {}).collect { |attrib, values|
-        Array(values).collect { |value|
-          Riddle::Client::Filter.new attrib.to_s, filter_value(value), true
-        }
-      }.flatten
-    end
-
-    # When passed a Time instance, returns the integer timestamp.
-    def filter_value(value)
-      case value
-      when Range
-        filter_value(value.first).first..filter_value(value.last).first
-      when Array
-        value.collect { |v| filter_value(v) }.flatten
-      when Time
-        [value.to_i]
-      when Date
-        [Time.utc(value.year, value.month, value.day).to_i]
-      when NilClass
-        0
-      else
-        Array(value)
-      end
-    end
-
-    def anchor
-      return {} unless options[:geo] || (options[:lat] && options[:lng])
-
-      {
-        :latitude   => options[:geo] ? options[:geo].first : options[:lat],
-        :longitude  => options[:geo] ? options[:geo].last  : options[:lng],
-        :latitude_attribute  => latitude_attr.to_s,
-        :longitude_attribute => longitude_attr.to_s
-      }
-    end
-
-    def latitude_attr
-      options[:latitude_attr]      ||
-      index_option(:latitude_attr) ||
-      attribute(:lat, :latitude)
-    end
-
-    def longitude_attr
-      options[:longitude_attr]      ||
-      index_option(:longitude_attr) ||
-      attribute(:lon, :lng, :longitude)
-    end
+  end
 
-    def index_option(key)
-      return nil unless one_class
+  def meta
+    populate
+    context[:meta]
+  end
 
-      one_class.sphinx_indexes.collect { |index|
-        index.local_options[key]
-      }.compact.first
-    end
+  def offset
+    @options[:offset] || ((current_page - 1) * per_page)
+  end
 
-    def attribute(*keys)
-      return nil unless one_class
+  alias_method :offset_value, :offset
 
-      keys.detect { |key|
-        attributes.include?(key)
-      }
-    end
+  def per_page
+    @options[:limit] ||= (@options[:per_page] || 20)
+    @options[:limit].to_i
+  end
 
-    def attributes
-      return [] unless one_class
+  alias_method :limit_value, :per_page
 
-      attributes = one_class.sphinx_indexes.collect { |index|
-        index.attributes.collect { |attrib| attrib.unique_name }
-      }.flatten
-    end
+  def populate
+    return self if @populated
 
-    def stale_retries
-      case options[:retry_stale]
-      when TrueClass
-        3
-      when nil, FalseClass
-        0
-      else
-        options[:retry_stale].to_i
-      end
-    end
-
-    def hard_retries
-      options[:hard_retry_count] || config.hard_retry_count
-    end
+    middleware.call [context]
+    @populated = true
 
-    def include_for_class(klass)
-      includes = options[:include] || klass.sphinx_index_options[:include]
-
-      case includes
-      when NilClass
-        nil
-      when Array
-        include_from_array includes, klass
-      when Symbol
-        klass.reflections[includes].nil? ? nil : includes
-      when Hash
-        include_from_hash includes, klass
-      else
-        includes
-      end
-    end
+    self
+  end
 
-    def include_from_array(array, klass)
-      scoped_array = []
-      array.each do |value|
-        case value
-        when Hash
-          scoped_hash = include_from_hash(value, klass)
-          scoped_array << scoped_hash unless scoped_hash.nil?
-        else
-          scoped_array << value unless klass.reflections[value].nil?
-        end
-      end
-      scoped_array.empty? ? nil : scoped_array
-    end
+  def populated!
+    @populated = true
+  end
 
-    def include_from_hash(hash, klass)
-      scoped_hash = {}
-      hash.keys.each do |key|
-        scoped_hash[key] = hash[key] unless klass.reflections[key].nil?
-      end
-      scoped_hash.empty? ? nil : scoped_hash
-    end
+  def raw
+    populate
+    context[:raw]
+  end
 
-    def instances_from_class(klass, matches)
-      index_options = klass.sphinx_index_options
+  def respond_to?(method, include_private = false)
+    super || context[:results].respond_to?(method, include_private)
+  end
 
-      ids = matches.collect { |match| match[:attributes]["sphinx_internal_id"] }
-      instances = ids.length > 0 ? klass.unscoped.find(
-        :all,
-        :joins      => options[:joins],
-        :conditions => {klass.primary_key_for_sphinx.to_sym => ids},
-        :include    => include_for_class(klass),
-        :select     => (options[:select]  || index_options[:select]),
-        :order      => (options[:sql_order] || index_options[:sql_order])
-      ) : []
+  def to_a
+    populate
+    context[:results].collect { |result|
+      result.respond_to?(:unglazed) ? result.unglazed : result
+    }
+  end
 
-      # Raise an exception if we find records in Sphinx but not in the DB, so
-      # the search method can retry without them. See
-      # ThinkingSphinx::Search.retry_search_on_stale_index.
-      if options[:raise_on_stale] && instances.length < ids.length
-        stale_ids = ids - instances.map { |i| i.id }
-        raise StaleIdsException, stale_ids
-      end
+  private
 
-      # if the user has specified an SQL order, return the collection
-      # without rearranging it into the Sphinx order
-      return instances if (options[:sql_order] || index_options[:sql_order])
+  def mask_stack
+    @mask_stack ||= masks.collect { |klass| klass.new self }
+  end
 
-      ids.collect { |obj_id|
-        instances.detect do |obj|
-          obj.primary_key_for_sphinx == obj_id
-        end
-      }
+  def method_missing(method, *args, &block)
+    mask_stack.each do |mask|
+      return mask.send(method, *args, &block) if mask.respond_to?(method)
     end
 
-    # Group results by class and call #find(:all) once for each group to reduce
-    # the number of #find's in multi-model searches.
-    #
-    def instances_from_matches
-      return single_class_results if one_class
+    populate if !SAFE_METHODS.include?(method.to_s)
 
-      groups = results[:matches].group_by { |match|
-        match[:attributes][crc_attribute]
-      }
-      groups.each do |crc, group|
-        group.replace(
-          instances_from_class(class_from_crc(crc), group)
-        )
-      end
-
-      results[:matches].collect do |match|
-        groups.detect { |crc, group|
-          crc == match[:attributes][crc_attribute]
-        }[1].compact.detect { |obj|
-          obj.primary_key_for_sphinx == match[:attributes]["sphinx_internal_id"]
-        }
-      end
-    end
-
-    def single_class_results
-      instances_from_class one_class, results[:matches]
-    end
+    context[:results].send(method, *args, &block)
+  end
 
-    def class_from_crc(crc)
-      if Riddle.loaded_version.to_i < 2
-        config.models_by_crc[crc].constantize
+  def middleware
+    @middleware ||= begin
+      if options[:ids_only]
+        ThinkingSphinx::Middlewares::IDS_ONLY
       else
-        crc.constantize
-      end
-    end
-
-    def each_with_attribute(attribute, &block)
-      populate
-      results[:matches].each_with_index do |match, index|
-        yield self[index],
-          (match[:attributes][attribute] || match[:attributes]["@#{attribute}"])
+        ThinkingSphinx::Middlewares::DEFAULT
       end
     end
-
-    def is_scope?(method)
-      one_class && one_class.sphinx_scopes.include?(method)
-    end
-
-    # Adds the default_sphinx_scope if set.
-    def add_default_scope
-      return unless one_class && one_class.has_default_sphinx_scope?
-      add_scope(one_class.get_default_sphinx_scope.to_sym)
-    end
-
-    def add_scope(method, *args, &block)
-      method = "#{method}_without_default".to_sym
-      merge_search one_class.send(method, *args, &block), self.args, options
-    end
-
-    def merge_search(search, args, options)
-      search.args.each { |arg| args << arg }
-
-      search.options.keys.each do |key|
-        if HashOptions.include?(key)
-          options[key] ||= {}
-          options[key].merge! search.options[key]
-        elsif ArrayOptions.include?(key)
-          options[key] ||= []
-          options[key] += search.options[key]
-          options[key].uniq!
-        else
-          options[key] = search.options[key]
-        end
-      end
-    end
-
-    def scoped_count
-      return self.total_entries if(@options[:ids_only] || @options[:only])
-
-      @options[:ids_only] = true
-      results_count = self.total_entries
-      @options[:ids_only] = false
-      @populated = false
-
-      results_count
-    end
-
-    def crc_attribute
-      Riddle.loaded_version.to_i < 2 ? 'class_crc' : 'sphinx_internal_class'
-    end
   end
 end
+
+require 'thinking_sphinx/search/batch_inquirer'
+require 'thinking_sphinx/search/context'
+require 'thinking_sphinx/search/glaze'
+require 'thinking_sphinx/search/merger'
+require 'thinking_sphinx/search/query'
+require 'thinking_sphinx/search/stale_ids_exception'