thinking-sphinx 3.0.3 → 3.0.4

data/lib/thinking_sphinx/middlewares/geographer.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/module/delegation'
+
 class ThinkingSphinx::Middlewares::Geographer <
   ThinkingSphinx::Middlewares::Middleware
 
@@ -9,6 +11,8 @@ class ThinkingSphinx::Middlewares::Geographer <
     app.call contexts
   end
 
+  private
+
   class Inner
     def initialize(context)
       @context = context
@@ -25,29 +29,58 @@ class ThinkingSphinx::Middlewares::Geographer <
 
     attr_reader :context
 
-    def attribute_names
-      @attribute_names ||= context[:indices].collect(&:unique_attribute_names).
-        flatten.uniq
-    end
+    delegate :geo, :latitude, :longitude, :to => :geolocation_attributes
 
-    def geo
-      context.search.options[:geo]
+    def geolocation_attributes
+      @geolocation_attributes ||= GeolocationAttributes.new(context)
     end
 
     def geodist_clause
-      "GEODIST(#{geo.first}, #{geo.last}, #{latitude_attribute}, #{longitude_attribute}) AS geodist"
+      "GEODIST(#{geo.first}, #{geo.last}, #{latitude}, #{longitude}) AS geodist"
     end
 
-    def latitude_attribute
-      context.search.options[:latitude_attr]                         ||
-      attribute_names.detect { |attribute| attribute == 'lat' }      ||
-      attribute_names.detect { |attribute| attribute == 'latitude' } || 'lat'
-    end
+    class GeolocationAttributes
+      def initialize(context)
+        self.context = context
+        self.latitude = latitude_attr if latitude_attr
+        self.longitude = longitude_attr if longitude_attr
+      end
+
+      def geo
+        search_context_options[:geo]
+      end
+      attr_accessor :latitude, :longitude
+
+      def latitude
+        @latitude ||= names.detect { |name| %w[lat latitude].include?(name) } || 'lat'
+      end
+
+      def longitude
+        @longitude ||= names.detect { |name| %w[lng longitude].include?(name) } || 'lng'
+      end
+
+      private
+      attr_accessor :context
+
+      def latitude_attr
+        @latitude_attr ||= search_context_options[:latitude_attr]
+      end
+
+      def longitude_attr
+        @longitude_attr ||= search_context_options[:longitude_attr]
+      end
+
+      def indices
+        context[:indices]
+      end
+
+      def names
+        @names ||= indices.collect(&:unique_attribute_names).flatten.uniq
+      end
 
-    def longitude_attribute
-      context.search.options[:longitude_attr]                         ||
-      attribute_names.detect { |attribute| attribute == 'lng' }       ||
-      attribute_names.detect { |attribute| attribute == 'longitude' } || 'lng'
+      def search_context_options
+        @search_context_options ||= context.search.options
+      end
     end
   end
 end

data/lib/thinking_sphinx/middlewares/sphinxql.rb

@@ -37,11 +37,26 @@ class ThinkingSphinx::Middlewares::SphinxQL <
       classes + descendants
     end
 
