ebeigarts-thinking-sphinx 1.1.21

data/tasks/distribution.rb

@@ -0,0 +1,67 @@
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'thinking_sphinx'
+
+desc 'Generate documentation'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Thinking Sphinx - ActiveRecord Sphinx Plugin'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+spec = Gem::Specification.new do |s|
+  s.name              = "thinking-sphinx"
+  s.version           = ThinkingSphinx::Version::String
+  s.summary           = "A concise and easy-to-use Ruby library that connects ActiveRecord to the Sphinx search daemon, managing configuration, indexing and searching."
+  s.description       = "A concise and easy-to-use Ruby library that connects ActiveRecord to the Sphinx search daemon, managing configuration, indexing and searching."
+  s.author            = "Pat Allan"
+  s.email             = "pat@freelancing-gods.com"
+  s.homepage          = "http://ts.freelancing-gods.com"
+  s.has_rdoc          = true
+  s.rdoc_options     << "--title" << "Thinking Sphinx -- Rails/Merb Sphinx Plugin" <<
+                        "--line-numbers"
+  s.rubyforge_project = "thinking-sphinx"
+  s.test_files        = FileList["spec/**/*_spec.rb"]
+  s.files             = FileList[
+    "rails/*.rb",
+    "lib/**/*.rb",
+    "LICENCE",
+    "README.textile",
+    "tasks/**/*.rb",
+    "tasks/**/*.rake",
+    "vendor/**/*"
+  ]
+  s.post_install_message = <<-MESSAGE
+With the release of Thinking Sphinx 1.1.18, there is one important change to
+note: previously, the default morphology for indexing was 'stem_en'. The new
+default is nil, to avoid any unexpected behavior. If you wish to keep the old
+value though, you will need to add the following settings to your
+config/sphinx.yml file:
+
+development:
+  morphology: stem_en
+test:
+  morphology: stem_en
+production:
+  morphology: stem_en
+
+To understand morphologies/stemmers better, visit the following link:
+http://www.sphinxsearch.com/docs/manual-0.9.8.html#conf-morphology
+
+MESSAGE
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+desc "Build gemspec file"
+task :build do
+  File.open('thinking-sphinx.gemspec', 'w') { |f| f.write spec.to_ruby }
+end

data/tasks/rails.rake

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), '/../lib/thinking_sphinx/tasks')

data/tasks/testing.rb

