thinking-sphinx 3.0.3 → 3.0.4

data/lib/thinking_sphinx/active_record/sql_source.rb

@@ -1,143 +1,148 @@
-class ThinkingSphinx::ActiveRecord::SQLSource < Riddle::Configuration::SQLSource
-  attr_reader :model, :database_settings, :options
-  attr_accessor :fields, :attributes, :associations, :conditions, :groupings,
-    :polymorphs
-
-  OPTIONS = [:name, :offset, :delta_processor, :delta?, :disable_range?,
-    :group_concat_max_len, :utf8?, :position]
-
-  def initialize(model, options = {})
-    @model             = model
-    @database_settings = model.connection.instance_variable_get(:@config).clone
-    @options           = {
-      :utf8? => (@database_settings[:encoding] == 'utf8')
-    }.merge options
-
-    @fields            = []
-    @attributes        = []
-    @associations      = []
-    @conditions        = []
-    @groupings         = []
-    @polymorphs        = []
-
-    Template.new(self).apply
-
-    name = "#{options[:name] || model.name.downcase}_#{options[:position]}"
-
-    super name, type
-
-    apply_defaults
-  end
-
-  def adapter
-    @adapter ||= ThinkingSphinx::ActiveRecord::DatabaseAdapters.
-      adapter_for(@model)
-  end
-
-  def delta_processor
-    options[:delta_processor].try(:new, adapter)
-  end
-
-  def delta?
-    options[:delta?]
-  end
-
-  def disable_range?
-    options[:disable_range?]
-  end
-
-  def facets
-    properties.select(&:facet?)
-  end
-
-  def offset
-    options[:offset]
-  end
-
-  def primary_key
-    options[:primary_key]
-  end
-
-  def render
-    prepare_for_render unless @prepared
-
-    super
-  end
-
-  def type
-    @type ||= case adapter
-    when ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter
-      'mysql'
-    when ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter
-      'pgsql'
-    else
-      raise "Unknown Adapter Type: #{adapter.class.name}"
+module ThinkingSphinx
+  module ActiveRecord
+    class SQLSource < Riddle::Configuration::SQLSource
+      include ThinkingSphinx::Core::Settings
+      attr_reader :model, :database_settings, :options
+      attr_accessor :fields, :attributes, :associations, :conditions, :groupings,
+        :polymorphs
+
+      OPTIONS = [:name, :offset, :delta_processor, :delta?, :disable_range?,
+        :group_concat_max_len, :utf8?, :position]
+
+      def initialize(model, options = {})
+        @model             = model
+        @database_settings = ::ActiveRecord::Base.connection.
+          instance_variable_get(:@config).clone
+        @options           = {
+          :utf8? => (@database_settings[:encoding] == 'utf8')
+        }.merge options
+
+        @fields            = []
+        @attributes        = []
+        @associations      = []
+        @conditions        = []
+        @groupings         = []
+        @polymorphs        = []
+
+        Template.new(self).apply
+
+        name = "#{options[:name] || model.name.downcase}_#{options[:position]}"
+
+        super name, type
+
+        apply_defaults!
+      end
+
+      def adapter
+        @adapter ||= DatabaseAdapters.adapter_for(@model)
+      end
+
+      def delta_processor
+        options[:delta_processor].try(:new, adapter)
+      end
+
+      def delta?
+        options[:delta?]
+      end
+
+      def disable_range?
+        options[:disable_range?]
+      end
+
+      def facets
+        properties.select(&:facet?)
+      end
+
+      def offset
+        options[:offset]
+      end
+
+      def primary_key
+        options[:primary_key]
+      end
+
+      def render
+        prepare_for_render unless @prepared
+
+        super
+      end
+
+      def type
+        @type ||= case adapter
+        when DatabaseAdapters::MySQLAdapter
+          'mysql'
+        when DatabaseAdapters::PostgreSQLAdapter
+          'pgsql'
+        else
+          raise "Unknown Adapter Type: #{adapter.class.name}"
+        end
+      end
+
+      private
+
+      def append_presenter_to_attribute_array
+        attributes.each do |attribute|
+          presenter = Attribute::SphinxPresenter.new(attribute, self)
+
+          attribute_array_for(presenter.collection_type) << presenter.declaration
+        end
+      end
+
+      def attribute_array_for(type)
+        instance_variable_get "@sql_attr_#{type}".to_sym
+      end
+
+      def builder
+        @builder ||= SQLBuilder.new self
+      end
+
+      def build_sql_fields
+        fields.each do |field|
+          @sql_field_string        << field.name if field.with_attribute?
+          @sql_field_str2wordcount << field.name if field.wordcount?
+          @sql_file_field          << field.name if field.file?
+
+          @sql_joined_field << PropertyQuery.new(field, self).to_s if field.source_type
+        end
+      end
+
+      def build_sql_query
+        @sql_query       = builder.sql_query
+        @sql_query_range = builder.sql_query_range
+        @sql_query_info  = builder.sql_query_info
+        @sql_query_pre  += builder.sql_query_pre
+      end
+
+      def config
+        ThinkingSphinx::Configuration.instance
+      end
+
+      def prepare_for_render
+        polymorphs.each &:morph!
+        append_presenter_to_attribute_array
+
+        set_database_settings
+        build_sql_fields
+        build_sql_query
+
+        @prepared = true
+      end
+
+      def properties
+        fields + attributes
+      end
+
+      def set_database_settings
+        @sql_host ||= database_settings[:host]     || 'localhost'
+        @sql_user ||= database_settings[:username] || database_settings[:user] ||
+          ENV['USER']
+        @sql_pass ||= database_settings[:password].to_s.gsub('#', '\#')
+        @sql_db   ||= database_settings[:database]
+        @sql_port ||= database_settings[:port]
+        @sql_sock ||= database_settings[:socket]
+      end
     end
   end