-    def class_condition
-      class_names = classes_and_descendants.collect(&:name).collect { |name|
-        name[/:/] ? "\"#{name}\"" : name
+    def classes_and_descendants_names
+      classes_and_descendants.collect do |klass|
+        name = klass.name
+        name = %Q{"#{name}"} if name[/:/]
+        name
+      end
+    end
+
+    def classes_with_inheritance_column
+      classes.select { |klass|
+        klass.column_names.include?(klass.inheritance_column)
       }
-      '(' + class_names.join('|') + ')'
+    end
+
+    def class_condition
+      "(#{classes_and_descendants_names.join('|')})"
+    end
+
+    def constantize_inheritance_column(klass)
+      klass.connection.select_values(inheritance_column_select(klass)).compact.each(&:constantize)
     end
 
     def descendants
@@ -49,51 +64,45 @@ class ThinkingSphinx::Middlewares::SphinxQL <
     end
 
     def descendants_from_tables
-      classes.select { |klass|
-        klass.column_names.include?(klass.inheritance_column)
-      }.collect { |klass|
-        klass.connection.select_values(<<-SQL).compact.each(&:constantize)
-  SELECT DISTINCT #{klass.inheritance_column}
-  FROM #{klass.table_name}
-        SQL
+      classes_with_inheritance_column.collect do |klass|
+        constantize_inheritance_column(klass)
         klass.descendants
-      }.flatten
+      end.flatten
+    end
+
+    def inheritance_column_select(klass)
+      <<-SQL
+SELECT DISTINCT #{klass.inheritance_column}
+FROM #{klass.table_name}
+SQL
     end
 
     def exclusive_filters
       @exclusive_filters ||= (options[:without] || {}).tap do |without|
-        if options[:without_ids].present? && options[:without_ids].any?
-          without[:sphinx_internal_id] = options[:without_ids]
-        end
+        without[:sphinx_internal_id] = options[:without_ids] if options[:without_ids].present?
       end
     end
 
     def extended_query
       conditions = options[:conditions] || {}
       conditions[:sphinx_internal_class_name] = class_condition if classes.any?
-      @extended_query ||= begin
-        ThinkingSphinx::Search::Query.new(context.search.query, conditions,
-          options[:star]).to_s
-      end
+      @extended_query ||= ThinkingSphinx::Search::Query.new(
+        context.search.query, conditions, options[:star]
+      ).to_s
     end
 
     def group_attribute
-      options[:group_by] ? options[:group_by].to_s : nil
+      options[:group_by].to_s if options[:group_by]
     end
 
     def group_order_clause
-      case options[:order_group_by]
-      when Symbol
-        "#{options[:order_group_by]} ASC"
-      else
-        options[:order_group_by]
-      end
+      group_by = options[:order_group_by]
+      group_by = "#{group_by} ASC" if group_by.is_a? Symbol
+      group_by
     end
 
     def inclusive_filters
-      @inclusive_filters ||= (options[:with] || {}).tap do |with|
-        with[:sphinx_deleted] = false
-      end
+      (options[:with] || {}).merge({:sphinx_deleted => false})
     end
 
     def index_names
@@ -108,17 +117,13 @@ class ThinkingSphinx::Middlewares::SphinxQL <
       @indices ||= ThinkingSphinx::IndexSet.new classes, options[:indices]
     end
 
-    def options
-      context.search.options
-    end
+    delegate :search, :to => :context
+    delegate :options, :to => :search
 
     def order_clause
-      case options[:order]
-      when Symbol
-        "#{options[:order]} ASC"
-      else
-        options[:order]
-      end
+      order_by = options[:order]
+      order_by = "#{order_by} ASC" if order_by.is_a? Symbol
+      order_by
     end
 
     def select_options
@@ -130,31 +135,96 @@ class ThinkingSphinx::Middlewares::SphinxQL <
       end
     end
 
-    def settings
-      context.configuration.settings
+    delegate :configuration, :to => :context
+    delegate :settings, :to => :configuration
+
+    def values
+      options[:select] ||= '*, @groupby, @count' if group_attribute.present?
+      options[:select]
     end
 
     def statement
-      Riddle::Query::Select.new.tap do |select|
-        select.from *index_names.collect { |index| "`#{index}`" }
-        select.values values                if values.present?
-        select.matching extended_query      if extended_query.present?
-        select.where inclusive_filters      if inclusive_filters.any?
-        select.where_all options[:with_all] if options[:with_all]
-        select.where_not exclusive_filters  if exclusive_filters.any?
-        select.where_not_all options[:without_all] if options[:without_all]
-        select.order_by order_clause        if order_clause.present?
-        select.group_by group_attribute     if group_attribute.present?
-        select.order_within_group_by group_order_clause if group_order_clause.present?
-        select.offset context.search.offset
-        select.limit  context.search.per_page
-        select.with_options select_options  if select_options.keys.any?
-      end
+      Statement.new(self).to_riddle_query_select
     end
 
-    def values
-      options[:select] ||= '*, @groupby, @count' if group_attribute.present?
-      options[:select]
+    class Statement
+      def initialize(report)
+        self.report = report
+        self.query = Riddle::Query::Select.new
+      end
+
+      def to_riddle_query_select
+        filter_by_scopes
+
+        query
+      end
+
+      protected
+      attr_accessor :report, :query
+      def filter_by_scopes
+        scope_by_from
+        scope_by_values
+        scope_by_extended_query
+        scope_by_inclusive_filters
+        scope_by_with_all
+        scope_by_exclusive_filters
+        scope_by_without_all
+
+        scope_by_order
+        scope_by_group
+        scope_by_pagination
+        scope_by_options
+      end
+
+      def scope_by_from
+        query.from *(index_names.collect { |index| "`#{index}`" })
+      end
+
+      def scope_by_values
+        query.values values if values.present?
+      end
+
+      def scope_by_extended_query
+        query.matching extended_query if extended_query.present?
+      end
+
+      def scope_by_inclusive_filters
+        query.where inclusive_filters if inclusive_filters.any?
+      end
+
+      def scope_by_with_all
+        query.where_all options[:with_all] if options[:with_all]
+      end
+
+      def scope_by_exclusive_filters
+        query.where_not exclusive_filters  if exclusive_filters.any?
+      end
+
+      def scope_by_without_all
+        query.where_not_all options[:without_all] if options[:without_all]
+      end
+
+      def scope_by_order
+        query.order_by order_clause if order_clause.present?
+      end
+
+      def scope_by_group
+        query.group_by group_attribute if group_attribute.present?
+        query.order_within_group_by group_order_clause if group_order_clause.present?
+      end
+
+      def scope_by_pagination
+        query.offset context.search.offset
+        query.limit  context.search.per_page
+      end
+
+      def scope_by_options
+        query.with_options select_options if select_options.keys.any?
+      end
+
+      def method_missing(*args, &block)
+        report.send *args, &block
+      end
     end
   end
 end

data/lib/thinking_sphinx/panes/excerpts_pane.rb

@@ -18,9 +18,13 @@ class ThinkingSphinx::Panes::ExcerptsPane
   end
 
   def excerpt_words
-    @excerpt_words ||= @context[:meta].keys.select { |key|
-      key[/^keyword\[/]
-    }.sort.collect { |key| @context[:meta][key] }.join(' ')
+    @excerpt_words ||= begin
+      conditions = @context.search.options[:conditions] || {}
+      ThinkingSphinx::Search::Query.new(
+        ([@context.search.query] + conditions.values).compact.join(' '),
+        {}, @context.search.options[:star]
+      ).to_s
+    end
   end
 
   class Excerpts

data/lib/thinking_sphinx/rake_interface.rb

@@ -1,4 +1,13 @@
 class ThinkingSphinx::RakeInterface
+  def clear
+    [
+      configuration.indices_location,
+      configuration.searchd.binlog_path
+    ].each do |path|
+      FileUtils.rm_r(path) if File.exists?(path)
+    end
+  end
+
   def configure
     puts "Generating configuration to #{configuration.configuration_file}"
     configuration.render_to_file
@@ -37,6 +46,7 @@ class ThinkingSphinx::RakeInterface
   def start
     raise RuntimeError, 'searchd is already running' if controller.running?
 
+    FileUtils.mkdir_p configuration.indices_location
     controller.start
 
     if controller.running?

data/lib/thinking_sphinx/real_time.rb

@@ -1,5 +1,11 @@
 module ThinkingSphinx::RealTime
-  module Callbacks; end
+  module Callbacks
+    #
+  end
+
+  def self.callback_for(reference, path = [])
+    Callbacks::RealTimeCallbacks.new reference, path
+  end
 end
 
 require 'thinking_sphinx/real_time/property'

data/lib/thinking_sphinx/real_time/attribute.rb

@@ -1,4 +1,8 @@
 class ThinkingSphinx::RealTime::Attribute < ThinkingSphinx::RealTime::Property
+  def multi?
+    @options[:multi]
+  end
+
   def type
     @options[:type]
   end

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

@@ -1,18 +1,22 @@
-class ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks <
-  ThinkingSphinx::Callbacks
-
-  callbacks :after_save
+class ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks
+  def initialize(reference, path = [])
+    @reference, @path = reference, path
+  end
 
-  def after_save
+  def after_save(instance)
     return unless real_time_indices?
 
     real_time_indices.each do |index|
-      ThinkingSphinx::RealTime::Transcriber.new(index).copy instance
+      objects_for(instance).each do |object|
+        ThinkingSphinx::RealTime::Transcriber.new(index).copy object
+      end
     end
   end
 
   private
 
+  attr_reader :reference, :path
+
   def configuration
     ThinkingSphinx::Configuration.instance
   end
@@ -21,6 +25,10 @@ class ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks <
     @indices ||= configuration.indices_for_references reference
   end
 
+  def objects_for(instance)
+    Array(path.inject(instance) { |object, method| object.send method })
+  end
+
   def real_time_indices?
     real_time_indices.any?
   end
@@ -30,8 +38,4 @@ class ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks <
       index.is_a? ThinkingSphinx::RealTime::Index
     }
   end
-
-  def reference
-    instance.class.name.underscore.to_sym
-  end
 end

data/lib/thinking_sphinx/real_time/index.rb

@@ -49,6 +49,25 @@ class ThinkingSphinx::RealTime::Index < Riddle::Configuration::RealtimeIndex
 
   private
 
+  def append_unique_attribute(collection, attribute)
+    collection << attribute.name unless collection.include?(attribute.name)
+  end
+
+  def collection_for(attribute)
+    case attribute.type
+    when :integer, :boolean
+      attribute.multi? ? @rt_attr_multi : @rt_attr_uint
+    when :string
+      @rt_attr_string
+    when :timestamp
+      @rt_attr_timestamp
+    when :float
+      @rt_attr_float
+    else
+      raise "Unknown attribute type '#{attribute.type}'"
+    end
+  end
+
   def interpreter
     ThinkingSphinx::RealTime::Interpreter
   end
@@ -59,18 +78,7 @@ class ThinkingSphinx::RealTime::Index < Riddle::Configuration::RealtimeIndex
     @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}'"
-      end
+      append_unique_attribute collection_for(attribute), attribute
     end
   end