lev 4.3.2 → 5.0.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MzhhMmY1NTUwMTc2NDllMjU4Yjc4MGM5YmFiNDRiNDU2Njc0NDQ3Mg==
+    MGNhMzZiZWRhNDllMzMwYjBhMmFkZTQ5YzJiYWNkNjYxMzQ4NmMzMg==
   data.tar.gz: !binary |-
-    OWQ0YzYxNTdjNWJiZDYyYjFiMjFkNzFjMWQ3N2U5MTFlOGRjYWJkNQ==
+    NTdmM2U2NWY0YjlkNDM3N2ViZWU5NzQ3NmYyYjkyZDVkZDUwMzMyNw==
 SHA512:
   metadata.gz: !binary |-
-    ZmVlNWJkNGZjZWIyOGE1Nzk3MDRlODM4YjY1ZjQ2ODEzNzVmNGY3NzAwMjkz
-    OTRmMmRhZWY4ZTI2OTAwNGNjZTM5MDI2MDBiYTRjMmExMmRiMDlhNGRmYzNi
-    MzNhZTU2ZjBkYTc0MmVjY2I5MjQzYTcyNDVmMTg0ZDQ4ZGEwNDc=
+    NDMyM2UzNzY2MDQxODlkNmNlMWJhOTRjYjJkZmI2OWE3ZWM1ZDAyZDU1OWZk
+    ZmRhOWVjZWI5MGNhYWJmNWViMzJlNzlmMTQ0ZjVlMDNjODA1YzJkMDYwMzNj
+    OTc4NGVmYzI2ZDUzOWUwNTVmM2E5NzMyOGQ0MjQ5MWMzMTJhNjM=
   data.tar.gz: !binary |-
-    YTRkYTZlYzlkOGNiNDFkODk2ODViMjc2MzJhYTk2NTY2ZjczYmVjYWQ4YzMx
-    ZjUzYWJjOTYwMTg5NmM2M2ZiZDFkOGIxZmY0MjUyYWRjOWIyNjZhYTExNjE5
-    ZTMyNWRjOTUzZDFlMWIyODMzNTUyOTNmNzgxOGMwZjYzMzc1MDc=
+    M2I4ODI3Mjg0MWJiYzYyZGM0ZDA0OTVmMmJhOTZmMjk0NGIxMDA5ZjUxNTlm
+    NmI2ZmZhMTFmMWUyMDU0NzUwMjFlOGRkYjVhNWE3YjBhNTBkYmM0MmIxYTI0
+    ZDAzYzMyNWYyOTExNjA1NTJjMTJhM2RlZjY3YzNhNzU4NzdkZGE=

data/README.md

@@ -435,23 +435,23 @@ end
 
 Routines run as ActiveJobs can also publish their status somewhere it can be listened to (e.g. to Redis).
 
-Routines have a `status` object and can call the following methods:
+Routines have a `job` 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 status to 'queued'
-* `working!` Sets the status to 'working'
-* `completed!` Sets the status to 'completed'
-* `failed!` Sets the status to 'failed'
-* `killed!` Sets the status 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(is_fatal, error)` takes a boolean and a Lev `Error` object and adds its data to an array of `errors` in the status hash.
+* `queued!` Sets the job status to 'queued'
+* `working!` Sets the job status to 'working'
+* `completed!` Sets the job status to 'completed'
+* `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.
 
-All routines have such a status object.  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 actually records the statuses to a store of your choice.  The store is configured in the Lev configuration block, e.g.:
+All routines have such a job object.  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.:
 
 ```ruby
 Lev.configure do |config|
-  config.status_store = whatever
+  config.job_store = whatever
 end
 ```
 
@@ -462,18 +462,18 @@ The store needs to respond to the following methods:
 
 The default store is essentially a hash (implemented in `Lev::MemoryStore`).  Any `ActiveSupport::Cache::Store` will work.
 