@@ -0,0 +1,100 @@
+require 'rubygems'
+require 'spec/rake/spectask'
+require 'cucumber/rake/task'
+
+desc "Run the specs under spec"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts << "-c"
+end
+
+desc "Run all feature-set configurations"
+task :features do |t|
+  puts   "rake features:mysql"
+  system "rake features:mysql"
+  puts   "rake features:postgresql"
+  system "rake features:postgresql"
+end
+
+namespace :features do
+  def add_task(name, description)
+    Cucumber::Rake::Task.new(name, description) do |t|
+      t.cucumber_opts = "--format pretty"
+      t.profile = name
+    end
+  end
+  
+  add_task :mysql,      "Run feature-set against MySQL"
+  add_task :postgresql, "Run feature-set against PostgreSQL"
+  add_task :oracle,     "Run feature-set against Oracle"
+  add_task :sqlite3,    "Run feature-set against SQLite3"
+end
+
+desc "Generate RCov reports"
+Spec::Rake::SpecTask.new(:rcov) do |t|
+  t.libs << 'lib'
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec', '--exclude', 'gems', '--exclude', 'riddle']
+end
+
+namespace :rcov do
+  def add_task(name, description)
+    Cucumber::Rake::Task.new(name, description) do |t|
+      t.cucumber_opts = "--format pretty"
+      t.profile = name
+      t.rcov = true
+      t.rcov_opts = [
+        '--exclude', 'spec',
+        '--exclude', 'gems',
+        '--exclude', 'riddle',
+        '--exclude', 'features'
+      ]
+    end
+  end
+  
+  add_task :mysql,      "Run feature-set against MySQL with rcov"
+  add_task :postgresql, "Run feature-set against PostgreSQL with rcov"
+  add_task :oracle,     "Run feature-set against Oracle with rcov"
+  add_task :sqlite3,    "Run feature-set against SQLite3 with rcov"
+end
+
+desc "Build cucumber.yml file"
+task :cucumber_defaults do
+  default_requires = %w(
+    --require features/support/env.rb
+    --require features/support/db/mysql.rb
+    --require features/support/db/active_record.rb
+    --require features/support/post_database.rb
+  ).join(" ")
+  
+  step_definitions = FileList["features/step_definitions/**.rb"].collect { |path|
+    "--require #{path}"
+  }.join(" ")
+  
+  features = FileList["features/*.feature"].join(" ")
+  
+  File.open('cucumber.yml', 'w') { |f|
+    f.write "default: \"#{default_requires} #{step_definitions}\"\n\n"
+    f.write "mysql: \"#{default_requires} #{step_definitions} #{features}\"\n\n"
+    f.write "postgresql: \"#{default_requires.gsub(/mysql/, 'postgresql')} #{step_definitions} #{features}\"\n\n"
+    f.write "oracle: \"#{default_requires.gsub(/mysql/, 'oracle')} #{step_definitions} #{features}\"\n\n"
+    f.write "sqlite3: \"#{default_requires.gsub(/mysql/, 'sqlite3')} #{step_definitions} #{features}\"\n\n"
+  }
+end
+
+namespace :thinking_sphinx do
+  # "Append testing enviroment settings to app_env task for xmlpipe support"
+  task :app_env do
+    # Establish DB connection
+    if ENV['DATABASE']
+      database = ENV['DATABASE'].to_s.sub(/jdbc|_enhanced/, '')
+      require "features/support/db/#{database}"
+      require "features/support/db/active_record"
+      # Load Models
+      Dir["features/support/models/*.rb"].sort.each do |file|
+        require file.gsub(/\.rb$/, '')
+      end
+    end
+  end
+end

data/vendor/after_commit/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Nick Muerdter
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/after_commit/README

@@ -0,0 +1,16 @@
+after_commit
+===========
+
+A Ruby on Rails plugin to add after_commit callbacks. The callbacks that are provided can be used
+to trigger events that run only after the entire transaction is complete. This is beneficial
+in situations where you are doing asynchronous processing and need committed objects.
+
+The following callbacks are provided:
+  
+   * (1) after_commit
+   * (2) after_commit_on_create
+   * (3) after_commit_on_update
+   * (4) after_commit_on_destroy
+   
+The after_commit callback is run for any object that has just been committed. You can obtain finer
+callback control by using the additional <tt>after_commit_on_*</tt> callbacks.

data/vendor/after_commit/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the after_commit plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the after_commit plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'AfterCommit'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/vendor/after_commit/init.rb

@@ -0,0 +1,8 @@
+ActiveRecord::Base.send(:include, AfterCommit::ActiveRecord)
+
+Object.subclasses_of(ActiveRecord::ConnectionAdapters::AbstractAdapter).each do |klass|
+  klass.send(:include, AfterCommit::ConnectionAdapters)
+end
+if defined?(JRUBY_VERSION) and defined?(JdbcSpec::MySQL)
+  JdbcSpec::MySQL.send :include, AfterCommit::ConnectionAdapters
+end

data/vendor/after_commit/lib/after_commit.rb

