warp-thinking-sphinx 1.2.12 → 1.3.10

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

@@ -1,103 +0,0 @@
-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

data/vendor/after_commit/test/after_commit_test.rb

@@ -1,53 +0,0 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
-require 'test/unit'
-require 'rubygems'
-require 'activerecord'
-require 'after_commit'
-require 'after_commit/active_record'
-require 'after_commit/connection_adapters'
-
-ActiveRecord::Base.establish_connection({"adapter" => "sqlite3", "database" => 'test.sqlite3'})
-begin
-  ActiveRecord::Base.connection.execute("drop table mock_records");
-rescue
-end
-ActiveRecord::Base.connection.execute("create table mock_records(id int)");
-
-require File.dirname(__FILE__) + '/../init.rb'
-
-class MockRecord < ActiveRecord::Base
-  attr_accessor :after_commit_on_create_called
-  attr_accessor :after_commit_on_update_called
-  attr_accessor :after_commit_on_destroy_called
-
-  after_commit_on_create :do_create
-  def do_create
-    self.after_commit_on_create_called = true
-  end
-
-  after_commit_on_update :do_update
-  def do_update
-    self.after_commit_on_update_called = true
-  end
-
-  after_commit_on_create :do_destroy
-  def do_destroy
-    self.after_commit_on_destroy_called = true
-  end
-end
-
-class AfterCommitTest < Test::Unit::TestCase
-  def test_after_commit_on_create_is_called
-    assert_equal true, MockRecord.create!.after_commit_on_create_called
-  end
-
-  def test_after_commit_on_update_is_called
-    record = MockRecord.create!
-    record.save
-    assert_equal true, record.after_commit_on_update_called
-  end
-
-  def test_after_commit_on_destroy_is_called
-    assert_equal true, MockRecord.create!.destroy.after_commit_on_destroy_called
-  end
-end

data/vendor/delayed_job/lib/delayed/job.rb

