delayed_job_active_record 4.0.1 → 4.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 82f721fcfca5c638b74b7fb452ec3c18cac88c28
-  data.tar.gz: 57081f4124787944eee874326349f48d4fbdf7fa
+  metadata.gz: 0ba9b64dfebf36a3cc8248ff10fff63af3a8b611
+  data.tar.gz: 506aba7854d7c39aa711c54e38c7a87e2fd7c00d
 SHA512:
-  metadata.gz: 34e1dadd821019d0b14b69bde6266192b74f018ae97141cf6754bfe5fb201b838ee295698dff925583e8c2808790f73ca94832a6c32797f3a1b6b3cff44e0fe6
-  data.tar.gz: 5c7866cc0d33e46433dff9d60444e046edf0fe0555cc9a114ec7a8aa517a61c19add09eac0b1334126450b0d97debd10276dee06916a531a7f29cb998a02d52e
+  metadata.gz: 7f1b5ad0fa88e075b988d4234654cfdbc0e63e8a32344d8cb1824ef7562f88b1aa7ad63952e3176df823daac164fda2bf34692735062961cb59896d10f0dec72
+  data.tar.gz: a4621ce576f0d7fb0458ccd3aa396ad79a5f5bd7ef85440c6aead1fcb8b6b11d11bc5610042b7da72f909a6fd5efeae0c1676427a80233d1d66cdc88a0f273e2

data/Rakefile

@@ -1,10 +1,10 @@
 # -*- encoding: utf-8 -*-
-require "bundler/gem_helper"
+require 'bundler/gem_helper'
 Bundler::GemHelper.install_tasks
 
-require "rspec/core/rake_task"
+require 'rspec/core/rake_task'
 
-ADAPTERS = %w(mysql postgresql sqlite3)
+ADAPTERS = %w[mysql postgresql sqlite3]
 
 ADAPTERS.each do |adapter|
   desc "Run RSpec code examples for #{adapter} adapter"
@@ -12,24 +12,27 @@ ADAPTERS.each do |adapter|
 
   namespace adapter do
     task :adapter do
-      ENV["ADAPTER"] = adapter
+      ENV['ADAPTER'] = adapter
     end
   end
 end
 
 task :coverage do
-  ENV["COVERAGE"] = "true"
+  ENV['COVERAGE'] = 'true'
 end
 
 task :adapter do
-  ENV["ADAPTER"] = nil
+  ENV['ADAPTER'] = nil
 end
 
 Rake::Task[:spec].enhance do
-  require "simplecov"
-  require "coveralls"
+  require 'simplecov'
+  require 'coveralls'
 
   Coveralls::SimpleCov::Formatter.new.format(SimpleCov.result)
 end
 
-task default: ([:coverage] + ADAPTERS + [:adapter])
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new
+
+task :default => ([:coverage] + ADAPTERS + [:adapter] + [:rubocop])

data/delayed_job_active_record.gemspec

@@ -1,19 +1,19 @@
 # coding: utf-8
 
 Gem::Specification.new do |spec|
-  spec.add_dependency   'activerecord', ['>= 3.0', '< 4.2']
-  spec.add_dependency   'delayed_job',  ['>= 3.0', '< 4.1']
-  spec.authors        = ["Brian Ryckbost", "Matt Griffin", "Erik Michaels-Ober"]
+  spec.add_dependency 'activerecord', ['>= 3.0', '< 4.2']
+  spec.add_dependency 'delayed_job',  ['>= 3.0', '< 4.1']
+  spec.authors        = ['Brian Ryckbost', 'Matt Griffin', 'Erik Michaels-Ober']
   spec.description    = 'ActiveRecord backend for Delayed::Job, originally authored by Tobias Lütke'
   spec.email          = ['bryckbost@gmail.com', 'matt@griffinonline.org', 'sferik@gmail.com']
-  spec.files          = %w(CONTRIBUTING.md LICENSE.md README.md Rakefile delayed_job_active_record.gemspec)
-  spec.files         += Dir.glob("lib/**/*.rb")
-  spec.files         += Dir.glob("spec/**/*")
+  spec.files          = %w[CONTRIBUTING.md LICENSE.md README.md Rakefile delayed_job_active_record.gemspec]
+  spec.files         += Dir.glob('lib/**/*.rb')
+  spec.files         += Dir.glob('spec/**/*')
   spec.homepage       = 'http://github.com/collectiveidea/delayed_job_active_record'
   spec.licenses       = ['MIT']
   spec.name           = 'delayed_job_active_record'
   spec.require_paths  = ['lib']
   spec.summary        = 'ActiveRecord backend for DelayedJob'
