thinking-sphinx 1.2.13 → 6.0.0

data/lib/thinking_sphinx/facet_search.rb

@@ -1,134 +1,141 @@
-module ThinkingSphinx
-  class FacetSearch < Hash
-    attr_accessor :args, :options
-    
-    def initialize(*args)
-      @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_crc" 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
-      facet_names.each do |name|
-        search_options = facet_search_options.merge(:group_by => name)
-        add_from_results name, ThinkingSphinx.search(
-          *(args + [search_options])
-        )
-      end
-    end
-    
-    def facet_search_options
-      config = ThinkingSphinx::Configuration.instance
-      max    = config.configuration.searchd.max_matches || 1000
-      
-      options.merge(
-        :group_function => :attr,
-        :limit          => max,
-        :max_matches    => max,
-        :page           => 1
-      )
-    end
-    
-    def facet_classes
-      (
-        options[:classes] || ThinkingSphinx.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
-      }
+# frozen_string_literal: true
+
+class ThinkingSphinx::FacetSearch
+  include Enumerable
+
+  attr_reader   :options
+  attr_accessor :query
+
+  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|
+      batch.searches << ThinkingSphinx::Search.new(query, options_for(facet))
     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
-          }
-        }
-      }
+
+    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
-    
-    def add_from_results(facet, results)
-      name = ThinkingSphinx::Facet.name_for(facet)
-      
-      self[name]  ||= {}
-      
-      return if results.empty?
-      
-      facet = facet_from_object(results.first, facet) if facet.is_a?(String)
-      
-      results.each_with_groupby_and_count { |result, group, count|
-        facet_value = facet.value(result, group)
-        
-        self[name][facet_value] ||= 0
-        self[name][facet_value]  += count
+
+    @hash[:class] = @hash[:sphinx_internal_class]
+
+    @populated = true
+  end
+
+  def populated?
+    @populated
+  end
+
+  def to_hash
+    populate
+
+    @hash
+  end
+
+  private
+
+  def configuration
+    ThinkingSphinx::Configuration.instance
+  end
+
+  def facets
+    @facets ||= properties.group_by(&:name).collect { |name, matches|
+      ThinkingSphinx::Facet.new name, matches
+    }
+  end
+
+  def properties
+    properties = indices.collect(&:facets).flatten
+    if options[:facets].present?
+      properties = properties.select { |property|
+        options[:facets].include? property.name.to_sym
       }
     end
-    
-    def underlying_value(key, value)
-      case value
-      when Array
-        value.collect { |item| underlying_value(key, item) }
-      when String
-        value.to_crc32
-      else
-        value
+    properties
+  end
+
+  def index_names_for(*facets)
+    facet_names(
+      indices.select do |index|
+        facets.all? { |facet| facet_names(index.facets).include?(facet.name) }
       end
+    )
+  end
+
+  def facet_names(facets)
+    facets.collect(&:name)
+  end
+
+  def indices
+    @indices ||= configuration.index_set_class.new(
+      options.slice(:classes, :indices)
+    )
+  end
+
+  def max_matches
+    configuration.settings['max_matches'] || 1000
+  end
+
+  def limit
+    limit = options[:limit] || options[:per_page] || max_matches
+  end
+
+  def options_for(facet)
+    options.merge(
+      :select      => [(options[:select] || '*'),
+        "groupby() AS sphinx_internal_group",
+        "id AS sphinx_document_id, count(DISTINCT sphinx_document_id) AS sphinx_internal_count"
+      ].join(', '),
+      :group_by    => facet.name,
+      :indices     => index_names_for(facet),
+      :max_matches => max_matches,
+      :limit       => limit
+    )
+  end
+
+  class Filter
+    def initialize(facets, hash)
+      @facets, @hash = facets, hash
     end
-    
-    def facet_from_object(object, name)
-      object.sphinx_facets.detect { |facet| facet.attribute_name == name }
+
+    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
   end
 end

data/lib/thinking_sphinx/float_formatter.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::FloatFormatter
+  PATTERN = /(\d+)e\-(\d+)$/
+
+  def initialize(float)
+    @float = float
+  end
+
+  def fixed
+    return float.to_s unless exponent_present?
+
+    ("%0.#{decimal_places}f" % float).gsub(/0+$/, '')
+  end
+
+  private
+
+  attr_reader :float
+
+  def exponent_decimal_places
+    float.to_s[PATTERN, 1].length
+  end
+
+  def exponent_factor
+    float.to_s[PATTERN, 2].to_i
+  end
+
+  def exponent_present?
+    float.to_s['e']
+  end
+
+  def decimal_places
+    exponent_factor + exponent_decimal_places
+  end
+end

data/lib/thinking_sphinx/frameworks/plain.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Frameworks::Plain
+  attr_accessor :environment, :root
+
+  def initialize
+    @environment = 'production'
+    @root        = Dir.pwd
+  end
+end

data/lib/thinking_sphinx/frameworks/rails.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Frameworks::Rails
+  def environment
+    Rails.env
+  end
+
+  def root
+    Rails.root
+  end
+end

data/lib/thinking_sphinx/frameworks.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx::Frameworks
+  def self.current
+    defined?(::Rails) ? ThinkingSphinx::Frameworks::Rails.new :
+      ThinkingSphinx::Frameworks::Plain.new
+  end
+end
+
+require 'thinking_sphinx/frameworks/plain'
+require 'thinking_sphinx/frameworks/rails'

data/lib/thinking_sphinx/guard/file.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Guard::File
+  attr_reader :name
+
+  def initialize(name)
+    @name = name
+  end
+
+  def lock
+    FileUtils.touch path
+  end
+
+  def locked?
+    File.exist? path
+  end
+
+  def path
+    @path ||= File.join(
+      ThinkingSphinx::Configuration.instance.indices_location,
+      "ts-#{name}.tmp"
+    )
+  end
+
+  def unlock
+    FileUtils.rm(path) if locked?
+  end
+end

data/lib/thinking_sphinx/guard/files.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Guard::Files
+  def self.call(names, &block)
+    new(names).call(&block)
+  end
+
+  def initialize(names)
+    @names = names
+  end
+
+  def call(&block)
+    return if unlocked.empty?
+
+    unlocked.each &:lock
+    block.call unlocked.collect(&:name)
+  rescue => error
+    raise error
+  ensure
+    unlocked.each &:unlock
+  end
+
+  private
+
+  attr_reader :names
+
+  def log_lock(file)
+    ThinkingSphinx::Logger.log :guard,
+      "Guard file for index #{file.name} exists, not indexing: #{file.path}."
+  end
+
+  def unlocked
+    @unlocked ||= names.collect { |name|
+      ThinkingSphinx::Guard::File.new name
+    }.reject { |file|
+      log_lock file if file.locked?
+      file.locked?
+    }
+  end
+end

data/lib/thinking_sphinx/guard/none.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Guard::None
+  def self.call(names, &block)
+    block.call names
+  end
+end

data/lib/thinking_sphinx/guard.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx::Guard
+  #
+end
+
+require 'thinking_sphinx/guard/file'
+require 'thinking_sphinx/guard/files'
+require 'thinking_sphinx/guard/none'

data/lib/thinking_sphinx/hooks/guard_presence.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Hooks::GuardPresence
+  def self.call(configuration = nil, stream = STDERR)
+    new(configuration, stream).call
+  end
+
+  def initialize(configuration = nil, stream = STDERR)
+    @configuration = configuration || ThinkingSphinx::Configuration.instance
+    @stream        = stream
+  end
+
+  def call
+    return if files.empty?
+
+    stream.puts "WARNING: The following indexing guard files exist:"
+    files.each do |file|
+      stream.puts " * #{file}"
+    end
+    stream.puts <<-TXT
+These files indicate indexing is already happening. If that is not the case,
+these files should be deleted to ensure all indices can be processed.
+
+    TXT
+  end
+
+  private
+
+  attr_reader :configuration, :stream
+
+  def files
+    @files ||= Dir["#{configuration.indices_location}/ts-*.tmp"]
+  end
+end

data/lib/thinking_sphinx/index.rb

@@ -1,99 +1,57 @@
-require 'thinking_sphinx/index/builder'
-require 'thinking_sphinx/index/faux_column'
+# frozen_string_literal: true
 
-module ThinkingSphinx
-  # The Index class is a ruby representation of a Sphinx source (not a Sphinx
-  # index - yes, I know it's a little confusing. You'll manage). This is
-  # another 'internal' Thinking Sphinx class - if you're using it directly,
-  # you either know what you're doing, or messing with things beyond your ken.
-  # Enjoy.
-  # 
-  class Index
-    attr_accessor :model, :sources, :delta_object
-    
-    # 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)
-      @model        = model
-      @sources      = []
-      @options      = {}
-      @delta_object = nil
-    end
-    
-    def fields
-      @sources.collect { |source| source.fields }.flatten
-    end
-    
-    def attributes
-      @sources.collect { |source| source.attributes }.flatten
-    end
-    
-    def name
-      self.class.name_for @model
-    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 = ThinkingSphinx::Configuration.instance.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
-    
-    private
-    
-    def adapter
-      @adapter ||= @model.sphinx_database_adapter
+class ThinkingSphinx::Index
+  attr_reader :reference, :options, :block
+
+  def self.define(reference, options = {}, &block)
+    new(reference, options, &block).indices.each do |index|
+      ThinkingSphinx::Configuration.instance.indices << index
     end
-    
-    def utf8?
-      options[:charset_type] == "utf-8"
+  end
+
+  def initialize(reference, options, &block)
+    defaults = ThinkingSphinx::Configuration.instance.
+      settings['index_options'] || {}
+    defaults.symbolize_keys!
+
+    @reference, @options, @block = reference, defaults.merge(options), block
+  end
+
+  def indices
+    options[:delta] ? delta_indices : [single_index]
+  end
+
+  private
+
+  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
-    
-    # Does all the magic with the block provided to the base #initialize.
-    # Creates a new class subclassed from Builder, and evaluates the block
-    # on it, then pulls all relevant settings - fields, attributes, conditions,
-    # properties - into the new index.
-    # 
-    def initialize_from_builder(&block)
-      #
+  end
+
+  def single_index
+    index_class.new(reference, options).tap do |index|
+      index.definition_block = block
     end
-    
-    def sql_query_pre_for_delta
-      [""]
+  end
+
+  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 processor
+    @processor ||= ThinkingSphinx::Deltas.processor_for options.delete(:delta)
+  end
 end