lev 7.0.0 → 7.0.1

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NjE5NzA3YmUwMzVmNTljMWZlMjE3MWMzNGEzODE4MjcyOTY5YWU5Zg==
-  data.tar.gz: !binary |-
-    OGVmOWM3NzViMDdlY2UwNTY0MDdmZTM1MGE1MWMyMTQ5NDc1OGRlOQ==
+SHA1:
+  metadata.gz: ef0f435c1b9d31f93f019ec4ed9a39a7f5168fd2
+  data.tar.gz: 7b20edd8fc30967cae1a66e409d42d5ec45a54dd
 SHA512:
-  metadata.gz: !binary |-
-    N2E2ZTBiYTM2M2JhNDI1YmRiMmFiMDU5Y2IxMDY0N2IxMzMwMzQ2NGY1YjFi
-    M2NmOWI5YWQyZTc3ZGU3MmFkNTk3YWE2YjZiZDgzZTJmMjI3M2Y5YThjMGI1
-    OTRjMjcyNWEyNTdlZmI2MmY5NDg5MzI4YWJmNGMwZmU2MTA3MDY=
-  data.tar.gz: !binary |-
-    ZDY5MGZiZGMwNzgxZDExZGE0Njk1ZTRiMDU0YzExYjNjZDRjNWI4NzJkZTdl
-    M2RjODNkNzUyMDYyNzUxNjYzZjhiYWNkZGEyOTJjY2RiMzFjOTY0MjFjNmEx
-    MGYzYzY5YzUzYjRkMDRkNDUyZmRhYjRjYTY4YjA0ZjNjMmVmZjE=
+  metadata.gz: c423328fc9d60a3583776a51d778c0b13252da9f3f93594a3765ed445893e12207b1fd11ac97394a64e8ca6443c478f8d2789596bf01bef40726a1644e2030de
+  data.tar.gz: 0fbf4737caa577039695222f8bf272d7c9f99aaeca9ac57116ce9be8fb139ce5ece6280c1f8fe4b2448b22d88c16a3400baf4efbf761a7011b8fb98e2f21dec9

data/README.md

@@ -432,48 +432,30 @@ end
 
 Routines run as ActiveJobs can also publish their status somewhere it can be listened to (e.g. to Redis).
 
-Routines have a `job` object and can call the following methods:
+Routines have a `status` object and can call the following methods:
 
 * `set_progress(at, out_of = nil)` sets the current progress; can either pass a float between 0.0 and 1.0 or
   a counter towards a total, e.g. `set_progress(67,212)`.
-* `queued!` Sets the job status to 'queued'
-* `working!` Sets the job status to 'working'
-* `succeeded!` Sets the job status to 'succeeded'
-* `failed!` Sets the job status to 'failed'
-* `killed!` Sets the job status to 'killed'
-* `save(hash)` Takes a hash of key value pairs and writes those keys and values to the job status; there are several reserved keys which cannot be used (and which will blow up if you try to use them)
-* `add_error(is_fatal, error)` takes a boolean and a Lev `Error` object and adds its data to an array of `errors` in the job status hash.
+* `queued!` Sets the state to 'queued'
+* `started!` Sets the state to 'working'
+* `succeeded!` Sets the state to 'succeeded'
+* `failed!` Sets the state to 'failed'
+* `killed!` Sets the state to 'killed'
+* `save(hash)` Takes a hash of key value pairs and writes those keys and values to the status; there are several reserved keys which cannot be used (and which will blow up if you try to use them)
+* `add_error(error)` takes a Lev `Error` object and adds its data to an array of `errors` in the job status hash.
 
-Routine job objects also have query methods to check if a job is in a given state, e.g. `queued?`.  `completed?` and `incomplete` convenience methods are provided as well.  A job is complete if it is failed or succeeded; incomplete if neither.  All job routines start in an `unqueued` state and will only stay there if queueing had a problem.  Scope-like class methods (e.g. `BackgroundJob.queued`) are provided to return all jobs in a given state.
+Routine status objects also have query methods to check if a status is in a given state, e.g. `queued?`.  `completed?` and `incomplete` convenience methods are provided as well.  A status is complete if it is failed or succeeded; incomplete if neither.  All job routines start in an `unqueued` state and will only stay there if queueing had a problem.  Scope-like class methods are provided to return all statuses in a given state.
 