@@ -0,0 +1,45 @@
+require 'after_commit/active_record'
+require 'after_commit/connection_adapters'
+
+module AfterCommit
+  def self.committed_records
+    @@committed_records ||= []
+  end
+
+  def self.committed_records=(committed_records)
+    @@committed_records = committed_records
+  end
+  
+  def self.committed_records_on_create
+    @@committed_records_on_create ||= []
+  end
+  
+  def self.committed_records_on_create=(committed_records)
+    @@committed_records_on_create = committed_records
+  end
+  
+  def self.committed_records_on_update
+    @@committed_records_on_update ||= []
+  end
+  
+  def self.committed_records_on_update=(committed_records)
+    @@committed_records_on_update = committed_records
+  end
+  
+  def self.committed_records_on_destroy
+    @@committed_records_on_destroy ||= []
+  end
+  
+  def self.committed_records_on_destroy=(committed_records)
+    @@committed_records_on_destroy = committed_records
+  end
+end
+
+ActiveRecord::Base.send(:include, AfterCommit::ActiveRecord)
+
+Object.subclasses_of(ActiveRecord::ConnectionAdapters::AbstractAdapter).each do |klass|
+  klass.send(:include, AfterCommit::ConnectionAdapters)
+end
+if defined?(JRUBY_VERSION) and defined?(JdbcSpec::MySQL)
+  JdbcSpec::MySQL.send :include, AfterCommit::ConnectionAdapters
+end

data/vendor/after_commit/lib/after_commit/active_record.rb

@@ -0,0 +1,114 @@
+module AfterCommit
+  module ActiveRecord
+    # Based on the code found in Thinking Sphinx:
+    # http://ts.freelancing-gods.com/ which was based on code written by Eli
+    # Miller:
+    # http://elimiller.blogspot.com/2007/06/proper-cache-expiry-with-aftercommit.html
+    # with slight modification from Joost Hietbrink. And now me! Whew.
+    def self.included(base)
+      base.class_eval do
+        # The define_callbacks method was added post Rails 2.0.2 - if it
+        # doesn't exist, we define the callback manually
+        if respond_to?(:define_callbacks)
+          define_callbacks  :after_commit,
+                            :after_commit_on_create,
+                            :after_commit_on_update,
+                            :after_commit_on_destroy
+        else
+          class << self
+            # Handle after_commit callbacks - call all the registered callbacks.
+            def after_commit(*callbacks, &block)
+              callbacks << block if block_given?
+              write_inheritable_array(:after_commit, callbacks)
+            end
+            
+            def after_commit_on_create(*callbacks, &block)
+              callbacks << block if block_given?
+              write_inheritable_array(:after_commit_on_create, callbacks)
+            end
+            
+            def after_commit_on_update(*callbacks, &block)
+              callbacks << block if block_given?
+              write_inheritable_array(:after_commit_on_update, callbacks)
+            end
+            
+            def after_commit_on_destroy(*callbacks, &block)
+              callbacks << block if block_given?
+              write_inheritable_array(:after_commit_on_destroy, callbacks)
+            end
+          end
+        end
+
+        after_save    :add_committed_record
+        after_create  :add_committed_record_on_create
+        after_update  :add_committed_record_on_update
+        after_destroy :add_committed_record_on_destroy
+
+        # We need to keep track of records that have been saved or destroyed
+        # within this transaction.
+        def add_committed_record
+          AfterCommit.committed_records << self
+        end
+        
+        def add_committed_record_on_create
+          AfterCommit.committed_records_on_create << self
+        end
+        
+        def add_committed_record_on_update
+          AfterCommit.committed_records_on_update << self
+        end
+        
+        def add_committed_record_on_destroy
+          AfterCommit.committed_records << self
+          AfterCommit.committed_records_on_destroy << self
+        end
+        
+        def after_commit
+          # Deliberately blank.
+        end
+
+        # Wraps a call to the private callback method so that the the
+        # after_commit callback can be made from the ConnectionAdapters when
+        # the commit for the transaction has finally succeeded. 
+        def after_commit_callback
+          call_after_commit_callback :after_commit
+        end
+        
+        def after_commit_on_create_callback
+          call_after_commit_callback :after_commit_on_create
+        end
+        
+        def after_commit_on_update_callback
+          call_after_commit_callback :after_commit_on_update
+        end
+        
+        def after_commit_on_destroy_callback
+          call_after_commit_callback :after_commit_on_destroy
+        end
+        
+        private
+        
+        def call_after_commit_callback(call)
+          if can_call_after_commit call
+            callback call
+            clear_after_commit_call call
+          end
+        end
+        
+        def can_call_after_commit(call)
+          @calls ||= {}
+          @calls[call] ||= false
+          if @calls[call]
+            return false
+          else
+            @calls[call] = true
+          end
+        end
+        
+        def clear_after_commit_call(call)
+          @calls[call] = false
+        end
+      end
+    end
+  end
+end

