thinking-sphinx 2.0.5 → 2.0.6

data/lib/thinking_sphinx/core/string.rb

@@ -1,15 +0,0 @@
-require 'zlib'
-
-module ThinkingSphinx
-  module Core
-    module String
-      def to_crc32
-        Zlib.crc32 self
-      end
-    end
-  end
-end
-
-class String
-  include ThinkingSphinx::Core::String
-end

data/lib/thinking_sphinx/deltas.rb

@@ -1,28 +0,0 @@
-require 'thinking_sphinx/deltas/default_delta'
-
-module ThinkingSphinx
-  module Deltas
-    def self.parse(index)
-      delta_option = index.local_options.delete(:delta)
-      case delta_option
-      when TrueClass, :default
-        DefaultDelta.new index, index.local_options
-      when :delayed
-        DelayedDelta.new index, index.local_options
-      when :datetime
-        DatetimeDelta.new index, index.local_options
-      when FalseClass, nil
-        nil
-      else
-        if delta_option.is_a?(String)
-          delta_option = Kernel.const_get(delta_option)
-        end
-        if delta_option.ancestors.include?(ThinkingSphinx::Deltas::DefaultDelta)
-          delta_option.new index, index.local_options
-        else
-          raise "Unknown delta type"
-        end
-      end
-    end
-  end
-end

data/lib/thinking_sphinx/deltas/default_delta.rb

@@ -1,62 +0,0 @@
-module ThinkingSphinx
-  module Deltas
-    class DefaultDelta
-      attr_accessor :column
-      
-      def initialize(index, options)
-        @index  = index
-        @column = options.delete(:delta_column) || :delta
-      end
-      
-      def index(model, instance = nil)
-        return true unless ThinkingSphinx.updates_enabled? &&
-          ThinkingSphinx.deltas_enabled?
-        return true if instance && !toggled(instance)
-        
-        update_delta_indexes model
-        delete_from_core     model, instance if instance
-        
-        true
-      end
-      
-      def toggle(instance)
-        instance.send "#{@column}=", true
-      end
-
-      def toggled(instance)
-        instance.send "#{@column}"
-      end
-
-      def reset_query(model)
-        "UPDATE #{model.quoted_table_name} SET " +
-        "#{model.connection.quote_column_name(@column.to_s)} = #{adapter.boolean(false)} " +
-        "WHERE #{model.connection.quote_column_name(@column.to_s)} = #{adapter.boolean(true)}"
-      end
-      
-      def clause(model, toggled)
-        "#{model.quoted_table_name}.#{model.connection.quote_column_name(@column.to_s)}" +
-        " = #{adapter.boolean(toggled)}"
-      end
-      
-      private
-      
-      def update_delta_indexes(model)
-        config = ThinkingSphinx::Configuration.instance
-        rotate = ThinkingSphinx.sphinx_running? ? "--rotate" : ""
-        
-        output = `#{config.bin_path}#{config.indexer_binary_name} --config "#{config.config_file}" #{rotate} #{model.delta_index_names.join(' ')}`
-        puts(output) unless ThinkingSphinx.suppress_delta_output?
-      end
-      
-      def delete_from_core(model, instance)
-        model.core_index_names.each do |index_name|
-          model.delete_in_index index_name, instance.sphinx_document_id
-        end
-      end
-      
-      def adapter
-        @adapter = @index.model.sphinx_database_adapter
-      end
-    end
-  end
-end

data/lib/thinking_sphinx/deploy/capistrano.rb

@@ -1,101 +0,0 @@
-Capistrano::Configuration.instance(:must_exist).load do
-  namespace :thinking_sphinx do
-    namespace :install do
-      desc <<-DESC
-        Install Sphinx by source
-
-        If Postgres is available, Sphinx will use it.
-
-        If the variable :thinking_sphinx_configure_args is set, it will
-        be passed to the Sphinx configure script. You can use this to
-        install Sphinx in a non-standard location:
-
-          set :thinking_sphinx_configure_args, "--prefix=$HOME/software"
-DESC
-
-      task :sphinx do
-        with_postgres = false
-        begin
-          run "which pg_config" do |channel, stream, data|
-            with_postgres = !(data.nil? || data == "")
-          end
-        rescue Capistrano::CommandError => e
-          puts "Continuing despite error: #{e.message}"
-        end
-
-        args = []
-        if with_postgres
-          run "pg_config --pkgincludedir" do |channel, stream, data|
-            args << "--with-pgsql=#{data}"
-          end
-        end
-        args << fetch(:thinking_sphinx_configure_args, '')
-
-        commands = <<-CMD
-        wget -q http://sphinxsearch.com/downloads/sphinx-0.9.9.tar.gz >> sphinx.log
-        tar xzvf sphinx-0.9.9.tar.gz
-        cd sphinx-0.9.9
-        ./configure #{args.join(" ")}
-        make
-        #{try_sudo} make install
-        rm -rf sphinx-0.9.9 sphinx-0.9.9.tar.gz
-        CMD
-        run commands.split(/\n\s+/).join(" && ")
-      end
-
-      desc "Install Thinking Sphinx as a gem"
-      task :ts do
-        run "#{try_sudo} gem install thinking-sphinx"
-      end
-    end
-
-    desc "Generate the Sphinx configuration file"
-    task :configure do
-      rake "thinking_sphinx:configure"
-    end
-
-    desc "Index data"
-    task :index do
-      rake "thinking_sphinx:index"
-    end
-
-    desc "Start the Sphinx daemon"
-    task :start do
-      configure
-      rake "thinking_sphinx:start"
-    end
-
-    desc "Stop the Sphinx daemon"
-    task :stop do
-      configure
-      rake "thinking_sphinx:stop"
-    end
-
-    desc "Stop and then start the Sphinx daemon"
-    task :restart do
-      stop
-      start
-    end
-
-    desc "Stop, re-index and then start the Sphinx daemon"
-    task :rebuild do
-      stop
-      index
-      start
-    end
-
-    desc "Add the shared folder for sphinx files"
-    task :shared_sphinx_folder, :roles => :web do
-      rails_env = fetch(:rails_env, "production")
-      run "mkdir -p #{shared_path}/sphinx/#{rails_env}"
-    end
-
-    def rake(*tasks)
-      rails_env = fetch(:rails_env, "production")
-      rake = fetch(:rake, "rake")
-      tasks.each do |t|
-        run "if [ -d #{release_path} ]; then cd #{release_path}; else cd #{current_path}; fi; #{rake} RAILS_ENV=#{rails_env} #{t}"
-      end
-    end
-  end
-end