-  spec.test_files     = Dir.glob("spec/**/*")
-  spec.version        = '4.0.1'
+  spec.test_files     = Dir.glob('spec/**/*')
+  spec.version        = '4.0.2'
 end

data/lib/delayed/backend/active_record.rb

@@ -21,7 +21,7 @@ module Delayed
           self.table_name = delayed_job_table_name
         end
 
-        self.set_delayed_job_table_name
+        set_delayed_job_table_name
 
         def self.ready_to_run(worker_name, max_run_time)
           where('(run_at <= ? AND (locked_at IS NULL OR locked_at < ?) OR locked_by = ?) AND failed_at IS NULL', db_time_now, db_time_now - max_run_time, worker_name)
@@ -40,9 +40,9 @@ module Delayed
           where(:locked_by => worker_name).update_all(:locked_by => nil, :locked_at => nil)
         end
 
-        def self.reserve(worker, max_run_time = Worker.max_run_time)
+        def self.reserve(worker, max_run_time = Worker.max_run_time) # rubocop:disable CyclomaticComplexity
           # scope to filter to records that are "ready to run"
-          ready_scope = self.ready_to_run(worker.name, max_run_time)
+          ready_scope = ready_to_run(worker.name, max_run_time)
 
           # scope to filter to the single next eligible job
           ready_scope = ready_scope.where('priority >= ?', Worker.min_priority) if Worker.min_priority
@@ -50,41 +50,47 @@ module Delayed
           ready_scope = ready_scope.where(:queue => Worker.queues) if Worker.queues.any?
           ready_scope = ready_scope.by_priority
 
-          now = self.db_time_now
+          reserve_with_scope(ready_scope, worker, db_time_now)
+        end
 
+        def self.reserve_with_scope(ready_scope, worker, now)
           # Optimizations for faster lookups on some common databases
-          case self.connection.adapter_name
-          when "PostgreSQL"
+          case connection.adapter_name
+          when 'PostgreSQL'
             # Custom SQL required for PostgreSQL because postgres does not support UPDATE...LIMIT
             # This locks the single record 'FOR UPDATE' in the subquery (http://www.postgresql.org/docs/9.0/static/sql-select.html#SQL-FOR-UPDATE-SHARE)
             # Note: active_record would attempt to generate UPDATE...LIMIT like sql for postgres if we use a .limit() filter, but it would not use
             # 'FOR UPDATE' and we would have many locking conflicts
-            quoted_table_name = self.connection.quote_table_name(self.table_name)
+            quoted_table_name = connection.quote_table_name(table_name)
             subquery_sql      = ready_scope.limit(1).lock(true).select('id').to_sql
-            reserved          = self.find_by_sql(["UPDATE #{quoted_table_name} SET locked_at = ?, locked_by = ? WHERE id IN (#{subquery_sql}) RETURNING *", now, worker.name])
+            reserved          = find_by_sql(["UPDATE #{quoted_table_name} SET locked_at = ?, locked_by = ? WHERE id IN (#{subquery_sql}) RETURNING *", now, worker.name])
             reserved[0]
-          when "MySQL", "Mysql2"
+          when 'MySQL', 'Mysql2'
             # This works on MySQL and possibly some other DBs that support UPDATE...LIMIT. It uses separate queries to lock and return the job
             count = ready_scope.limit(1).update_all(:locked_at => now, :locked_by => worker.name)
             return nil if count == 0
-            self.where(:locked_at => now, :locked_by => worker.name, :failed_at => nil).first
-          when "MSSQL", "Teradata"
+            where(:locked_at => now, :locked_by => worker.name, :failed_at => nil).first
+          when 'MSSQL', 'Teradata'
             # The MSSQL driver doesn't generate a limit clause when update_all is called directly
             subsubquery_sql = ready_scope.limit(1).to_sql
             # select("id") doesn't generate a subquery, so force a subquery
             subquery_sql = "SELECT id FROM (#{subsubquery_sql}) AS x"
-            quoted_table_name = self.connection.quote_table_name(self.table_name)
+            quoted_table_name = connection.quote_table_name(table_name)
             sql = ["UPDATE #{quoted_table_name} SET locked_at = ?, locked_by = ? WHERE id IN (#{subquery_sql})", now, worker.name]