data/vendor/after_commit/lib/after_commit/connection_adapters.rb

@@ -0,0 +1,103 @@
+module AfterCommit
+  module ConnectionAdapters
+    def self.included(base)
+      base.class_eval do
+        # The commit_db_transaction method gets called when the outermost
+        # transaction finishes and everything inside commits. We want to
+        # override it so that after this happens, any records that were saved
+        # or destroyed within this transaction now get their after_commit
+        # callback fired.
+        def commit_db_transaction_with_callback
+          commit_db_transaction_without_callback
+          trigger_after_commit_callbacks
+          trigger_after_commit_on_create_callbacks
+          trigger_after_commit_on_update_callbacks
+          trigger_after_commit_on_destroy_callbacks
+        end 
+        alias_method_chain :commit_db_transaction, :callback
+
+        # In the event the transaction fails and rolls back, nothing inside
+        # should recieve the after_commit callback.
+        def rollback_db_transaction_with_callback
+          rollback_db_transaction_without_callback
+
+          AfterCommit.committed_records = []
+          AfterCommit.committed_records_on_create = []
+          AfterCommit.committed_records_on_update = []
+          AfterCommit.committed_records_on_destroy = []
+        end
+        alias_method_chain :rollback_db_transaction, :callback
+        
+        protected        
+          def trigger_after_commit_callbacks
+            # Trigger the after_commit callback for each of the committed
+            # records.
+            if AfterCommit.committed_records.any?
+              AfterCommit.committed_records.each do |record|
+                begin
+                  record.after_commit_callback
+                rescue
+                end
+              end 
+            end 
+
+            # Make sure we clear out our list of committed records now that we've
+            # triggered the callbacks for each one. 
+            AfterCommit.committed_records = []
+          end
+        
+          def trigger_after_commit_on_create_callbacks
+            # Trigger the after_commit_on_create callback for each of the committed
+            # records.
+            if AfterCommit.committed_records_on_create.any?
+              AfterCommit.committed_records_on_create.each do |record|
+                begin
+                  record.after_commit_on_create_callback
+                rescue
+                end
+              end 
+            end 
+
+            # Make sure we clear out our list of committed records now that we've
+            # triggered the callbacks for each one. 
+            AfterCommit.committed_records_on_create = []
+          end
+        
+          def trigger_after_commit_on_update_callbacks
+            # Trigger the after_commit_on_update callback for each of the committed
+            # records.
+            if AfterCommit.committed_records_on_update.any?
+              AfterCommit.committed_records_on_update.each do |record|
+                begin
+                  record.after_commit_on_update_callback
+                rescue
+                end
+              end 
+            end 
+
+            # Make sure we clear out our list of committed records now that we've
+            # triggered the callbacks for each one. 
+            AfterCommit.committed_records_on_update = []
+          end
+        
+          def trigger_after_commit_on_destroy_callbacks
+            # Trigger the after_commit_on_destroy callback for each of the committed
+            # records.
+            if AfterCommit.committed_records_on_destroy.any?
+              AfterCommit.committed_records_on_destroy.each do |record|
+                begin
+                  record.after_commit_on_destroy_callback
+                rescue
+                end
+              end 
+            end 
+
+            # Make sure we clear out our list of committed records now that we've
+            # triggered the callbacks for each one. 
+            AfterCommit.committed_records_on_destroy = []
+          end
+        #end protected
+      end 
+    end 
+  end
+end