thinking-sphinx 2.1.0 → 3.0.0.pre

data/lib/cucumber/thinking_sphinx/internal_world.rb

@@ -1,137 +0,0 @@
-require 'cucumber/thinking_sphinx/sql_logger'
-
-module Cucumber
-  module ThinkingSphinx
-    class InternalWorld
-      attr_accessor :temporary_directory, :migrations_directory,
-        :models_directory, :fixtures_directory, :database_file
-      attr_accessor :adapter, :database, :username,
-        :password, :host
-
-      def initialize
-        pwd = Dir.pwd
-        @temporary_directory  = "#{pwd}/tmp"
-        @migrations_directory = "#{pwd}/features/thinking_sphinx/db/migrations"
-        @models_directory     = "#{pwd}/features/thinking_sphinx/models"
-        @fixtures_directory   = "#{pwd}/features/thinking_sphinx/db/fixtures"
-        @database_file        = "#{pwd}/features/thinking_sphinx/database.yml"
-
-        @adapter  = (ENV['DATABASE'] || 'mysql').gsub /^mysql$/, 'mysql2'
-        @database = 'thinking_sphinx'
-        @username = ENV['USER']
-        @host     = 'localhost'
-
-        if @adapter[/mysql/]
-          @username = 'root'
-        elsif ENV['TRAVIS']
-          @username = 'postgres'
-        end
-      end
-
-      def setup
-        make_temporary_directory
-
-        configure_cleanup
-        configure_thinking_sphinx
-        configure_active_record
-
-        prepare_data
-        setup_sphinx
-
-        self
-      end
-
-      def configure_database
-        ActiveRecord::Base.establish_connection database_settings
-        self
-      end
-
-      private
-
-      def config
-        @config ||= ::ThinkingSphinx::Configuration.instance
-      end
-
-      def make_temporary_directory
-        FileUtils.mkdir_p temporary_directory
-        Dir["#{temporary_directory}/*"].each do |file|
-          FileUtils.rm_rf file
-        end
-      end
-
-      def configure_thinking_sphinx
-        config.config_file        = "#{temporary_directory}/sphinx.conf"
-        config.searchd_log_file   = "#{temporary_directory}/searchd.log"
-        config.query_log_file     = "#{temporary_directory}/searchd.query.log"
-        config.pid_file           = "#{temporary_directory}/searchd.pid"
-        config.searchd_file_path  = "#{temporary_directory}/indexes/"
-
-        ::ThinkingSphinx.suppress_delta_output = true
-      end
-
-      def configure_cleanup
-        Kernel.at_exit do
-          ::ThinkingSphinx::Configuration.instance.controller.stop
-          sleep(0.5) # Ensure Sphinx has shut down completely
-          ::ThinkingSphinx::ActiveRecord::LogSubscriber.logger.close
-          ::ActiveRecord::Base.logger.close
-        end
-      end
-
-      def yaml_database_settings
-        return {} unless File.exist?(@database_file)
-
-        YAML.load open(@database_file)
-      end
-
-      def database_settings
-        {
-          'adapter'  => @adapter,
-          'database' => @database,
-          'username' => @username,
-          'password' => @password,
-          'host'     => @host
-        }.merge yaml_database_settings
-      end
-
-      def configure_active_record
-        ::ActiveRecord::Base.logger = Logger.new(
-          open("#{temporary_directory}/active_record.log", "a")
-        )
-
-        ::ThinkingSphinx::ActiveRecord::LogSubscriber.logger = Logger.new(
-          open("#{temporary_directory}/active_record.log", "a")
-        )
-
-        ActiveRecord::Base.connection.class.send(
-          :include, Cucumber::ThinkingSphinx::SqlLogger
-        )
-      end
-
-      def prepare_data
-        ::ThinkingSphinx.deltas_enabled = false
-
-        load_files migrations_directory
-        load_files models_directory
-        load_files fixtures_directory
-
-        ::ThinkingSphinx.deltas_enabled = true
-      end
-
-      def load_files(path)
-        files = Dir["#{path}/*.rb"].sort!
-        files.each do |file|
-          require file.gsub(/\.rb$/, '')
-        end
-      end
-
-      def setup_sphinx
-        FileUtils.mkdir_p config.searchd_file_path
-
-        config.build
-        config.controller.index
-        config.controller.start
-      end
-    end
-  end
-end

data/lib/cucumber/thinking_sphinx/sql_logger.rb