-            count = self.connection.execute(sanitize_sql(sql))
+            count = connection.execute(sanitize_sql(sql))
             return nil if count == 0
             # MSSQL JDBC doesn't support OUTPUT INSERTED.* for returning a result set, so query locked row
-            self.where(:locked_at => now, :locked_by => worker.name, :failed_at => nil).first
+            where(:locked_at => now, :locked_by => worker.name, :failed_at => nil).first
           else
-            # This is our old fashion, tried and true, but slower lookup
-            ready_scope.limit(worker.read_ahead).detect do |job|
-              count = ready_scope.where(:id => job.id).update_all(:locked_at => now, :locked_by => worker.name)
-              count == 1 && job.reload
-            end
+            reserve_with_scope_using_default_sql(ready_scope, worker, now)
+          end
+        end
+
+        def self.reserve_with_scope_using_default_sql(ready_scope, worker, now)
+          # This is our old fashion, tried and true, but slower lookup
+          ready_scope.limit(worker.read_ahead).detect do |job|
+            count = ready_scope.where(:id => job.id).update_all(:locked_at => now, :locked_by => worker.name)
+            count == 1 && job.reload
           end
         end
 

data/lib/generators/delayed_job/active_record_generator.rb

@@ -9,13 +9,13 @@ module DelayedJob
     include Rails::Generators::Migration
     extend NextMigrationVersion
 
-    self.source_paths << File.join(File.dirname(__FILE__), 'templates')
+    source_paths << File.join(File.dirname(__FILE__), 'templates')
 
     def create_migration_file
       migration_template 'migration.rb', 'db/migrate/create_delayed_jobs.rb'
     end
 
-    def self.next_migration_number dirname
+    def self.next_migration_number(dirname)
       ActiveRecord::Generators::Base.next_migration_number dirname
     end
   end

data/lib/generators/delayed_job/next_migration_version.rb

@@ -5,9 +5,9 @@ module DelayedJob
     def next_migration_number(dirname)
       next_migration_number = current_migration_number(dirname) + 1
       if ActiveRecord::Base.timestamped_migrations
-        [Time.now.utc.strftime("%Y%m%d%H%M%S"), "%.14d" % next_migration_number].max
+        [Time.now.utc.strftime('%Y%m%d%H%M%S'), format('%.14d', next_migration_number)].max
       else
-        "%.3d" % next_migration_number
+        format('%.3d', next_migration_number)
       end
     end
   end

data/lib/generators/delayed_job/templates/migration.rb

@@ -1,15 +1,15 @@
 class CreateDelayedJobs < ActiveRecord::Migration
   def self.up
     create_table :delayed_jobs, :force => true do |table|
-      table.integer  :priority, :default => 0, :null => false # Allows some jobs to jump to the front of the queue
-      table.integer  :attempts, :default => 0, :null => false # Provides for retries, but still fail eventually.
-      table.text     :handler, :null => false                 # YAML-encoded string of the object that will do work
-      table.text     :last_error                              # reason for last failure (See Note below)
-      table.datetime :run_at                                  # When to run. Could be Time.zone.now for immediately, or sometime in the future.
-      table.datetime :locked_at                               # Set when a client is working on this object
-      table.datetime :failed_at                               # Set when all retries have failed (actually, by default, the record is deleted instead)
-      table.string   :locked_by                               # Who is working on this object (if locked)
-      table.string   :queue                                   # The name of the queue this job is in
+      table.integer :priority, :default => 0, :null => false # Allows some jobs to jump to the front of the queue
+      table.integer :attempts, :default => 0, :null => false # Provides for retries, but still fail eventually.
+      table.text :handler, :null => false                    # YAML-encoded string of the object that will do work
+      table.text :last_error                                 # reason for last failure (See Note below)
+      table.datetime :run_at                                 # When to run. Could be Time.zone.now for immediately, or sometime in the future.
+      table.datetime :locked_at                              # Set when a client is working on this object
+      table.datetime :failed_at                              # Set when all retries have failed (actually, by default, the record is deleted instead)
+      table.string :locked_by                                # Who is working on this object (if locked)
+      table.string :queue                                    # The name of the queue this job is in
       table.timestamps
     end
 

data/lib/generators/delayed_job/upgrade_generator.rb

@@ -9,13 +9,13 @@ module DelayedJob
     include Rails::Generators::Migration
     extend NextMigrationVersion
 