-A routine's status can be retrieved with `Lev::Status.get(uuid_here)`.  This just returns a simple hash.  Notable keys are
+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
-* `'uuid'` the UUID of the routine / status
+* `'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 status store that uses the ActiveRecord database, as the database changes would only be seen when the routine completes and its transaction is committed.
+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).
 
 ## Handlers

data/lib/lev.rb

@@ -26,8 +26,8 @@ require "lev/transaction_isolation"
 
 require 'lev/active_job'
 require 'lev/memory_store'
-require 'lev/status'
-require 'lev/black_hole_status'
+require 'lev/background_job'
+require 'lev/no_background_job'
 
 module Lev
   class << self
@@ -59,16 +59,16 @@ module Lev
       attr_accessor :security_transgression_error
       attr_accessor :illegal_argument_error
       attr_accessor :raise_fatal_errors
-      attr_accessor :status_store
-      attr_accessor :status_store_namespace
+      attr_accessor :job_store
+      attr_accessor :job_store_namespace
 
       def initialize
         @form_error_class = 'error'
         @security_transgression_error = Lev::SecurityTransgression
         @illegal_argument_error = Lev::IllegalArgument
         @raise_fatal_errors = false
-        @status_store = Lev::MemoryStore.new
-        @status_store_namespace = "lev_status"
+        @job_store = Lev::MemoryStore.new
+        @job_store_namespace = "lev_job"
         super
       end
     end

data/lib/lev/active_job.rb

@@ -6,25 +6,25 @@ if defined?(::ActiveJob)
           queue_as routine_class.active_job_queue
           args.push(routine_class.to_s)
 
-          # To enable tracking of this job's status, create a new Status object
+          # 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 Status UUID is returned
+          # off and handed to the routine instance.  The BackgroundJob UUID is returned
           # so that callers can track the status.
-          status = Lev::Status.new
-          status.queued!
-          args.push(status.uuid)
+          job = Lev::BackgroundJob.new
+          job.queued!
+          args.push(job.id)
 
           super(*args, &block)
 
-          status.uuid
+          job.id
         end
 
         def perform(*args, &block)
           # Pop arguments added by perform_later
-          uuid = args.pop
+          id = args.pop
           routine_class = Kernel.const_get(args.pop)
 
-          routine_instance = routine_class.new(Lev::Status.new(uuid))
+          routine_instance = routine_class.new(Lev::BackgroundJob.new(id: id))
           routine_instance.call(*args, &block)
         end
       end

data/lib/lev/background_job.rb

@@ -0,0 +1,173 @@
+require 'json'
+
+module Lev
+  class BackgroundJob
+    attr_reader :id, :status, :progress, :errors
+
+    STATE_QUEUED = 'queued'
+    STATE_WORKING = 'working'
+    STATE_COMPLETED = 'completed'
+    STATE_FAILED = 'failed'
+    STATE_KILLED = 'killed'
+    STATE_UNKNOWN = 'unknown'
+
+    STATES = [
+      STATE_QUEUED,
+      STATE_WORKING,
+      STATE_COMPLETED,
+      STATE_FAILED,
+      STATE_KILLED,
+      STATE_UNKNOWN
+    ].freeze
+
+    def initialize(attrs = {})
+      @id = attrs[:id] || attrs['id'] || SecureRandom.uuid
+      @status = attrs[:status] || attrs['status'] || STATE_UNKNOWN
+      @progress = attrs[:progress] || attrs['progress'] || set_progress(0)
+      @errors = attrs[:errors] || attrs['errors'] || []
+
+      set({ id: id,
+            status: status,
+            progress: progress,
+            errors: errors })
+    end
+
+    def self.find(id)
+      attrs = { id: id }
+
+      if job = store.fetch(job_key(id))
+        attrs.merge!(JSON.parse(job))
+      else
+        attrs.merge!(status: STATE_UNKNOWN)
+      end
+
+      new(attrs)
+    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)
+
+      data_to_set = { progress: progress }
+      data_to_set[:status] = STATE_COMPLETED if 1.0 == progress
+
+      set(data_to_set)
+
+      progress
+    end
+
+    STATES.each do |state|
+      define_method("#{state}!") do
+        set(status: state)
+      end
+    end
+
+    def add_error(error, options = { })
+      options = { is_fatal: false }.merge(options)
+      @errors << { is_fatal: options[:is_fatal],
+                   code: error.code,
+                   message: error.message }
+      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 method_missing(method_name, *args)
+      instance_variable_get("@#{method_name}") || super
+    end
+
+    def respond_to?(method_name)
+      if method_name.match /\?$/
+        super
+      else
+        instance_variable_get("@#{method_name}").present? || super
+      end
+    end
+
+    protected
+    RESERVED_KEYS = [:id, :status, :progress, :errors]
+
+    def set(incoming_hash)
+      incoming_hash = stored.merge(incoming_hash)
+      incoming_hash.each { |k, v| instance_variable_set("@#{k}", v) }
+      self.class.store.write(job_key, incoming_hash.to_json)
+      track_job_id
+    end
+
+    def self.store
+      Lev.configuration.job_store
+    end
+
+    def self.job_ids
+      store.fetch(job_key('lev_job_ids')) || []
+    end
+
+    def stored
+      if found = self.class.store.fetch(job_key)
+        JSON.parse(found)
+      else
+        {}
+      end
+    end
+
+    def track_job_id
+      ids = self.class.job_ids
+      ids << @id
+      self.class.store.write(self.class.job_key('lev_job_ids'), ids.uniq)
+    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
+
+    STATES.each do |state|
+      define_method("#{state}?") do
+        status == state
+      end
+    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/errors.rb

@@ -4,8 +4,8 @@ module Lev
   #
   class Errors < Array
 
-    def initialize(routine_status = nil, raise_fatal_errors = false)
-      @routine_status = routine_status || BlackHoleStatus.new
+    def initialize(routine_job = nil, raise_fatal_errors = false)
+      @routine_job = routine_job || NoBackgroundJob.new
       @raise_fatal_errors = raise_fatal_errors
     end
 
@@ -16,10 +16,10 @@ module Lev
       return if ignored_error_procs.any?{|proc| proc.call(error)}
       self.push(error)
 
-      routine_status.add_error(error, is_fatal: fail)
+      routine_job.add_error(error, is_fatal: fail)
 
       if fail
-        routine_status.failed!
+        routine_job.failed!
 
         if raise_fatal_errors
           raise StandardError, args.to_a.map { |i| i.join(' ') }.join(' - ')
@@ -54,7 +54,7 @@ module Lev
 
   protected
 
-    attr_reader :routine_status
+    attr_reader :routine_job
     attr_reader :raise_fatal_errors
 
     def ignored_error_procs

data/lib/lev/memory_store.rb

@@ -13,5 +13,9 @@ module Lev
       @store[key] = value
     end
 
+    def clear
+      @store.clear
+    end
+
   end
 end

data/lib/lev/no_background_job.rb

@@ -0,0 +1,26 @@
+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.new.respond_to?(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/lib/lev/routine.rb

@@ -191,7 +191,7 @@ module Lev
       end
     end
 
-    attr_reader :uuid
+    attr_reader :id
 
     def self.included(base)
       base.extend(ClassMethods)
@@ -267,7 +267,7 @@ module Lev
     def call(*args, &block)
       @after_transaction_blocks = []
 
-      status.working!
+      job.working!
 
       in_transaction do
         catch :fatal_errors_encountered do
@@ -285,7 +285,7 @@ module Lev
         block.call
       end
 
-      status.completed! if !errors?
+      job.completed! if !errors?
 
       result
     end
@@ -418,26 +418,23 @@ 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(status = nil)
-      # If someone cares about the status, they'll pass it in; otherwise all
-      # status updates go into the bit bucket.
-      @status = status
+    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
     end
 
   protected
 
     attr_writer :runner
 
-    def status
-       @status ||= Lev::BlackHoleStatus.new
+    def job
+       @job ||= Lev::NoBackgroundJob.new
     end
 
     def result
-      @result ||= Result.new(
-        Outputs.new,
-        Errors.new(status,
-                   topmost_runner.class.raise_fatal_errors?)
-      )
+      @result ||= Result.new(Outputs.new,
+                             Errors.new(job, topmost_runner.class.raise_fatal_errors?))
     end
 
     def outputs

data/lib/lev/version.rb

@@ -1,3 +1,3 @@
 module Lev
-  VERSION = "4.3.2"
+  VERSION = "5.0.0"
 end

data/spec/active_job_routines_spec.rb

@@ -16,9 +16,21 @@ RSpec.describe 'ActiveJob routines' do
     end
 
     it 'can have the default queue overridden' do
+      ActiveJob::Base.queue_adapter.enqueued_jobs.clear
+
       LaterRoutine.perform_later
+
       queue_name = ActiveJob::Base.queue_adapter.enqueued_jobs.first[:queue]
+
       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
 end

data/spec/lev/status_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+RSpec.describe Lev::BackgroundJob 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(Lev::BackgroundJob::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(Lev::BackgroundJob::STATE_UNKNOWN)
+  end
+
+  it 'uses as_json' do
+    json = job.as_json
+
+    expect(json).to eq({
+      'id' => '123abc',
+      'status' => Lev::BackgroundJob::STATE_QUEUED,
+      'progress' => 0.0,
+      'errors' => []
+    })
+
+    job.save(foo: :bar)
+    json = job.as_json
+
+    expect(json['foo']).to eq('bar')
+  end
+end

data/spec/statused_routines_spec.rb

@@ -5,135 +5,146 @@ class StatusedRoutine
 
   protected
   def exec
-    status.set_progress(9, 10)
+    job.set_progress(9, 10)
   end
 end
 
 RSpec.describe 'Statused Routines' do
-  subject(:status) { Lev::Status.new }
+  subject(:job) { Lev::BackgroundJob.new }
 
   context 'in a routine' do
-    it 'queues the status object on queue' do
-      uuid = StatusedRoutine.perform_later
-      status = Lev::Status.find(uuid)
+    it 'queues the job object on queue' do
+      id = StatusedRoutine.perform_later
+      job = Lev::BackgroundJob.find(id)
 
-      expect(status['state']).to eq(Lev::Status::STATE_QUEUED)
+      expect(job.status).to eq(Lev::BackgroundJob::STATE_QUEUED)
     end
 
     context 'inline activejob mode' do
       before { ::ActiveJob::Base.queue_adapter = :inline }
       after { ::ActiveJob::Base.queue_adapter = :test }
 
-      it 'sets status to working when called' do
-        expect_any_instance_of(Lev::Status).to receive(:working!)
+      it 'sets job to working when called' do
+        expect_any_instance_of(Lev::BackgroundJob).to receive(:working!)
         StatusedRoutine.perform_later
       end
 
-      it 'completes the status object on completion, returning other data' do
-        uuid = StatusedRoutine.perform_later
-        status = Lev::Status.find(uuid)
-        expect(status['state']).to eq(Lev::Status::STATE_COMPLETED)
-        expect(status['progress']).to eq(0.9)
+      it 'completes the job object on completion, returning other data' do
+        id = StatusedRoutine.perform_later
+        job = Lev::BackgroundJob.find(id)
+        expect(job.status).to eq(Lev::BackgroundJob::STATE_COMPLETED)
+        expect(job.progress).to eq(0.9)
       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' }])
+    end
+  end
+
   describe '#save' do
     it 'prevents the use of reserved keys' do
       expect {
-        status.save(progress: 'blocked')
+        job.save(progress: 'blocked')
       }.to raise_error(Lev::IllegalArgument)
 
       expect {
-        status.save(uuid: 'blocked')
+        job.save(id: 'blocked')
       }.to raise_error(Lev::IllegalArgument)
 
       expect {
-        status.save(state: 'blocked')
+        job.save(status: 'blocked')
       }.to raise_error(Lev::IllegalArgument)
 
       expect {
-        status.save(errors: 'blocked')
+        job.save(errors: 'blocked')
       }.to raise_error(Lev::IllegalArgument)
     end
 
-    it 'saves the hash given and writes them to the status' do
-      status.save(something: 'else')
-      expect(status.get('something')).to eq('else')
-    end
-  end
-
-  describe '#add_error' do
-    it 'adds the error object data to the status object' do
-      errors = Lev::Error.new(code: 'bad', message: 'awful')
-      status.add_error(errors)
-      expect(status.get('errors')).to eq([{ 'is_fatal' => false,
-                                            'code' => 'bad',
-                                            'message' => 'awful' }])
+    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 status setters/getters' do
+  describe 'dynamic job setters/getters' do
     it 'is queued' do
-      expect(status).not_to be_queued
-      status.queued!
-      expect(status).to be_queued
+      expect(job).not_to be_queued
+      job.queued!
+      expect(job).to be_queued
     end
 
     it 'is working' do
-      expect(status).not_to be_working
-      status.working!
-      expect(status).to be_working
+      expect(job).not_to be_working
+      job.working!
+      expect(job).to be_working
     end
 
     it 'is completed' do
-      expect(status).not_to be_completed
-      status.completed!
-      expect(status).to be_completed
+      expect(job).not_to be_completed
+      job.completed!
+      expect(job).to be_completed
     end
 
     it 'is failed' do
-      expect(status).not_to be_failed
-      status.failed!
-      expect(status).to be_failed
+      expect(job).not_to be_failed
+      job.failed!
+      expect(job).to be_failed
     end
 
     it 'is killed' do
-      expect(status).not_to be_killed
-      status.killed!
-      expect(status).to be_killed
+      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 status object' do
-      status.set_progress(8, 10)
-      progress = status.get('progress')
-      expect(progress).to eq(0.8)
+    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 {
-          status.set_progress(nil, 1)
+          job.set_progress(nil, 1)
         }.to raise_error(Lev::IllegalArgument)
 
         expect {
-          status.set_progress(-1, 1)
+          job.set_progress(-1, 1)
         }.to raise_error(Lev::IllegalArgument)
 
         expect {
-          status.set_progress(2, 5)
+          job.set_progress(2, 5)
         }.not_to raise_error
       end
 
       it 'requires `out_of` to be greater than `at`' do
         expect {
-          status.set_progress(15, 8)
+          job.set_progress(15, 8)
         }.to raise_error(Lev::IllegalArgument)
 
         expect {
-          status.set_progress(5, 10)
+          job.set_progress(5, 10)
         }.not_to raise_error
       end
     end
@@ -141,15 +152,15 @@ RSpec.describe 'Statused Routines' do
     context 'without out_of specified' do
       it 'requires `at` to be a float between 0.0 and 1.0' do
         expect {
-          status.set_progress(1.1)
+          job.set_progress(1.1)
         }.to raise_error(Lev::IllegalArgument)
 
         expect {
-          status.set_progress(-1)
+          job.set_progress(-1)
         }.to raise_error(Lev::IllegalArgument)
 
         expect {
-          status.set_progress(0.78)
+          job.set_progress(0.78)
         }.not_to raise_error
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lev
 version: !ruby/object:Gem::Version
-  version: 4.3.2
+  version: 5.0.0
 platform: ruby
 authors:
 - JP Slavinsky
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-20 00:00:00.000000000 Z
+date: 2015-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -218,8 +218,8 @@ files:
 - Rakefile
 - lib/lev.rb
 - lib/lev/active_job.rb
+- lib/lev/background_job.rb
 - lib/lev/better_active_model_errors.rb
-- lib/lev/black_hole_status.rb
 - lib/lev/delegate_to_routine.rb
 - lib/lev/error.rb
 - lib/lev/error_transferer.rb
@@ -231,10 +231,10 @@ files:
 - lib/lev/handler.rb
 - lib/lev/handler_helper.rb
 - lib/lev/memory_store.rb
+- lib/lev/no_background_job.rb
 - lib/lev/object.rb
 - lib/lev/outputs.rb
 - lib/lev/routine.rb
-- lib/lev/status.rb
 - lib/lev/term_mapper.rb
 - lib/lev/transaction_isolation.rb
 - lib/lev/utilities.rb
@@ -244,6 +244,7 @@ files:
 - spec/deep_merge_spec.rb
 - spec/delegates_to_spec.rb
 - spec/errors_spec.rb
+- spec/lev/status_spec.rb
 - spec/outputs_spec.rb
 - spec/paramify_handler_spec.rb
 - spec/routine_spec.rb
@@ -289,6 +290,7 @@ test_files:
 - spec/deep_merge_spec.rb
 - spec/delegates_to_spec.rb
 - spec/errors_spec.rb
+- spec/lev/status_spec.rb
 - spec/outputs_spec.rb
 - spec/paramify_handler_spec.rb
 - spec/routine_spec.rb

data/lib/lev/black_hole_status.rb

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

data/lib/lev/status.rb

@@ -1,125 +0,0 @@
-require 'json'
-
-module Lev
-  class Status
-    STATE_QUEUED = 'queued'
-    STATE_WORKING = 'working'
-    STATE_COMPLETED = 'completed'
-    STATE_FAILED = 'failed'
-    STATE_KILLED = 'killed'
-
-    STATES = [
-      STATE_QUEUED,
-      STATE_WORKING,
-      STATE_COMPLETED,
-      STATE_FAILED,
-      STATE_KILLED
-    ].freeze
-
-    attr_reader :uuid
-
-    def initialize(uuid = nil)
-      @uuid = uuid || SecureRandom.uuid
-      save
-    end
-
-    def self.find(uuid)
-      if status = store.fetch(status_key(uuid))
-        JSON.parse(status)
-      else
-        nil
-      end
-    end
-
-    def set_progress(at, out_of = nil)
-      progress = compute_fractional_progress(at, out_of)
-
-      data_to_set = { progress: progress }
-      data_to_set[:state] = STATE_COMPLETED if 1.0 == progress
-
-      set(data_to_set)
-    end
-
-    STATES.each do |state|
-      define_method("#{state}!") do
-        set(state: state)
-      end
-    end
-
-    def save(hash = {})
-      if has_reserved_keys?(hash)
-        raise IllegalArgument,
-              "Caller cannot specify any reserved keys (#{RESERVED_KEYS})"
-      else
-        set(hash)
-      end
-    end
-
-    def add_error(error, options = { })
-      options = { is_fatal: false }.merge(options)
-      push('errors', { is_fatal: options[:is_fatal],
-                       code: error.code,
-                       message: error.message })
-    end
-
-    def get(key)
-      self.class.find(uuid)[key]
-    end
-
-    protected
-    RESERVED_KEYS = [:progress, :uuid, :state, :errors]
-
-    def self.store
-      # Nice to get the store from lev config each time so it isn't serialized
-      # when activejobs are sent off to places like redis
-      Lev.configuration.status_store
-    end
-
-    def set(incoming_hash)
-      if existing_settings = self.class.find(uuid)
-        incoming_hash = existing_settings.merge(incoming_hash)
-      end
-
-      self.class.store.write(status_key, incoming_hash.to_json)
-    end
-
-    def status_key
-      self.class.status_key(uuid)
-    end
-
-    def self.status_key(uuid)
-      "#{Lev.configuration.status_store_namespace}:#{uuid}"
-    end
-
-    def has_reserved_keys?(hash)
-      (hash.keys.collect(&:to_sym) & RESERVED_KEYS).any?
-    end
-
-    def push(key, new_item)
-      new_value = (get(key) || []).push(new_item)
-      set(key => new_value)
-    end
-
-    STATES.each do |state|
-      define_method("#{state}?") do
-        get('state') == state
-      end
-    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
-