@@ -1,251 +0,0 @@
-module Delayed
-
-  class DeserializationError < StandardError
-  end
-
-  class Job < ActiveRecord::Base
-    MAX_ATTEMPTS = 25
-    MAX_RUN_TIME = 4.hours
-    set_table_name :delayed_jobs
-
-    # By default failed jobs are destroyed after too many attempts.
-    # If you want to keep them around (perhaps to inspect the reason
-    # for the failure), set this to false.
-    cattr_accessor :destroy_failed_jobs
-    self.destroy_failed_jobs = true
-
-    # Every worker has a unique name which by default is the pid of the process.
-    # There are some advantages to overriding this with something which survives worker retarts:
-    # Workers can safely resume working on tasks which are locked by themselves. The worker will assume that it crashed before.
-    cattr_accessor :worker_name
-    self.worker_name = "host:#{Socket.gethostname} pid:#{Process.pid}" rescue "pid:#{Process.pid}"
-
-    NextTaskSQL         = '(run_at <= ? AND (locked_at IS NULL OR locked_at < ?) OR (locked_by = ?)) AND failed_at IS NULL'
-    NextTaskOrder       = 'priority DESC, run_at ASC'
-
-    ParseObjectFromYaml = /\!ruby\/\w+\:([^\s]+)/
-
-    cattr_accessor :min_priority, :max_priority
-    self.min_priority = nil
-    self.max_priority = nil
-
-    class LockError < StandardError
-    end
-
-    def self.clear_locks!
-      update_all("locked_by = null, locked_at = null", ["locked_by = ?", worker_name])
-    end
-
-    def failed?
-      failed_at
-    end
-    alias_method :failed, :failed?
-
-    def payload_object
-      @payload_object ||= deserialize(self['handler'])
-    end
-
-    def name
-      @name ||= begin
-        payload = payload_object
-        if payload.respond_to?(:display_name)
-          payload.display_name
-        else
-          payload.class.name
-        end
-      end
-    end
-
-    def payload_object=(object)
-      self['handler'] = object.to_yaml
-    end
-
-    def reschedule(message, backtrace = [], time = nil)
-      if self.attempts < MAX_ATTEMPTS
-        time ||= Job.db_time_now + (attempts ** 4) + 5
-
-        self.attempts    += 1
-        self.run_at       = time
-        self.last_error   = message + "\n" + backtrace.join("\n")
-        self.unlock
-        save!
-      else
-        logger.info "* [JOB] PERMANENTLY removing #{self.name} because of #{attempts} consequetive failures."
-        destroy_failed_jobs ? destroy : update_attribute(:failed_at, Time.now)
-      end
-    end
-
-    def self.enqueue(*args, &block)
-      object = block_given? ? EvaledJob.new(&block) : args.shift
-
-      unless object.respond_to?(:perform) || block_given?
-        raise ArgumentError, 'Cannot enqueue items which do not respond to perform'
-      end
-    
-      priority = args[0] || 0
-      run_at   = args[1]
-
-      Job.create(:payload_object => object, :priority => priority.to_i, :run_at => run_at)
-    end
-
-    def self.find_available(limit = 5, max_run_time = MAX_RUN_TIME)
-
-      time_now = db_time_now
-
-      sql = NextTaskSQL.dup
-
-      conditions = [time_now, time_now - max_run_time, worker_name]
-
-      if self.min_priority
-        sql << ' AND (priority >= ?)'
-        conditions << min_priority
-      end
-
-      if self.max_priority
-        sql << ' AND (priority <= ?)'
-        conditions << max_priority
-      end
-
-      conditions.unshift(sql)
-
-      records = ActiveRecord::Base.silence do
-        find(:all, :conditions => conditions, :order => NextTaskOrder, :limit => limit)
-      end
-
-      records.sort_by { rand() }
-    end
-
-    # Get the payload of the next job we can get an exclusive lock on.
-    # If no jobs are left we return nil
-    def self.reserve(max_run_time = MAX_RUN_TIME, &block)
-
-      # We get up to 5 jobs from the db. In face we cannot get exclusive access to a job we try the next.
-      # this leads to a more even distribution of jobs across the worker processes
-      find_available(5, max_run_time).each do |job|
-        begin
-          logger.info "* [JOB] aquiring lock on #{job.name}"
-          job.lock_exclusively!(max_run_time, worker_name)
-          runtime =  Benchmark.realtime do
-            invoke_job(job.payload_object, &block)
-            job.destroy
-          end
-          logger.info "* [JOB] #{job.name} completed after %.4f" % runtime
-
-          return job
-        rescue LockError
-          # We did not get the lock, some other worker process must have
-          logger.warn "* [JOB] failed to aquire exclusive lock for #{job.name}"
-        rescue StandardError => e
-          job.reschedule e.message, e.backtrace
-          log_exception(job, e)
-          return job
-        end
-      end
-
-      nil
-    end
-
-    # This method is used internally by reserve method to ensure exclusive access
-    # to the given job. It will rise a LockError if it cannot get this lock.
-    def lock_exclusively!(max_run_time, worker = worker_name)
-      now = self.class.db_time_now
-      affected_rows = if locked_by != worker
-        # We don't own this job so we will update the locked_by name and the locked_at
-        self.class.update_all(["locked_at = ?, locked_by = ?", now, worker], ["id = ? and (locked_at is null or locked_at < ?)", id, (now - max_run_time.to_i)])
-      else
-        # We already own this job, this may happen if the job queue crashes.
-        # Simply resume and update the locked_at
-        self.class.update_all(["locked_at = ?", now], ["id = ? and locked_by = ?", id, worker])
-      end
-      raise LockError.new("Attempted to aquire exclusive lock failed") unless affected_rows == 1
-
-      self.locked_at    = now
-      self.locked_by    = worker
-    end
-
-    def unlock
-      self.locked_at    = nil
-      self.locked_by    = nil
-    end
-
-    # This is a good hook if you need to report job processing errors in additional or different ways
-    def self.log_exception(job, error)
-      logger.error "* [JOB] #{job.name} failed with #{error.class.name}: #{error.message} - #{job.attempts} failed attempts"
-      logger.error(error)
-    end
-
-    def self.work_off(num = 100)
-      success, failure = 0, 0
-
-      num.times do
-        job = self.reserve do |j|
-          begin
-            j.perform
-            success += 1
-          rescue
-            failure += 1
-            raise
-          end
-        end
-
-        break if job.nil?
-      end
-
-      return [success, failure]
-    end
-
-    # Moved into its own method so that new_relic can trace it.
-    def self.invoke_job(job, &block)
-      block.call(job)
-    end
-
-  private
-
-    def deserialize(source)
-      handler = YAML.load(source) rescue nil
-
-      unless handler.respond_to?(:perform)
-        if handler.nil? && source =~ ParseObjectFromYaml
-          handler_class = $1
-        end
-        attempt_to_load(handler_class || handler.class)
-        handler = YAML.load(source)
-      end
-
-      return handler if handler.respond_to?(:perform)
-
-      raise DeserializationError,
-        'Job failed to load: Unknown handler. Try to manually require the appropiate file.'
-    rescue TypeError, LoadError, NameError => e
-      raise DeserializationError,
-        "Job failed to load: #{e.message}. Try to manually require the required file."
-    end
-
-    # Constantize the object so that ActiveSupport can attempt
-    # its auto loading magic. Will raise LoadError if not successful.
-    def attempt_to_load(klass)
-       klass.constantize
-    end
-
-    def self.db_time_now
-      (ActiveRecord::Base.default_timezone == :utc) ? Time.now.utc : Time.now
-    end
-
-  protected
-
-    def before_save
-      self.run_at ||= self.class.db_time_now
-    end
-
-  end
-
-  class EvaledJob
-    def initialize
-      @job = yield
-    end
-
-    def perform
-      eval(@job)
-    end
-  end
-end