-    self.source_paths << File.join(File.dirname(__FILE__), 'templates')
+    source_paths << File.join(File.dirname(__FILE__), 'templates')
 
     def create_migration_file
       migration_template 'upgrade_migration.rb', 'db/migrate/add_queue_to_delayed_jobs.rb'
     end
 
-    def self.next_migration_number dirname
+    def self.next_migration_number(dirname)
       ActiveRecord::Generators::Base.next_migration_number dirname
     end
   end

data/spec/delayed/backend/active_record_spec.rb

@@ -4,39 +4,59 @@ require 'delayed/backend/active_record'
 describe Delayed::Backend::ActiveRecord::Job do
   it_behaves_like 'a delayed_job backend'
 
-  context "db_time_now" do
+  describe "reserve_with_scope" do
+    let(:worker) { double(name: "worker01", read_ahead: 1) }
+    let(:scope)  { double(limit: limit, where: double(update_all: nil)) }
+    let(:limit)  { double(job: job) }
+    let(:job)    { double(id: 1) }
+
+    before do
+      allow(Delayed::Backend::ActiveRecord::Job.connection).to receive(:adapter_name).at_least(:once).and_return(dbms)
+    end
+
+    context "for a dbms without a specific implementation" do
+      let(:dbms) { "OtherDB" }
+
+      it "uses the plain sql version" do
+        expect(Delayed::Backend::ActiveRecord::Job).to receive(:reserve_with_scope_using_default_sql).once
+        Delayed::Backend::ActiveRecord::Job.reserve_with_scope(scope, worker, Time.now)
+      end
+    end
+  end
+
+  context 'db_time_now' do
     after do
       Time.zone = nil
       ActiveRecord::Base.default_timezone = :local
     end
 
-    it "returns time in current time zone if set" do
+    it 'returns time in current time zone if set' do
       Time.zone = 'Eastern Time (US & Canada)'
       expect(%(EST EDT)).to include(Delayed::Job.db_time_now.zone)
     end
 
-    it "returns UTC time if that is the AR default" do
+    it 'returns UTC time if that is the AR default' do
       Time.zone = nil
       ActiveRecord::Base.default_timezone = :utc
       expect(Delayed::Backend::ActiveRecord::Job.db_time_now.zone).to eq 'UTC'
     end
 
-    it "returns local time if that is the AR default" do
+    it 'returns local time if that is the AR default' do
       Time.zone = 'Central Time (US & Canada)'
       ActiveRecord::Base.default_timezone = :local
-      expect(%w(CST CDT)).to include(Delayed::Backend::ActiveRecord::Job.db_time_now.zone)
+      expect(%w[CST CDT]).to include(Delayed::Backend::ActiveRecord::Job.db_time_now.zone)
     end
   end
 
-  describe "after_fork" do
-    it "calls reconnect on the connection" do
-      ActiveRecord::Base.should_receive(:establish_connection)
+  describe 'after_fork' do
+    it 'calls reconnect on the connection' do
+      allow(ActiveRecord::Base).to receive(:establish_connection)
       Delayed::Backend::ActiveRecord::Job.after_fork
     end
   end
 
-  describe "enqueue" do
-    it "allows enqueue hook to modify job at DB level" do
+  describe 'enqueue' do
+    it 'allows enqueue hook to modify job at DB level' do
       later = described_class.db_time_now + 20.minutes
       job = Delayed::Backend::ActiveRecord::Job.enqueue :payload_object => EnqueueJobMod.new
       expect(Delayed::Backend::ActiveRecord::Job.find(job.id).run_at).to be_within(1).of(later)
@@ -44,7 +64,7 @@ describe Delayed::Backend::ActiveRecord::Job do
   end
 
   if ::ActiveRecord::VERSION::MAJOR < 4 || defined?(::ActiveRecord::MassAssignmentSecurity)
-    context "ActiveRecord::Base.send(:attr_accessible, nil)" do
+    context 'ActiveRecord::Base.send(:attr_accessible, nil)' do
       before do
         Delayed::Backend::ActiveRecord::Job.send(:attr_accessible, nil)
       end
@@ -53,14 +73,14 @@ describe Delayed::Backend::ActiveRecord::Job do
         Delayed::Backend::ActiveRecord::Job.send(:attr_accessible, *Delayed::Backend::ActiveRecord::Job.new.attributes.keys)
       end
 
-      it "is still accessible" do
+      it 'is still accessible' do
         job = Delayed::Backend::ActiveRecord::Job.enqueue :payload_object => EnqueueJobMod.new
         expect(Delayed::Backend::ActiveRecord::Job.find(job.id).handler).to_not be_blank
       end
     end
   end
 
