thinking-sphinx 2.1.0 → 3.0.0.pre

data/lib/thinking_sphinx/facet_search.rb

@@ -1,170 +1,103 @@
-module ThinkingSphinx
-  class FacetSearch < Hash
-    attr_accessor :args, :options
-    
-    def initialize(*args)
-      ThinkingSphinx.context.define_indexes
-      
-      @options      = args.extract_options!
-      @args         = args
-      
-      set_default_options
-      
-      populate
-    end
-    
-    def for(hash = {})
-      for_options = {:with => {}}.merge(options)
-      
-      hash.each do |key, value|
-        attrib = ThinkingSphinx::Facet.attribute_name_from_value(key, value)
-        for_options[:with][attrib] = underlying_value key, value
-      end
-      
-      ThinkingSphinx.search *(args + [for_options])
-    end
-    
-    def facet_names
-      @facet_names ||= begin
-        names = options[:all_facets] ?
-          facet_names_for_all_classes : facet_names_common_to_all_classes
-        
-        names.delete class_facet unless options[:class_facet]
-        names
-      end
-    end
-    
-    private
-    
-    def set_default_options
-      options[:all_facets]  ||= false
-      if options[:class_facet].nil?
-        options[:class_facet] = ((options[:classes] || []).length != 1)
-      end
-    end
-    
-    def populate
-      return if facet_names.empty?
-      
-      ThinkingSphinx::Search.bundle_searches(facet_names) { |sphinx, name|
-        sphinx.search *(args + [facet_search_options(name)])
-      }.each_with_index { |search, index|
-        add_from_results facet_names[index], search
-      }
-    end
-    
-    def facet_search_options(facet_name)
-      options.merge(
-        :group_function => :attr,
-        :limit          => max_matches,
-        :max_matches    => max_matches,
-        :page           => 1,
-        :group_by       => facet_name,
-        :ids_only       => !translate?(facet_name)
+class ThinkingSphinx::FacetSearch
+  include Enumerable
+
+  attr_reader :query, :options
+
+  def initialize(query = nil, options = {})
+    query, options   = nil, query if query.is_a?(Hash)
+    @query, @options = query, options
+    @hash             = {}
+  end
+
+  def [](key)
+    populate
+
+    @hash[key]
+  end
+
+  def each(&block)
+    populate
+
+    @hash.each(&block)
+  end
+
+  def for(facet_values)
+    filter_facets = facet_values.keys.collect { |key|
+      facets.detect { |facet| facet.name == key.to_s }
+    }
+
+    ThinkingSphinx::Search.new query, options.merge(
+      :indices => index_names_for(*filter_facets)
+    ).merge(Filter.new(facets, facet_values).to_hash)
+  end
+
+  def populate
+    return if @populated
+
+    batch = ThinkingSphinx::BatchedSearch.new
+    facets.each do |facet|
+      search = ThinkingSphinx::Search.new query, options.merge(
+        :select   => '*, @groupby, @count',
+        :group_by => facet.name,
+        :indices  => index_names_for(facet)
       )
-    end
-    
-    def facet_classes
-      (
-        options[:classes] || ThinkingSphinx.context.indexed_models.collect { |model|
-          model.constantize
-        }
-      ).select { |klass| klass.sphinx_facets.any? }
-    end
-    
-    def all_facets
-      facet_classes.collect { |klass|
-        klass.sphinx_facets
-      }.flatten.select { |facet|
-        options[:facets].blank? || Array(options[:facets]).include?(facet.name)
-      }
-    end
-    
-    def facet_names_for_all_classes
-      all_facets.group_by { |facet|
-        facet.name
-      }.collect { |name, facets|
-        if facets.collect { |facet| facet.type }.uniq.length > 1
-          raise "Facet #{name} exists in more than one model with different types"
-        end
-        facets.first.attribute_name
+      batch.searches << search
+    end
+
+    batch.populate ThinkingSphinx::Middlewares::RAW_ONLY
+
+    facets.each_with_index do |facet, index|
+      @hash[facet.name.to_sym] = facet.results_from batch.searches[index].raw
+    end
+
+    @hash[:class] = @hash[:sphinx_internal_class]
+
+    @populated = true
+  end
+
+  def to_hash
+    populate
+
+    @hash
+  end
+
+  private
+
+  def facets
+    @facets ||= begin
+      properties = indices.collect(&:facets).flatten
+      properties.group_by(&:name).collect { |name, matches|
+        ThinkingSphinx::Facet.new name, matches
       }
     end
-    
-    def facet_names_common_to_all_classes
-      facet_names_for_all_classes.select { |name|
-        facet_classes.all? { |klass|
-          klass.sphinx_facets.detect { |facet|
-            facet.attribute_name == name
-          }
-        }
+  end
+
+  def index_names_for(*facets)
+    indices.select { |index|
+      facet_names = index.facets.collect(&:name)
+      facets.all? { |facet|
+        facet_names.include?(facet.name)
       }
-    end
-    
-    def translate?(name)
-      facet = facet_from_name(name)
-      facet.translate? || facet.float?
-    end
-    
-    def config
-      ThinkingSphinx::Configuration.instance
-    end
-    
-    def max_matches
-      @max_matches ||= config.configuration.searchd.max_matches || 1000
-    end
-    
-    # example: facet = country_facet; name = :country
-    def add_from_results(facet, search)
-      name  = ThinkingSphinx::Facet.name_for(facet)
-      facet = facet_from_name(facet)
-      
-      self[name]  ||= {}
-      
-      return if search.empty?
-      
-      search.each_with_match do |result, match|
-        facet_value = facet.value(result, match[:attributes])
-        
-        self[name][facet_value] ||= 0
-        self[name][facet_value]  += match[:attributes]["@count"]
-      end
-    end
-    
-    def underlying_value(key, value)
-      case value
-      when Array
-        value.collect { |item| underlying_value(key, item) }
-      when String
-        value.to_crc32
-      else
-        value
-      end
-    end
-    
-    def facet_from_object(object, name)
-      facet = nil
-      klass = object.class
-      
-      while klass != ::ActiveRecord::Base && facet.nil?
-        facet = klass.sphinx_facets.detect { |facet|
-          facet.attribute_name == name
-        }
-        klass = klass.superclass
-      end
-      
-      facet
-    end
-    
-    def facet_from_name(name)
-      name = ThinkingSphinx::Facet.name_for(name)
-      all_facets.detect { |facet|
-        facet.name == name
+    }.collect &:name
+  end
+
+  def indices
+    @indices ||= ThinkingSphinx::IndexSet.new options[:classes],
+      options[:indices]
+  end
+
+  class Filter
+    def initialize(facets, hash)
+      @facets, @hash = facets, hash
+    end
+
+    def to_hash
+      @hash.keys.inject({}) { |options, key|
+        type = @facets.detect { |facet| facet.name == key.to_s }.filter_type
+        options[type] ||= {}
+        options[type][key] = @hash[key]
+        options
       }
     end
-    
-    def class_facet
-      Riddle.loaded_version.to_i < 2 ? 'class_crc' : 'sphinx_internal_class'
-    end
   end
 end

data/lib/thinking_sphinx/index.rb

@@ -1,159 +1,55 @@
-require 'thinking_sphinx/index/builder'
-require 'thinking_sphinx/index/faux_column'
+class ThinkingSphinx::Index
+  attr_reader :reference, :options, :block
 
-module ThinkingSphinx
-  class Index
-    attr_accessor :name, :model, :sources, :delta_object, :additional_indices
-
-    # Create a new index instance by passing in the model it is tied to, and
-    # a block to build it with (optional but recommended). For documentation
-    # on the syntax for inside the block, the Builder class is what you want.
-    #
-    # Quick Example:
-    #
-    #   Index.new(User) do
-    #     indexes login, email
-    #
-    #     has created_at
-    #
-    #     set_property :delta => true
-    #   end
-    #
-    def initialize(model, &block)
-      @name         = self.class.name_for model
-      @model        = model
-      @sources      = []
-      @options      = {}
-      @delta_object = nil
-      @additional_indices = []
-    end
-
-    def fields
-      @sources.collect { |source| source.fields }.flatten
-    end
-
-    def attributes
-      @sources.collect { |source| source.attributes }.flatten
-    end
-
-    def core_name
-      "#{name}_core"
-    end
-
-    def delta_name
-      "#{name}_delta"
-    end
-
-    def all_names
-      names  = [core_name]
-      names << delta_name if delta?
-
-      names
-    end
-
-    def self.name_for(model)
-      model.name.underscore.tr(':/\\', '_')
-    end
-
-    def prefix_fields
-      fields.select { |field| field.prefixes }
-    end
-
-    def infix_fields
-      fields.select { |field| field.infixes }
-    end
-
-    def local_options
-      @options
-    end
-
-    def options
-      all_index_options = config.index_options.clone
-      @options.keys.select { |key|
-        ThinkingSphinx::Configuration::IndexOptions.include?(key.to_s) ||
-        ThinkingSphinx::Configuration::CustomOptions.include?(key.to_s)
-      }.each { |key| all_index_options[key.to_sym] = @options[key] }
-      all_index_options
-    end
-
-    def delta?
-      !@delta_object.nil?
-    end
-
-    def to_riddle(offset)
-      indexes = [to_riddle_for_core(offset)]
-      indexes << to_riddle_for_delta(offset) if delta?
-      indexes << to_riddle_for_distributed
-    end
-
-    private
-
-    def adapter
-      @adapter ||= @model.sphinx_database_adapter
+  def self.define(reference, options = {}, &block)
+    new(reference, options, &block).indices.each do |index|
+      ThinkingSphinx::Configuration.instance.indices << index
     end
+  end
 
-    def utf8?
-      options[:charset_type] == "utf-8"
-    end
-
-    def sql_query_pre_for_delta
-      [""]
-    end
-
-    def config
-      @config ||= ThinkingSphinx::Configuration.instance
-    end
-
-    def to_riddle_for_core(offset)
-      index = Riddle::Configuration::Index.new core_name
-      index.path = File.join config.searchd_file_path, index.name
-
-      set_configuration_options_for_indexes index
-      set_field_settings_for_indexes        index
-
-      sources.each_with_index do |source, i|
-        index.sources << source.to_riddle_for_core(offset, i)
-      end
+  def initialize(reference, options, &block)
+    @reference, @options, @block = reference, options, block
+  end
 
-      index
+  def indices
+    if options[:delta]
+      delta_indices
+    else
+      [single_index]
     end
+  end
 
-    def to_riddle_for_delta(offset)
-      index = Riddle::Configuration::Index.new delta_name
-      index.parent = core_name
-      index.path = File.join config.searchd_file_path, index.name
-
-      sources.each_with_index do |source, i|
-        index.sources << source.to_riddle_for_delta(offset, i)
-      end
+  private
 
-      index
+  def index_class
+    case options[:with]
+    when :active_record
+      ThinkingSphinx::ActiveRecord::Index
+    when :real_time
+      ThinkingSphinx::RealTime::Index
+    else
+      raise "Unknown index type: #{options[:with]}"
     end
+  end
 
-    def to_riddle_for_distributed
-      index = Riddle::Configuration::DistributedIndex.new name
-      index.local_indices << core_name
-      index.local_indices += additional_indices
-      index.local_indices.unshift delta_name if delta?
-      index
+  def single_index
+    index_class.new(reference, options).tap do |index|
+      index.definition_block = block
     end
+  end
 
-    def set_configuration_options_for_indexes(index)
-      config.index_options.each do |key, value|
-        method = "#{key}=".to_sym
-        index.send(method, value) if index.respond_to?(method)
-      end
-
-      options.each do |key, value|
-        index.send("#{key}=".to_sym, value) if ThinkingSphinx::Configuration::IndexOptions.include?(key.to_s) && !value.nil?
+  def delta_indices
+    [false, true].collect do |delta|
+      index_class.new(
+        reference,
+        options.merge(:delta? => delta, :delta_processor => processor)
+      ).tap do |index|
+        index.definition_block = block
       end
     end
+  end
 
-    def set_field_settings_for_indexes(index)
-      field_names = lambda { |field| field.unique_name.to_s }
-
-      index.prefix_field_names += prefix_fields.collect(&field_names)
-      index.infix_field_names  += infix_fields.collect(&field_names)
-    end
+  def processor
+    @processor ||= ThinkingSphinx::Deltas.processor_for options.delete(:delta)
   end
 end