-For plain vanilla routines not run as an active job, the job calls are no-ops.  When a routine is invoked with `perform_later`, the job object actually records the jobs to a store of your choice.  The store is configured in the Lev configuration block, e.g.:
+For plain vanilla routines not run as an active job, the status calls are no-ops.  When a routine is invoked with `perform_later`, the status object is created/found using two configuration options that must be set (if you care about the status):
 
 ```ruby
 Lev.configure do |config|
-  config.job_store = whatever
+  config.create_status_proc = ->(*) { Jobba::Status.create! }
+  config.find_status_proc = ->(id) { Jobba::Status.find!(id) }
 end
 ```
 
-The store needs to respond to the following methods:
-
-1. fetch(key)
-2. write(key, value)
-
-The default store is essentially a hash (implemented in `Lev::MemoryStore`).  Any `ActiveSupport::Cache::Store` will work.
-
-A routine's job can be retrieved with `Lev::BackgroundJob.get(uuid_here)`.  This just returns a simple hash.  Notable keys are
-
-* `'progress'` which returns the progress as a number between 0.0 and 1.0
-* `'status'` which returns one of the status strings shown above
-* `'errors'` which (if present) is an error of error hashes
-* `'id'` the UUID of the routine / job
-
-Other routine-specific keys (set with a `save` call) are also present.
-
-**Notes:**
-
-1. Don't try to write a job store that uses the ActiveRecord database, as the database changes would only be seen when the routine completes and its transaction is committed.
-2. Job killing hasn't been implemented yet, but shouldn't be too bad.  For routines run in a transaction (which are frankly the only ones you'd want to kill), we can likely kill them by raising an exception or similar to cause a rollback (will need to have good tests to prove that).
+See the [Jobba README](https://github.com/openstax/jobba) for full details on the status objects.
 
 ## Handlers
 

data/lib/lev.rb

@@ -26,12 +26,19 @@ require "lev/delegate_to_routine"
 require "lev/transaction_isolation"
 
 require 'lev/memory_store'
-require 'lev/background_job'
-require 'lev/no_background_job'
+require 'lev/null_status'
 
 module Lev
   class << self
 
+    def create_status
+      configuration.create_status_proc.call
+    end
+
+    def find_status(id)
+      configuration.find_status_proc.call(id)
+    end
+
     ###########################################################################
     #
     # Configuration machinery.
@@ -64,8 +71,8 @@ module Lev
       attr_accessor :security_transgression_error
       attr_accessor :illegal_argument_error
       attr_accessor :raise_fatal_errors
-      attr_accessor :job_store
-      attr_accessor :job_store_namespace
+      attr_accessor :create_status_proc
+      attr_accessor :find_status_proc
       attr_accessor :job_class
 
       def initialize
@@ -73,8 +80,8 @@ module Lev
         @security_transgression_error = Lev::SecurityTransgression
         @illegal_argument_error = Lev::IllegalArgument
         @raise_fatal_errors = false
-        @job_store = Lev::MemoryStore.new
-        @job_store_namespace = "lev_job"
+        @create_status_proc = ->(*) { NullStatus.new }
+        @find_status_proc = ->(*) { NullStatus.new }
         @job_class = ::ActiveJob::Base
         super
       end

data/lib/lev/active_job.rb

@@ -5,19 +5,18 @@ module Lev
         queue_as routine_class.active_job_queue
         args.push(routine_class.to_s)
 
-        # To enable tracking of this job's status, create a new BackgroundJob object
-        # and push it on to the arguments so that in `perform` it can be peeled
-        # off and handed to the routine instance.  The BackgroundJob UUID is returned
-        # so that callers can track the status.
-        job = Lev::BackgroundJob.create
-        args.push(job.id)
+        # Create a new status object and push its ID on to the arguments so that
+        # in `perform` it can be used to retrieve the status when the routine is
+        # initialized.
+        status = Lev::create_status
+        args.push(status.id)
 
         # In theory we'd mark as queued right after the call to super, but this messes
         # up when the activejob adapter runs the job right away
-        job.queued!
+        status.queued!
         super(*args, &block)
 
-        job.id
+        status.id
       end
 
       def perform(*args, &block)
@@ -25,7 +24,7 @@ module Lev
         id = args.pop
         routine_class = Kernel.const_get(args.pop)
 
-        routine_instance = routine_class.new(Lev::BackgroundJob.find!(id))
+        routine_instance = routine_class.new(Lev::find_status(id))
 
         routine_instance.call(*args, &block)
       end

data/lib/lev/error.rb

@@ -24,10 +24,6 @@ module Lev
       ErrorTranslator.translate(self)
     end
 
-    def to_s
-      inspect
-    end
-
   end
 
-end
+end

data/lib/lev/errors.rb

@@ -4,8 +4,8 @@ module Lev
   #
   class Errors < Array
 
-    def initialize(routine_job = nil, raise_fatal_errors = false)
-      @routine_job = routine_job || NoBackgroundJob.new
+    def initialize(routine_status = nil, raise_fatal_errors = false)
+      @routine_status = routine_status || NullStatus.new
       @raise_fatal_errors = raise_fatal_errors
     end
 
@@ -16,13 +16,13 @@ module Lev
       return if ignored_error_procs.any?{|proc| proc.call(error)}
       self.push(error)
 
-      routine_job.add_error(error, is_fatal: fail)
+      routine_status.add_error(error)
 
       if fail
-        routine_job.failed!
+        routine_status.failed!
 
         if raise_fatal_errors
-          # Use special FatalError type so Routine doesn't re-add job errors
+          # Use special FatalError type so Routine doesn't re-add status errors
           raise Lev::FatalError, args.to_a.map { |i| i.join(' ') }.join(' - ')
         else
           throw :fatal_errors_encountered
@@ -55,7 +55,7 @@ module Lev
 
   protected
 
-    attr_reader :routine_job
+    attr_reader :routine_status
     attr_reader :raise_fatal_errors
 
     def ignored_error_procs

data/lib/lev/null_status.rb

@@ -0,0 +1,34 @@
+class Lev::NullStatus
+  attr_reader :id
+
+  def initialize(id=nil)
+    @id = id || "null-status:#{SecureRandom.uuid}"
+    @kill_requested = false
+  end
+
+  def request_kill!
+    @kill_requested = true
+  end
+
+  def kill_requested?
+    @kill_requested
+  end
+
+  def method_missing(*args, &block)
+    nil
+  end
+
+  # Provide null object pattern methods for status setter methods called from
+  # within routines; routines should not be using other query methods to check
+  # their own status (they should know it), with the exception of `kill_requested?`
+
+  def set_progress(*); end
+  def save(*); end
+  def add_error(*); end
+
+  def queued!; end
+  def started!; end
+  def succeeded!; end
+  def failed!; end
+  def killed!; end
+end

data/lib/lev/routine.rb

@@ -265,7 +265,7 @@ module Lev
     def call(*args, &block)
       @after_transaction_blocks = []
 
-      job.working!
+      status.started!
 
       begin
         in_transaction do
@@ -284,20 +284,20 @@ module Lev
           block.call
         end
       rescue Exception => e
-        # Let exceptions escape but make sure to note the error in the job
+        # Let exceptions escape but make sure to note the error in the status
         # if not already done
         if !e.is_a?(Lev::FatalError)
           error = Error.new(code: :exception,
                             message: e.message,
                             data: e.backtrace.first)
-          job.add_error(error, is_fatal: true)
-          job.failed!
+          status.add_error(error)
+          status.failed!
         end
 
         raise e
       end
 
-      job.succeeded! if !errors?
+      status.succeeded! if !errors?
 
       result
     end
@@ -430,23 +430,20 @@ module Lev
 
     # Note that the parent may neglect to call super, leading to this method never being called.
     # Do not perform any initialization here that cannot be safely skipped
-    def initialize(job = nil)
-      # If someone cares about the job, they'll pass it in; otherwise all
-      # job updates go into the bit bucket.
-      @job = job
+    def initialize(status = nil)
+      # If someone cares about the status, they'll pass it in; otherwise all
+      # status updates go into the bit bucket.
+      @status = status || Lev::NullStatus.new
     end
 
   protected
 
     attr_writer :runner
-
-    def job
-       @job ||= Lev::NoBackgroundJob.new
-    end
+    attr_reader :status
 
     def result
       @result ||= Result.new(Outputs.new,
-                             Errors.new(job, topmost_runner.class.raise_fatal_errors?))
+                             Errors.new(status, topmost_runner.class.raise_fatal_errors?))
     end
 
     def reset_result!

data/lib/lev/version.rb

@@ -1,3 +1,3 @@
 module Lev
-  VERSION = "7.0.0"
+  VERSION = "7.0.1"
 end

data/spec/active_job_routines_spec.rb

@@ -1,6 +1,9 @@
 require 'spec_helper'
 
 RSpec.describe 'ActiveJob routines' do
+
+  before { Lev::Jobba.use_jobba }
+
   context 'default configuration' do
     class LaterRoutine
       lev_routine active_job_queue: :something_else
@@ -24,22 +27,6 @@ RSpec.describe 'ActiveJob routines' do
 
       expect(queue_name).to eq('something_else')
     end
-
-    it 'stores all the UUIDs of queued jobs' do
-      Lev.configuration.job_store.clear
-
-      job_id1 = LaterRoutine.perform_later
-
-      expect(Lev::BackgroundJob.send(:job_ids)).to eq([job_id1])
-    end
-  end
-
-  it 'does not duplicate BackgroundJobs in `all`' do
-    # Previous track_job_id implementation changed string objects in job_ids
-    # resulting in duplicate objects in `all`
-    Lev.configuration.job_store.clear
-    LaterRoutine.perform_later
-    expect(Lev::BackgroundJob.all.count).to eq 1
   end
 
   context 'exception raised' do
@@ -56,17 +43,17 @@ RSpec.describe 'ActiveJob routines' do
     end
 
     it 'lets exception escape, job is failed and has error details' do
-      Lev.configuration.job_store.clear
+      Jobba.all.delete_all!
 
       expect{
         ExceptionalRoutine.perform_later
       }.to raise_error(TypeError)
 
-      job = Lev::BackgroundJob.all.first
+      status = Jobba.all.run.to_a.first
 
-      expect(job.status).to eq Lev::BackgroundJob::STATE_FAILED
+      expect(status).to be_failed
 
-      error = job.errors.first
+      error = status.errors.first
 
       expect(error["code"]).to eq "exception"
       expect(error["message"]).to eq "howdy there"

data/spec/spec_helper.rb

@@ -21,9 +21,8 @@ RSpec.configure do |config|
   config.order = 'random'
 end
 
-
 require 'lev'
-require 'debugger'
+require 'byebug'
 
 require 'transaction_retry'
 TransactionRetry.apply_activerecord_patch

data/spec/statused_routines_spec.rb

@@ -5,166 +5,44 @@ class StatusedRoutine
 
   protected
   def exec
-    job.set_progress(9, 10)
+    status.set_progress(9, 10)
+    status.save({'hi' => 'there'})
+    fatal_error(code: 'blah', message: 'hi')
   end
 end
 
 RSpec.describe 'Statused Routines' do
-  subject(:job) { Lev::BackgroundJob.new }
+
+  before { Lev::Jobba.use_jobba }
 
   context 'in a routine' do
     it 'queues the job object on queue' do
       id = StatusedRoutine.perform_later
-      job = Lev::BackgroundJob.find(id)
+      status = Jobba::Status.find(id)
 
-      expect(job.status).to eq(Lev::BackgroundJob::STATE_QUEUED)
+      expect(status).to be_queued
     end
 
     context 'inline activejob mode' do
       before { ::ActiveJob::Base.queue_adapter = :inline }
       after { ::ActiveJob::Base.queue_adapter = :test }
 
-      it 'sets job to working when called' do
-        expect_any_instance_of(Lev::BackgroundJob).to receive(:working!)
+      it 'sets job to started when called' do
+        expect_any_instance_of(Jobba::Status).to receive(:started!)
         StatusedRoutine.perform_later
       end
 
-      it 'completes the job object on completion, returning other data' do
+      it 'completes the status object on completion, returning other data' do
         id = StatusedRoutine.perform_later
-        job = Lev::BackgroundJob.find(id)
-        expect(job.status).to eq(Lev::BackgroundJob::STATE_SUCCEEDED)
-        expect(job.progress).to eq(1.0)
+        status = Jobba::Status.find(id)
+        expect(status).to be_failed
+        expect(status.progress).to eq(0.9)
+        expect(status.errors).to contain_exactly(
+          a_hash_including({'code' => 'blah', 'message' => 'hi'})
+        )
+        expect(status.data).to eq ({'hi' => 'there'})
       end
     end
   end
 
-  describe '#save' do
-    it 'saves the hash given and writes them to the job' do
-      job.save(something: 'else')
-      expect(job.something).to eq('else')
-    end
-  end
-
-  describe '#add_error' do
-    it 'adds the error object data to the job object' do
-      errors = Lev::Error.new(code: 'bad', message: 'awful')
-      job.add_error(errors)
-      expect(job.errors).to eq([{ is_fatal: false,
-                                     code: 'bad',
-                                     message: 'awful',
-                                     data: nil }])
-    end
-  end
-
-  describe '#save' do
-    it 'prevents the use of reserved keys' do
-      expect {
-        job.save(progress: 'blocked')
-      }.to raise_error(Lev::IllegalArgument)
-
-      expect {
-        job.save(id: 'blocked')
-      }.to raise_error(Lev::IllegalArgument)
-
-      expect {
-        job.save(status: 'blocked')
-      }.to raise_error(Lev::IllegalArgument)
-
-      expect {
-        job.save(errors: 'blocked')
-      }.to raise_error(Lev::IllegalArgument)
-    end
-
-    it 'saves the hash given and writes them to the job' do
-      job.save(something: 'else')
-      expect(job).to respond_to(:something)
-      expect(job.something).to eq('else')
-    end
-  end
-
-  describe 'dynamic job setters/getters' do
-    it 'is queued' do
-      expect(job).not_to be_queued
-      job.queued!
-      expect(job).to be_queued
-    end
-
-    it 'is working' do
-      expect(job).not_to be_working
-      job.working!
-      expect(job).to be_working
-    end
-
-    it 'is succeeded' do
-      expect(job).not_to be_succeeded
-      job.succeeded!
-      expect(job).to be_succeeded
-    end
-
-    it 'is failed' do
-      expect(job).not_to be_failed
-      job.failed!
-      expect(job).to be_failed
-    end
-
-    it 'is killed' do
-      expect(job).not_to be_killed
-      job.killed!
-      expect(job).to be_killed
-    end
-
-    it 'is unknown' do
-      expect(job).to be_unknown
-    end
-  end
-
-  describe '#set_progress' do
-    it 'sets the progress key on the job object' do
-      job.set_progress(8, 10)
-      expect(job.progress).to eq(0.8)
-    end
-
-    context 'when `out_of` is supplied' do
-      it 'requires a positive `at` float or integer' do
-        expect {
-          job.set_progress(nil, 1)
-        }.to raise_error(Lev::IllegalArgument)
-
-        expect {
-          job.set_progress(-1, 1)
-        }.to raise_error(Lev::IllegalArgument)
-
-        expect {
-          job.set_progress(2, 5)
-        }.not_to raise_error
-      end
-
-      it 'requires `out_of` to be greater than `at`' do
-        expect {
-          job.set_progress(15, 8)
-        }.to raise_error(Lev::IllegalArgument)
-
-        expect {
-          job.set_progress(5, 10)
-        }.not_to raise_error
-      end
-    end
-
-    context 'without out_of specified' do
-      it 'requires `at` to be a float between 0.0 and 1.0' do
-        expect {
-          job.set_progress(1.1)
-        }.to raise_error(Lev::IllegalArgument)
-
-        expect {
-          job.set_progress(-1)
-        }.to raise_error(Lev::IllegalArgument)
-
-        expect {
-          job.set_progress(0.78)
-        }.not_to raise_error
-      end
-    end
-
-  end
 end

data/spec/support/jobba.rb

@@ -0,0 +1,13 @@
+require 'jobba'
+
+module Lev::Jobba
+
+  def self.use_jobba
+    Lev.configure do |config|
+      config.create_status_proc = ->(*) { Jobba::Status.create! }
+      config.find_status_proc = ->(id) { Jobba::Status.find!(id) }
+    end
+    true
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lev
 version: !ruby/object:Gem::Version
-  version: 7.0.0
+  version: 7.0.1
 platform: ruby
 authors:
 - JP Slavinsky
@@ -14,196 +14,210 @@ dependencies:
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.2'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.2'
 - !ruby/object:Gem::Dependency
   name: actionpack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.2'
 - !ruby/object:Gem::Dependency
   name: activejob
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: transaction_isolation
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: transaction_retry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: active_attr
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: hashie
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: debugger
+  name: byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jobba
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Ride the rails but don't touch them.
@@ -218,7 +232,6 @@ files:
 - Rakefile
 - lib/lev.rb
 - lib/lev/active_job.rb
-- lib/lev/background_job.rb
 - lib/lev/better_active_model_errors.rb
 - lib/lev/delegate_to_routine.rb
 - lib/lev/error.rb
@@ -231,7 +244,7 @@ files:
 - lib/lev/handler.rb
 - lib/lev/handler_helper.rb
 - lib/lev/memory_store.rb
-- lib/lev/no_background_job.rb
+- lib/lev/null_status.rb
 - lib/lev/object.rb
 - lib/lev/outputs.rb
 - lib/lev/routine.rb
@@ -240,7 +253,6 @@ files:
 - lib/lev/utilities.rb
 - lib/lev/version.rb
 - spec/active_job_routines_spec.rb
-- spec/background_job_spec.rb
 - spec/create_sprocket_spec.rb
 - spec/deep_merge_spec.rb
 - spec/delegates_to_spec.rb
@@ -254,6 +266,7 @@ files:
 - spec/support/create_sprocket.rb
 - spec/support/delegated_routine.rb
 - spec/support/delegating_routine.rb
+- spec/support/jobba.rb
 - spec/support/paramify_handler_a.rb
 - spec/support/paramify_handler_b.rb
 - spec/support/sprocket.rb
@@ -269,23 +282,22 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Ride the rails but don't touch them.
 test_files:
 - spec/active_job_routines_spec.rb
-- spec/background_job_spec.rb
 - spec/create_sprocket_spec.rb
 - spec/deep_merge_spec.rb
 - spec/delegates_to_spec.rb
@@ -299,6 +311,7 @@ test_files:
 - spec/support/create_sprocket.rb
 - spec/support/delegated_routine.rb
 - spec/support/delegating_routine.rb
+- spec/support/jobba.rb
 - spec/support/paramify_handler_a.rb
 - spec/support/paramify_handler_b.rb
 - spec/support/sprocket.rb

data/lib/lev/background_job.rb

@@ -1,229 +0,0 @@
-require 'json'
-
-module Lev
-  class BackgroundJob
-    attr_reader :id, :status, :progress, :errors
-
-    STATE_UNQUEUED = 'unqueued'
-    STATE_QUEUED = 'queued'
-    STATE_WORKING = 'working'
-    STATE_SUCCEEDED = 'succeeded'
-    STATE_FAILED = 'failed'
-    STATE_KILLED = 'killed'
-    STATE_UNKNOWN = 'unknown'
-
-    STATES = [
-      STATE_UNQUEUED,
-      STATE_QUEUED,
-      STATE_WORKING,
-      STATE_SUCCEEDED,
-      STATE_FAILED,
-      STATE_KILLED,
-      STATE_UNKNOWN
-    ].freeze
-
-    def self.create
-      new(status: STATE_UNQUEUED).tap do |job|
-        job.save_standard_values
-      end
-    end
-
-    # Finds the job with the specified ID and returns it.  If no such ID
-    # exists in the store, returns a job with 'unknown' status and sets it
-    # in the store
-    def self.find!(id)
-      find(id) || new({id: id}).tap do |job|
-        job.save_standard_values
-      end
-    end
-
-    # Finds the job with the specified ID and returns it.  If no such ID
-    # exists in the store, returns nil.
-    def self.find(id)
-      raise(ArgumentError, "`id` cannot be nil") if id.nil?
-
-      attrs = { id: id }
-
-      existing_job_attrs = fetch_and_parse(job_key(id))
-
-      if existing_job_attrs.present?
-        attrs.merge!(existing_job_attrs)
-        new(attrs)
-      else
-        nil
-      end
-    end
-
-    def self.all
-      job_ids.map { |id| find!(id) }
-    end
-
-    def set_progress(at, out_of = nil)
-      progress = compute_fractional_progress(at, out_of)
-      set(progress: progress)
-    end
-
-    STATES.each do |state|
-      define_method("#{state}!") do
-        set(status: state)
-      end
-
-      define_method("#{state}?") do
-        status == state
-      end
-    end
-
-    (STATES + %w(completed incomplete)).each do |state|
-      define_singleton_method("#{state}") do
-        all.select{|job| job.send("#{state}?")}
-      end
-    end
-
-    def completed?
-      failed? || succeeded?
-    end
-
-    def incomplete?
-      !completed?
-    end
-
-    def add_error(error, options = { })
-      options = { is_fatal: false }.merge(options)
-      @errors << { is_fatal: options[:is_fatal],
-                   code: error.code,
-                   message: error.message,
-                   data: error.data }
-      set(errors: @errors)
-    end
-
-    # Rails compatibility
-    # returns a Hash of all key-value pairs that have been #set()
-    def as_json(options = {})
-      stored
-    end
-
-    def save(incoming_hash)
-      if reserved = incoming_hash.select { |k, _| RESERVED_KEYS.include?(k) }.first
-        raise IllegalArgument, "Cannot set reserved key: #{reserved[0]}"
-      else
-        set(incoming_hash)
-      end
-    end
-
-    def save_standard_values
-      set({
-        id: id,
-        status: status,
-        progress: progress,
-        errors: errors
-      })
-    end
-
-    def method_missing(method_name, *args)
-      get_dynamic_variable(method_name) || super
-    end
-
-    def respond_to?(method_name)
-      has_dynamic_variable?(method_name) || super
-    end
-
-    protected
-
-    RESERVED_KEYS = [:id, :status, :progress, :errors]
-
-    def initialize(attrs = {})
-      attrs = attrs.stringify_keys
-
-      @id = attrs['id'] || SecureRandom.uuid
-      @status = attrs['status'] || STATE_UNKNOWN
-      @progress = attrs['progress'] || 0
-      @errors = attrs['errors'] || []
-
-      attrs.each do |attr, value|
-        if !instance_variable_defined?("@#{attr}")
-          instance_variable_set("@#{attr}", attrs[attr])
-        end
-      end
-    end
-
-    def set(incoming_hash)
-      apply_consistency_rules!(incoming_hash)
-      new_hash = stored.merge(incoming_hash)
-      new_hash.each { |k, v| instance_variable_set("@#{k}", v) }
-      self.class.store.write(job_key, new_hash.to_json)
-      track_job_id
-    end
-
-    def apply_consistency_rules!(hash)
-      hash.stringify_keys!
-      hash['progress'] = 1.0 if hash['status'] == 'succeeded'
-    end
-
-    def get_dynamic_variable(name)
-      return nil if !has_dynamic_variable?(name)
-      instance_variable_get("@#{name}")
-    end
-
-    def has_dynamic_variable?(name)
-      !name.match(/\?|\!/) && instance_variable_defined?("@#{name}")
-    end
-
-    def self.store
-      Lev.configuration.job_store
-    end
-
-    def self.fetch_and_parse(job_key)
-      fetched = store.fetch(job_key)
-      return nil if fetched.nil?
-      JSON.parse(fetched).stringify_keys!
-    end
-
-    def self.job_ids
-      store.fetch(job_key('lev_job_ids')) || []
-    end
-
-    def stored
-      self.class.fetch_and_parse(job_key) || {}
-    end
-
-    def track_job_id
-      ids = self.class.job_ids
-      return if ids.include?(@id)
-      ids << @id
-      self.class.store.write(self.class.job_key('lev_job_ids'), ids)
-    end
-
-    def job_key
-      self.class.job_key(@id)
-    end
-
-    def self.job_key(id)
-      "#{Lev.configuration.job_store_namespace}:#{id}"
-    end
-
-    def has_reserved_keys?(hash)
-      (hash.keys.collect(&:to_sym) & RESERVED_KEYS).any?
-    end
-
-    def push(key, new_item)
-      new_value = (send(key) || []).push(new_item)
-      set(key => new_value)
-    end
-
-    def compute_fractional_progress(at, out_of)
-      if at.nil?
-        raise IllegalArgument, "Must specify at least `at` argument to `progress` call"
-      elsif at < 0
-        raise IllegalArgument, "progress cannot be negative (at=#{at})"
-      elsif out_of && out_of < at
-        raise IllegalArgument, "`out_of` must be greater than `at` in `progress` calls"
-      elsif out_of.nil? && (at < 0 || at > 1)
-        raise IllegalArgument, "If `out_of` not specified, `at` must be in the range [0.0, 1.0]"
-      end
-
-      at.to_f / (out_of || 1).to_f
-    end
-
-  end
-end
-

data/lib/lev/no_background_job.rb

@@ -1,26 +0,0 @@
-module Lev
-  class NoBackgroundJob
-
-    # Provide null object pattern methods for background jobs; routines should
-    # not be checking their own status (they should know it), and outside callers
-    # should not be checking status unless the background job is a real one.
-
-    def set_progress(*); end
-    def save(*); end
-    def add_error(*); end
-
-    Lev::BackgroundJob::STATES.each do |state|
-      define_method("#{state}!") do; end
-    end
-
-    def self.method_missing(method_sym, *args, &block)
-      if Lev::BackgroundJob.method_defined?(method_sym)
-        raise NameError,
-              "'#{method_sym}' is Lev::BackgroundJob query method, and those cannot be called on NoBackgroundJob"
-      else
-        super
-      end
-    end
-
-  end
-end

data/spec/background_job_spec.rb

@@ -1,129 +0,0 @@
-require 'spec_helper'
-require 'lev/active_job'
-
-describe Lev::BackgroundJob do
-
-  context 'delayed routine' do
-    class DelayedRoutine
-      lev_routine
-      protected
-      def exec; end
-    end
-
-    subject(:job) { described_class.all.last }
-
-    before do
-      Lev.configuration.job_store.clear
-      allow(SecureRandom).to receive(:uuid) { '123abc' }
-      DelayedRoutine.perform_later
-    end
-
-    it 'behaves as a nice ruby object' do
-      expect(job.id).to eq('123abc')
-      expect(job.status).to eq(described_class::STATE_QUEUED)
-      expect(job.progress).to eq(0.0)
-    end
-
-    it 'is unknown when not found' do
-      foo = described_class.find!('noooooo')
-      expect(foo.status).to eq(described_class::STATE_UNKNOWN)
-    end
-
-    it 'uses as_json' do
-      json = job.as_json
-
-      expect(json).to eq({
-        'id' => '123abc',
-        'status' => described_class::STATE_QUEUED,
-        'progress' => 0.0,
-        'errors' => []
-      })
-
-      job.save(foo: :bar)
-      json = job.as_json
-
-      expect(json['foo']).to eq('bar')
-    end
-
-    it 'generates attributes for custom variables' do
-      job.save(foo: 'bar')
-
-      reloaded_job = Lev::BackgroundJob.find(job.id)
-
-      expect(reloaded_job.respond_to?(:foo)).to be true
-      expect(reloaded_job.foo).to eq('bar')
-    end
-
-    it 'has scopes' do
-      expect(described_class.incomplete.collect(&:id)).to include(job.id)
-
-      job.queued!
-      expect(described_class.incomplete.collect(&:id)).to include(job.id)
-      expect(described_class.queued.collect(&:id)).to include(job.id)
-
-      job.working!
-      expect(described_class.incomplete.collect(&:id)).to include(job.id)
-      expect(described_class.working.collect(&:id)).to include(job.id)
-
-      job.failed!
-      expect(described_class.incomplete.collect(&:id)).not_to include(job.id)
-      expect(described_class.failed.collect(&:id)).to include(job.id)
-
-      job.killed!
-      expect(described_class.incomplete.collect(&:id)).to include(job.id)
-      expect(described_class.killed.collect(&:id)).to include(job.id)
-
-      job.unknown!
-      expect(described_class.incomplete.collect(&:id)).to include(job.id)
-      expect(described_class.unknown.collect(&:id)).to include(job.id)
-
-      job.succeeded!
-      expect(described_class.succeeded.collect(&:id)).to include(job.id)
-      expect(described_class.incomplete.collect(&:id)).not_to include(job.id)
-      expect(described_class.succeeded.collect(&:id)).to include(job.id)
-    end
-
-    it 'has the unqueued scope' do
-      expect(described_class.unqueued.collect(&:id)).to eq []
-      unqueued_job = Lev::BackgroundJob.create
-      expect(described_class.unqueued.collect(&:id)).to include(unqueued_job.id)
-    end
-  end
-
-  it 'sets progress to 100% when succeeded' do
-    job = described_class.new
-    job.succeeded!
-    expect(job.progress).to eq 1
-  end
-
-  describe '.find!' do
-    let!(:job) { described_class.create }
-
-    it 'does not write to store when job exists' do
-      expect(described_class.store).to_not receive(:write)
-      found_job = described_class.find!(job.id)
-      expect(found_job.as_json).to eq(job.as_json)
-    end
-
-    it 'finds jobs that are not in the store' do
-      found_job = described_class.find!('not-a-real-id')
-      expect(found_job.as_json).to include('status' => 'unknown')
-    end
-  end
-
-  describe '.find' do
-    let!(:job) { described_class.create }
-
-    it 'finds jobs that are in the store' do
-      expect(described_class.store).to_not receive(:write)
-      found_job = described_class.find(job.id)
-      expect(found_job.as_json).to eq(job.as_json)
-    end
-
-    it 'returns nil for jobs not in the store' do
-      found_job = described_class.find('not-a-real-id')
-      expect(found_job).to be_nil
-    end
-  end
-
-end