-
-  private
-
-  def apply_defaults
-    self.class.settings.each do |setting|
-      value = config.settings[setting.to_s]
-      send("#{setting}=", value) unless value.nil?
-    end
-  end
-
-  def attribute_array_for(type)
-    instance_variable_get "@sql_attr_#{type}".to_sym
-  end
-
-  def builder
-    @builder ||= ThinkingSphinx::ActiveRecord::SQLBuilder.new self
-  end
-
-  def config
-    ThinkingSphinx::Configuration.instance
-  end
-
-  def prepare_for_render
-    polymorphs.each &:morph!
-
-    set_database_settings
-
-    fields.each do |field|
-      @sql_field_string        << field.name if field.with_attribute?
-      @sql_field_str2wordcount << field.name if field.wordcount?
-      @sql_file_field          << field.name if field.file?
-
-      @sql_joined_field << ThinkingSphinx::ActiveRecord::PropertyQuery.new(
-        field, self
-      ).to_s if field.source_type
-    end
-
-    attributes.each do |attribute|
-      presenter = ThinkingSphinx::ActiveRecord::Attribute::SphinxPresenter.new(attribute, self)
-
-      attribute_array_for(presenter.collection_type) << presenter.declaration
-    end
-
-    @sql_query       = builder.sql_query
-    @sql_query_range = builder.sql_query_range
-    @sql_query_info  = builder.sql_query_info
-    @sql_query_pre  += builder.sql_query_pre
-
-    @prepared = true
-  end
-
-  def properties
-    fields + attributes
-  end
-
-  def set_database_settings
-    @sql_host ||= database_settings[:host]     || 'localhost'
-    @sql_user ||= database_settings[:username] || database_settings[:user] ||
-      ENV['USER']
-    @sql_pass ||= database_settings[:password].to_s.gsub('#', '\#')
-    @sql_db   ||= database_settings[:database]
-    @sql_port ||= database_settings[:port]
-    @sql_sock ||= database_settings[:socket]
-  end
 end
 
 require 'thinking_sphinx/active_record/sql_source/template'

data/lib/thinking_sphinx/capistrano.rb

@@ -1,29 +1,32 @@
 Capistrano::Configuration.instance(:must_exist).load do
+  _cset(:thinking_sphinx_roles)   { :db }
+  _cset(:thinking_sphinx_options) { {:roles => fetch(:thinking_sphinx_roles)} }
+
   namespace :thinking_sphinx do
     desc 'Generate the Sphinx configuration file.'
-    task :configure do
+    task :configure, fetch(:thinking_sphinx_options) do
       rake 'ts:configure'
     end
 
     desc 'Build Sphinx indexes into the shared path and symlink them into your release.'
-    task :index do
+    task :index, fetch(:thinking_sphinx_options) do
       rake 'ts:index'
     end
     after 'thinking_sphinx:index', 'thinking_sphinx:symlink_indexes'
 
     desc 'Start the Sphinx search daemon.'
-    task :start do
+    task :start, fetch(:thinking_sphinx_options) do
       rake 'ts:start'
     end
     before 'thinking_sphinx:start', 'thinking_sphinx:configure'
 
     desc 'Stop the Sphinx search daemon.'
-    task :stop do
+    task :stop, fetch(:thinking_sphinx_options) do
       rake 'ts:stop'
     end
 
     desc 'Restart the Sphinx search daemon.'
-    task :restart do
+    task :restart, fetch(:thinking_sphinx_options) do
       rake 'ts:stop ts:configure ts:start'
     end
 
@@ -31,19 +34,19 @@ Capistrano::Configuration.instance(:must_exist).load do
 Stop, reindex, and then start the Sphinx search daemon. This task must be executed \
 if you alter the structure of your indexes.
     DESC
-    task :rebuild do
+    task :rebuild, fetch(:thinking_sphinx_options) do
       rake 'ts:rebuild'
     end
     after 'thinking_sphinx:rebuild', 'thinking_sphinx:symlink_indexes'
 
     desc 'Create the shared folder for sphinx indexes.'
-    task :shared_sphinx_folder do
+    task :shared_sphinx_folder, fetch(:thinking_sphinx_options) do
       rails_env = fetch(:rails_env, 'production')
       run "mkdir -p #{shared_path}/db/sphinx/#{rails_env}"
     end
 
     desc 'Symlink Sphinx indexes from the shared folder to the latest release.'