data/vendor/delayed_job/lib/delayed/message_sending.rb

@@ -1,7 +0,0 @@
-module Delayed
-  module MessageSending
-    def send_later(method, *args)
-      Delayed::Job.enqueue Delayed::PerformableMethod.new(self, method.to_sym, args)
-    end
-  end
-end

data/vendor/delayed_job/lib/delayed/performable_method.rb

@@ -1,55 +0,0 @@
-module Delayed
-  class PerformableMethod < Struct.new(:object, :method, :args)
-    CLASS_STRING_FORMAT = /^CLASS\:([A-Z][\w\:]+)$/
-    AR_STRING_FORMAT    = /^AR\:([A-Z][\w\:]+)\:(\d+)$/
-
-    def initialize(object, method, args)
-      raise NoMethodError, "undefined method `#{method}' for #{self.inspect}" unless object.respond_to?(method)
-
-      self.object = dump(object)
-      self.args   = args.map { |a| dump(a) }
-      self.method = method.to_sym
-    end
-    
-    def display_name  
-      case self.object
-      when CLASS_STRING_FORMAT then "#{$1}.#{method}"
-      when AR_STRING_FORMAT    then "#{$1}##{method}"
-      else "Unknown##{method}"
-      end      
-    end    
-
-    def perform
-      load(object).send(method, *args.map{|a| load(a)})
-    rescue ActiveRecord::RecordNotFound
-      # We cannot do anything about objects which were deleted in the meantime
-      true
-    end
-
-    private
-
-    def load(arg)
-      case arg
-      when CLASS_STRING_FORMAT then $1.constantize
-      when AR_STRING_FORMAT    then $1.constantize.find($2)
-      else arg
-      end
-    end
-
-    def dump(arg)
-      case arg
-      when Class              then class_to_string(arg)
-      when ActiveRecord::Base then ar_to_string(arg)
-      else arg
-      end
-    end
-
-    def ar_to_string(obj)
-      "AR:#{obj.class}:#{obj.id}"
-    end
-
-    def class_to_string(obj)
-      "CLASS:#{obj.name}"
-    end
-  end
-end