data/lib/thinking_sphinx/excerpter.rb

@@ -1,23 +0,0 @@
-module ThinkingSphinx
-  class Excerpter
-    CoreMethods = %w( kind_of? object_id respond_to? respond_to_missing? should
-      should_not stub! )
-    # Hide most methods, to allow them to be passed through to the instance.
-    instance_methods.select { |method|
-      method.to_s[/^__/].nil? && !CoreMethods.include?(method.to_s)
-    }.each { |method|
-      undef_method method
-    }
-    
-    def initialize(search, instance)
-      @search   = search
-      @instance = instance
-    end
-    
-    def method_missing(method, *args, &block)
-      string = @instance.send(method, *args, &block).to_s
-      
-      @search.excerpt_for(string, @instance.class)
-    end
-  end
-end

data/lib/thinking_sphinx/facet.rb

@@ -1,128 +0,0 @@
-module ThinkingSphinx
-  class Facet
-    attr_reader :property, :value_source
-    
-    def initialize(property, value_source = nil)
-      @property     = property
-      @value_source = value_source
-      
-      if property.columns.length != 1
-        raise "Can't translate Facets on multiple-column field or attribute"
-      end
-    end
-
-    def self.name_for(facet)
-      case facet
-      when Facet
-        facet.name
-      when String, Symbol
-        return :class if facet.to_s == 'sphinx_internal_class'
-        facet.to_s.gsub(/(_facet|_crc)$/,'').to_sym
-      end
-    end
-    
-    def self.attribute_name_for(name)
-      name.to_s == 'class' ? 'class_crc' : "#{name}_facet"
-    end
-    
-    def self.attribute_name_from_value(name, value)
-      case value
-      when String
-        attribute_name_for(name)
-      when Array
-        if value.all? { |val| val.is_a?(Integer) }
-          name
-        else
-          attribute_name_for(name)
-        end
-      else
-        name
-      end
-    end
-    
-    def self.translate?(property)
-      return true if property.is_a?(Field)
-      
-      case property.type
-      when :string
-        true
-      when :integer, :boolean, :datetime, :float
-        false
-      when :multi
-        !property.all_ints?
-      end
-    end
-    
-    def name
-      property.unique_name
-    end
-    
-    def attribute_name
-      if translate?
-        Facet.attribute_name_for(@property.unique_name)
-      else
-        @property.unique_name.to_s
-      end
-    end
-    
-    def translate?
-      Facet.translate?(@property)
-    end
-    
-    def type
-      @property.is_a?(Field) ? :string : @property.type
-    end
-    
-    def float?
-      @property.type == :float
-    end
-    
-    def value(object, attribute_hash)
-      attribute_value = attribute_hash['@groupby']
-      return translate(object, attribute_value) if translate? || float?
-      
-      case @property.type
-      when :datetime
-        Time.at(attribute_value)
-      when :boolean
-        attribute_value > 0
-      else
-        attribute_value
-      end
-    end
-    
-    def to_s
-      name
-    end
-    
-    private
-    
-    def translate(object, attribute_value)
-      objects = source_objects(object)
-      return if objects.blank?
-
-      method = value_source || column.__name
-      object = objects.one? ? objects.first : objects.detect { |item|
-        result = item.send(method)
-        result && result.to_crc32 == attribute_value
-      }
-
-      object.try(method)
-    end
-    
-    def source_objects(object)
-      column.__stack.each { |method|
-        object = Array(object).collect { |item|
-          item.send(method)
-        }.flatten.compact
-        
-        return nil if object.empty?
-      }
-      Array(object)
-    end
-    
-    def column
-      @property.columns.first
-    end
-  end
-end

data/lib/thinking_sphinx/facet_search.rb

@@ -1,170 +0,0 @@
-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)
-      )
-    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
-      }
-    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 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
-      }
-    end
-    
-    def class_facet
-      Riddle.loaded_version.to_i < 2 ? 'class_crc' : 'sphinx_internal_class'
-    end
-  end
-end