-    task :symlink_indexes do
+    task :symlink_indexes, fetch(:thinking_sphinx_options) do
       run "if [ -d #{release_path} ]; then ln -nfs #{shared_path}/db/sphinx #{release_path}/db/sphinx; else ln -nfs #{shared_path}/db/sphinx #{current_path}/db/sphinx; fi;"
     end
 

data/lib/thinking_sphinx/configuration.rb

@@ -1,3 +1,5 @@
+require 'pathname'
+
 class ThinkingSphinx::Configuration < Riddle::Configuration
   attr_accessor :configuration_file, :indices_location, :version
   attr_reader :index_paths
@@ -19,12 +21,14 @@ class ThinkingSphinx::Configuration < Riddle::Configuration
     @instance = nil
   end
 
+  def bin_path
+    settings['bin_path']
+  end
+
   def controller
     @controller ||= begin
       rc = Riddle::Controller.new self, configuration_file
-      if settings['bin_path'].present?
-        rc.bin_path = settings['bin_path'].gsub(/([^\/])$/, '\1/')
-      end
+      rc.bin_path = bin_path.gsub(/([^\/])$/, '\1/') if bin_path.present?
       rc
     end
   end
@@ -42,11 +46,13 @@ class ThinkingSphinx::Configuration < Riddle::Configuration
   def engine_index_paths
     return [] unless defined?(Rails)
 
-    Rails::Engine::Railties.engines.select { |engine|
-      engine.paths['app/indices']
-    }.collect { |engine|
-      engine.paths['app/indices'].existent
-    }.flatten
+    engine_indice_paths.flatten.compact
+  end
+
+  def engine_indice_paths
+    Rails::Engine::Railties.engines.collect do |engine|
+      engine.paths['app/indices'].existent if engine.paths['app/indices']
+    end
   end
 
   def indices_for_references(*references)
@@ -90,48 +96,64 @@ class ThinkingSphinx::Configuration < Riddle::Configuration
 
   private
 
+  def configure_searchd
+    configure_searchd_log_files
+
+    searchd.binlog_path = framework_root.join('tmp', 'binlog',environment).to_s
+    searchd.address = settings['address'].presence || Defaults::ADDRESS
+    searchd.mysql41 = settings['mysql41'] || settings['port'] || Defaults::PORT
+    searchd.workers = 'threads'
+  end
+
+  def configure_searchd_log_files
+    searchd.pid_file = log_root.join("#{environment}.sphinx.pid").to_s
+    searchd.log = log_root.join("#{environment}.searchd.log").to_s
+    searchd.query_log = log_root.join("#{environment}.searchd.query.log").to_s
+  end
+
+  def log_root
+    framework_root.join('log')
+  end
+
+  def framework_root
+    Pathname.new(framework.root)
+  end
+
   def settings_to_hash
     contents = YAML.load(ERB.new(File.read(settings_file)).result)
     contents && contents[environment] || {}
   end
 
   def settings_file
-    File.join framework.root, 'config', 'thinking_sphinx.yml'
+    framework_root.join 'config', 'thinking_sphinx.yml'
   end
 
   def setup
-    @configuration_file = settings['configuration_file'] ||
-      File.join(framework.root, 'config', "#{environment}.sphinx.conf")
-    @index_paths        = engine_index_paths +
-      [File.join(framework.root, 'app', 'indices')]
-    @indices_location   = settings['indices_location'] ||
-      File.join(framework.root, 'db', 'sphinx', environment)
-    @version            = settings['version'] || '2.0.6'
-
-    searchd.pid_file    = File.join framework.root, 'log',
-      "#{environment}.sphinx.pid"
-    searchd.log         = File.join framework.root, 'log',
-      "#{environment}.searchd.log"
-    searchd.query_log   = File.join framework.root, 'log',
-      "#{environment}.searchd.query.log"
-    searchd.binlog_path = File.join framework.root, 'tmp', 'binlog',
-      environment
-
-    searchd.address   = settings['address']
-    searchd.address   = Defaults::ADDRESS unless searchd.address.present?
-    searchd.mysql41   = settings['mysql41'] || settings['port'] ||
-      Defaults::PORT
-    searchd.workers   = 'threads'
-
-   [indexer, searchd].each do |object|
+    @settings = nil
+    @configuration_file = settings['configuration_file'] || framework_root.join(
+      'config', "#{environment}.sphinx.conf"
+    ).to_s
+    @index_paths = engine_index_paths + [framework_root.join('app', 'indices').to_s]
+    @indices_location = settings['indices_location'] || framework_root.join(
+      'db', 'sphinx', environment
+    ).to_s
+    @version = settings['version'] || '2.0.6'
+
+    configure_searchd
+
+    apply_sphinx_settings!
+
+    @offsets = {}
+  end
+
+  def apply_sphinx_settings!
+    [indexer, searchd].each do |object|
       settings.each do |key, value|
         next unless object.class.settings.include?(key.to_sym)
 
         object.send("#{key}=", value)
       end
     end
-
-    @offsets = {}
   end
 end