@@ -1,28 +0,0 @@
-module Cucumber
-  module ThinkingSphinx
-    module SqlLogger
-      IGNORED_SQL = [
-        /^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/,
-        /^SELECT @@ROWCOUNT/, /^SHOW FIELDS/
-      ]
-
-      if ActiveRecord::VERSION::STRING.to_f > 3.0
-        def log(sql, name = 'SQL', binds = [])
-          $queries_executed ||= []
-          $queries_executed << sql unless IGNORED_SQL.any? { |r| sql =~ r }
-          super sql, name, binds
-        end
-      else
-        def self.included(base)
-          base.send :alias_method_chain, :execute, :query_record
-        end
-
-        def execute_with_query_record(sql, name = 'SQL', &block)
-          $queries_executed ||= []
-          $queries_executed << sql unless IGNORED_SQL.any? { |r| sql =~ r }
-          execute_without_query_record(sql, name, &block)
-        end
-      end
-    end
-  end
-end

data/lib/thinking_sphinx/action_controller.rb

@@ -1,31 +0,0 @@
-module ThinkingSphinx
-  module ActionController
-    extend ActiveSupport::Concern
-
-    protected
-
-    attr_internal :query_runtime
-
-    def cleanup_view_runtime
-      log_subscriber = ThinkingSphinx::ActiveRecord::LogSubscriber
-      query_runtime_pre_render = log_subscriber.reset_runtime
-      runtime = super
-      query_runtime_post_render = log_subscriber.reset_runtime
-      self.query_runtime = query_runtime_pre_render + query_runtime_post_render
-      runtime - query_runtime_post_render
-    end
-
-    def append_info_to_payload(payload)
-      super
-      payload[:query_runtime] = query_runtime
-    end
-
-    module ClassMethods
-      def log_process_action(payload)
-        messages, query_runtime = super, payload[:query_runtime]
-        messages << ("Sphinx: %.1fms" % query_runtime.to_f) if query_runtime
-        messages
-      end
-    end
-  end
-end

data/lib/thinking_sphinx/active_record/attribute_updates.rb

@@ -1,54 +0,0 @@
-module ThinkingSphinx
-  module ActiveRecord
-    module AttributeUpdates
-      def self.included(base)
-        base.class_eval do
-          after_save :update_attribute_values
-        end
-      end
-
-      private
-
-      def update_attribute_values
-        return true unless ThinkingSphinx.updates_enabled? &&
-          ThinkingSphinx.sphinx_running?
-
-        self.class.sphinx_indexes.each do |index|
-          attribute_pairs  = attribute_values_for_index(index)
-          attribute_names  = attribute_pairs.keys
-          attribute_values = attribute_names.collect { |key|
-            attribute_pairs[key]
-          }
-
-          update_index index.core_name, attribute_names, attribute_values
-          next unless index.delta?
-          update_index index.delta_name, attribute_names, attribute_values
-        end
-
-        true
-      end
-
-      def updatable_attributes(index)
-        index.attributes.select { |attrib| attrib.updatable? }
-      end
-
-      def attribute_values_for_index(index)
-        updatable_attributes(index).inject({}) { |hash, attrib|
-          hash[attrib.unique_name.to_s] = attrib.live_value self
-          hash
-        }
-      end
-
-      def update_index(index_name, attribute_names, attribute_values)
-        ThinkingSphinx::Connection.take do |client|
-          client.update index_name, attribute_names, {
-            sphinx_document_id => attribute_values
-          }
-        end
-      rescue Riddle::ConnectionError, Riddle::ResponseError,
-        ThinkingSphinx::SphinxError, Errno::ETIMEDOUT
-        # Not the end of the world if Sphinx isn't running.
-      end
-    end
-  end
-end

data/lib/thinking_sphinx/active_record/collection_proxy.rb

@@ -1,47 +0,0 @@
-module ThinkingSphinx
-  module ActiveRecord
-    module CollectionProxy
-      def search(*args)
-        proxy_association.klass.search(*association_args(args))
-      end
-
-      def facets(*args)
-        proxy_association.klass.facets(*association_args(args))
-      end
-
-      private
-
-      def association_args(args)
-        options = args.extract_options!
-        options[:with] ||= {}
-        options[:with].merge! default_filter
-
-        args + [options]
-      end
-
-      def attribute_for_foreign_key
-        if proxy_association.reflection.through_reflection
-          foreign_key = proxy_association.reflection.through_reflection.foreign_key
-        else
-          foreign_key = proxy_association.reflection.foreign_key
-        end
-
-        proxy_association.klass.define_indexes
-        (proxy_association.klass.sphinx_indexes || []).each do |index|
-          attribute = index.attributes.detect { |attrib|
-            attrib.columns.length == 1 &&
-            attrib.columns.first.__name  == foreign_key.to_sym ||
-            attrib.alias == foreign_key.to_sym
-          }
-          return attribute unless attribute.nil?
-        end
-
-        raise "Missing Attribute for Foreign Key #{foreign_key}"
-      end
-
-      def default_filter
-        {attribute_for_foreign_key.unique_name => proxy_association.owner.id}
-      end
-    end
-  end
-end

data/lib/thinking_sphinx/active_record/collection_proxy_with_scopes.rb