-  context "ActiveRecord::Base.table_name_prefix" do
+  context 'ActiveRecord::Base.table_name_prefix' do
     it "when prefix is not set, use 'delayed_jobs' as table name" do
       ::ActiveRecord::Base.table_name_prefix = nil
       Delayed::Backend::ActiveRecord::Job.set_delayed_job_table_name
@@ -68,7 +88,7 @@ describe Delayed::Backend::ActiveRecord::Job do
       expect(Delayed::Backend::ActiveRecord::Job.table_name).to eq 'delayed_jobs'
     end
 
-    it "when prefix is set, prepend it before default table name" do
+    it 'when prefix is set, prepend it before default table name' do
       ::ActiveRecord::Base.table_name_prefix = 'custom_'
       Delayed::Backend::ActiveRecord::Job.set_delayed_job_table_name
 

data/spec/delayed/serialization/active_record_spec.rb

@@ -1,15 +1,15 @@
 require 'helper'
 
 describe ActiveRecord do
-  it "loads classes with non-default primary key" do
-    expect {
+  it 'loads classes with non-default primary key' do
+    expect do
       YAML.load(Story.create.to_yaml)
-    }.not_to raise_error
+    end.not_to raise_error
   end
 
-  it "loads classes even if not in default scope" do
-    expect {
+  it 'loads classes even if not in default scope' do
+    expect do
       YAML.load(Story.create(:scoped => false).to_yaml)
-    }.not_to raise_error
+    end.not_to raise_error
   end
 end

data/spec/helper.rb

@@ -3,16 +3,20 @@ require 'coveralls'
 
 SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
     SimpleCov::Formatter::HTMLFormatter,
-      Coveralls::SimpleCov::Formatter
+    Coveralls::SimpleCov::Formatter
 ]
-SimpleCov.start
+
+SimpleCov.start do
+  add_filter '/spec/'
+  minimum_coverage(73.33)
+end
 
 require 'logger'
 require 'rspec'
 
 begin
   require 'protected_attributes'
-rescue LoadError
+rescue LoadError # rubocop:disable HandleExceptions
 end
 require 'delayed_job_active_record'
 require 'delayed/backend/shared_spec'
@@ -20,8 +24,8 @@ require 'delayed/backend/shared_spec'
 Delayed::Worker.logger = Logger.new('/tmp/dj.log')
 ENV['RAILS_ENV'] = 'test'
 
-db_adapter, gemfile = ENV["ADAPTER"], ENV["BUNDLE_GEMFILE"]
-db_adapter ||= gemfile && gemfile[%r(gemfiles/(.*?)/)] && $1
+db_adapter, gemfile = ENV['ADAPTER'], ENV['BUNDLE_GEMFILE']
+db_adapter ||= gemfile && gemfile[%r{gemfiles/(.*?)/}] && $1 # rubocop:disable PerlBackrefs
 db_adapter ||= 'sqlite3'
 
 config = YAML.load(File.read('spec/database.yml'))
@@ -31,15 +35,15 @@ ActiveRecord::Migration.verbose = false
 
 ActiveRecord::Schema.define do
   create_table :delayed_jobs, :force => true do |table|
-    table.integer  :priority, :default => 0
-    table.integer  :attempts, :default => 0
-    table.text     :handler
-    table.text     :last_error
+    table.integer :priority, :default => 0
+    table.integer :attempts, :default => 0
+    table.text :handler
+    table.text :last_error
     table.datetime :run_at
     table.datetime :locked_at
     table.datetime :failed_at
-    table.string   :locked_by
-    table.string   :queue
+    table.string :locked_by
+    table.string :queue
     table.timestamps
   end
 
@@ -58,8 +62,13 @@ class Story < ActiveRecord::Base
   else
     self.primary_key = :story_id
   end
-  def tell; text; end
-  def whatever(n, _); tell*n; end
+  def tell
+    text
+  end
+
+  def whatever(n, _)
+    tell * n
+  end
   default_scope { where(:scoped => true) }
 
   handle_asynchronously :whatever

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: delayed_job_active_record
 version: !ruby/object:Gem::Version
-  version: 4.0.1
+  version: 4.0.2
 platform: ruby
 authors:
 - Brian Ryckbost
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-12 00:00:00.000000000 Z
+date: 2014-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -98,7 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.1
 signing_key: 
 specification_version: 4
 summary: ActiveRecord backend for DelayedJob