@@ -1,27 +0,0 @@
-module ThinkingSphinx
-  module ActiveRecord
-    module CollectionProxyWithScopes
-      def self.included(base)
-        base.class_eval do
-          alias_method_chain :method_missing, :sphinx_scopes
-          alias_method_chain :respond_to?, :sphinx_scopes
-        end
-      end
-
-      def method_missing_with_sphinx_scopes(method, *args, &block)
-        klass = proxy_association.klass
-        if klass.respond_to?(:sphinx_scopes) && klass.sphinx_scopes.include?(method)
-          klass.search(:with => default_filter).send(method, *args, &block)
-        else
-          method_missing_without_sphinx_scopes(method, *args, &block)
-        end
-      end
-
-      def respond_to_with_sphinx_scopes?(method)
-        proxy_association.klass.respond_to?(:sphinx_scopes) &&
-        proxy_association.klass.sphinx_scopes.include?(method) ||
-        respond_to_without_sphinx_scopes?(method)
-      end
-    end
-  end
-end

data/lib/thinking_sphinx/active_record/delta.rb

@@ -1,67 +0,0 @@
-module ThinkingSphinx
-  module ActiveRecord
-    # This module contains all the delta-related code for models. There isn't
-    # really anything you need to call manually in here - except perhaps
-    # index_delta, but not sure what reason why.
-    #
-    module Delta
-      # Code for after_commit callback is written by Eli Miller:
-      # http://elimiller.blogspot.com/2007/06/proper-cache-expiry-with-aftercommit.html
-      # with slight modification from Joost Hietbrink.
-      #
-      def self.included(base)
-        base.class_eval do
-          class << self
-            # Build the delta index for the related model. This won't be called
-            # if running in the test environment.
-            #
-            def index_delta(instance = nil)
-              delta_objects.each { |obj| obj.index(self, instance) }
-            end
-
-            def delta_objects
-              self.sphinx_indexes.collect(&:delta_object).compact
-            end
-          end
-
-          def toggled_delta?
-            self.class.delta_objects.any? { |obj| obj.toggled(self) }
-          end
-
-          private
-
-          # Set the delta value for the model to be true.
-          def toggle_delta
-            self.class.delta_objects.each { |obj|
-              obj.toggle(self)
-            } if should_toggle_delta?
-          end
-
-          # Build the delta index for the related model. This won't be called
-          # if running in the test environment.
-          #
-          def index_delta
-            self.class.index_delta(self) if self.class.delta_objects.any? { |obj|
-              obj.toggled(self)
-            }
-          end
-
-          def should_toggle_delta?
-            return fire_delta? if respond_to?(:fire_delta?)
-
-            self.new_record? || indexed_data_changed?
-          end
-
-          def indexed_data_changed?
-            sphinx_indexes.any? { |index|
-              index.fields.any? { |field| field.changed?(self) } ||
-              index.attributes.any? { |attrib|
-                attrib.public? && attrib.changed?(self) && !attrib.updatable?
-              }
-            }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/thinking_sphinx/active_record/has_many_association.rb

@@ -1,44 +0,0 @@
-module ThinkingSphinx
-  module ActiveRecord
-    module HasManyAssociation
-      def search(*args)
-        @reflection.klass.search(*association_args(args))
-      end
-
-      def facets(*args)
-        @reflection.klass.facets(*association_args(args))
-      end
-
-      private
-
-      def association_args(args)
-        options = args.extract_options!
-        options[:with] ||= {}
-        options[:with].merge! default_filter
-
-        args + [options]
-      end
-
-      def attribute_for_foreign_key
-        foreign_key = @reflection.primary_key_name
-        stack = [@reflection.options[:through]].compact
-        
-        @reflection.klass.define_indexes
-        (@reflection.klass.sphinx_indexes || []).each do |index|
-          attribute = index.attributes.detect { |attrib|
-            attrib.columns.length == 1 &&
-            attrib.columns.first.__name  == foreign_key.to_sym ||
-            attrib.alias == foreign_key.to_sym
-          }
-          return attribute unless attribute.nil?
-        end
-        
-        raise "Missing Attribute for Foreign Key #{foreign_key}"
-      end
-      
-      def default_filter
-        {attribute_for_foreign_key.unique_name => @owner.id}
-      end
-    end
-  end
-end

data/lib/thinking_sphinx/active_record/has_many_association_with_scopes.rb

@@ -1,21 +0,0 @@
-module ThinkingSphinx
-  module ActiveRecord
-    module HasManyAssociationWithScopes
-      def method_missing(method, *args, &block)
-        if responds_to_scope(method)
-          @reflection.klass.
-            search(:with => default_filter).
-            send(method, *args, &block)
-        else
-          super
-        end
-      end
-      
-      private
-      def responds_to_scope(scope)
-        @reflection.klass.respond_to?(:sphinx_scopes)   &&
-        @reflection.klass.sphinx_scopes.include?(scope)
-      end
-    end
-  end
-end