acts_as_living 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de0cdd11d713c73fa97d94da8f0812ffbeeb5bf7b724c86a8f6d1fa01cf79ebc
-  data.tar.gz: fa9f2638f6e04047cbb7954792d1acdfb375939b65ede0af9f97055b31eef6f7
+  metadata.gz: 9cbb282fe5a1693ff6fd2fe42873fbe624d7eac46b7df7f33ea4df5fd9e20cf1
+  data.tar.gz: 58de6c0353521c7c66c911bda0875eb884fc674a0b969acbbc31abbd712ca8b8
 SHA512:
-  metadata.gz: f944327ad557443227149617a1ecc5fc79bd78a3715d96e1db986e71d782c7d1b110e28ff88023cbea0b86d6f6eb4e079ae062d4a95b3427b827b5cdf73b0e2a
-  data.tar.gz: 3d96447eec1760afd73458b059d5659c58b6020edd38cd45295db1558463d6c6dc5b98484ccae61ace9b34c6d8cf5ed4c8c590d02670bc18d7566158c39ccec4
+  metadata.gz: 89aec99a32d32a373176ef6375920eec25abea134be45b94cbd3b47bd13976047f33e5333833c3571ff27a262195b92637cfad6b4adb249f193241cad69365d6
+  data.tar.gz: 397944cef3dc238ee7d6c1edd2af41f41ba7de684c2f37736c58e40bce8487c1d30b8ee95025d537825f48cee437044608145cc4b8e3516dd3b278e23d1b4369

data/lib/acts_as_living.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
 require 'active_support'
+
 require 'acts_as_living/version'
-require 'acts_as_living/class_methods'
+require 'acts_as_living/acts_as_living'
+require 'acts_as_living/methods_definer'
 require 'acts_as_living/enum_definer'
 require 'acts_as_living/callbacks_definer'
-require 'acts_as_living/instance_methods_definer'
 require 'acts_as_living/scopes_definer'
 require 'acts_as_living/validations_definer'
 

data/lib/acts_as_living/acts_as_living.rb

@@ -0,0 +1,26 @@
+
+require 'active_support/concern'
+
+module ActsAsLiving::ActsAsLiving
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def acts_as_living(keys, periods:, lock_on:, death:, spread:, column:)
+      @stage_keys     = keys
+      @periods        = periods
+      @locked_stages  = lock_on
+      @death          = death
+      @spread         = spread
+      @column         = column
+
+      run_definers
+    end
+
+    def run_definers
+      ActsAsLiving::MethodsDefiner.call(self)
+      ActsAsLiving::EnumDefiner.call(self)
+      ActsAsLiving::ScopesDefiner.call(self)
+      ActsAsLiving::ValidationsDefiner.call(self)
+    end
+  end
+end

data/lib/acts_as_living/callbacks_definer.rb

@@ -7,10 +7,10 @@
 #                           ->(_target, result) { result == false }
 #                         end
 
-#   # defines before, after and around callbaks for each stage of the acts_as_living
+#   # defines before, after and around callbaks for each period of the acts_as_living
 #   #   e.g. before_cancelled { do_something }
 #   #   e.g. after_activated :run_method
-#   #   e.g. after_status_change :run_method
+#   #   e.g. after_stage_change :run_method
 
 #   def self.call(klass)
 #     klass.class_eval do
@@ -18,78 +18,78 @@
 #       extend ClassMethods
 #       include InstanceMethods
 
-#       callbacks_for(:status_change)
-#       callbacks_for(:life_stage_change)
-#       status_keys.each(&method(:status_callbacks_for))
-#       @life_stages.keys.each(&method(:lifestage_callbacks_for))
+#       callbacks_for(:stage_change)
+#       callbacks_for(:period_change)
+#       stage_keys.each(&method(:stage_callbacks_for))
+#       @periods.keys.each(&method(:lifeperiod_callbacks_for))
 #     end
 #   end
 
 #   module InstanceMethods
 #     def save(*args)
-#       return super(*args) unless valid? && status_changed? ||  valid? && new_record?
+#       return super(*args) unless valid? && stage_changed? ||  valid? && new_record?
 
-#       _run_status_change_callbacks do
-#         run_callbacks("status_change_to_#{status}") do
+#       _run_stage_change_callbacks do
+#         run_callbacks("stage_change_to_#{stage}") do
 #           binding.pry if notice_of_termination_received?
-#           life_stage_changed? ? run_life_stage_callbacks { binding.pry; 'hey'; super(*args) } : super(*args)
+#           period_changed? ? run_period_callbacks { binding.pry; 'hey'; super(*args) } : super(*args)
 #         end
 #       end
 #     end
 
 #     def save!(*args)
-#       return super(*args) unless valid? && status_changed? ||  valid? && new_record?
+#       return super(*args) unless valid? && stage_changed? ||  valid? && new_record?
 
-#       _run_status_change_callbacks do
-#         run_callbacks("status_change_to_#{status}") do
-#           life_stage_changed? ? run_life_stage_callbacks { binding.pry; 'hey'; super(*args) } : super(*args)
+#       _run_stage_change_callbacks do
+#         run_callbacks("stage_change_to_#{stage}") do
+#           period_changed? ? run_period_callbacks { binding.pry; 'hey'; super(*args) } : super(*args)
 #         end
 #       end
 #     end
 
 #     protected
 
-#     def run_life_stage_callbacks(&block)
-#       _run_life_stage_change_callbacks do
-#         _run_life_stage_started_callbacks do
-#           _run_life_stage_ended_callbacks(&block)
+#     def run_period_callbacks(&block)
+#       _run_period_change_callbacks do
+#         _run_period_started_callbacks do
+#           _run_period_ended_callbacks(&block)
 #         end
 #       end
 #     end
 
-#     def _run_life_stage_started_callbacks(&block)
-#       life_stages_started.inject(block) do |blk, stage|
-#         _run_stage_started_callbacks(stage, &blk)
+#     def _run_period_started_callbacks(&block)
+#       periods_started.inject(block) do |blk, period|
+#         _run_period_started_callbacks(period, &blk)
 #       end
 #     end
 
-#     def _run_life_stage_ended_callbacks(&block)
-#       life_stages_ended.inject(block) do |blk, stage|
-#         _run_stage_ended_callbacks(stage, &blk)
+#     def _run_period_ended_callbacks(&block)
+#       periods_ended.inject(block) do |blk, period|
+#         _run_period_ended_callbacks(period, &blk)
 #       end
 #     end
 
-#     def _run_stage_started_callbacks(stage, &block)
-#       run_callbacks("#{stage}_started".to_sym, &block)
+#     def _run_period_started_callbacks(period, &block)
+#       run_callbacks("#{period}_started".to_sym, &block)
 #     end
 
-#     def _run_stage_ended_callbacks(stage, &block)
-#       run_callbacks("#{stage}_ended".to_sym, &block)
+#     def _run_period_ended_callbacks(period, &block)
+#       run_callbacks("#{period}_ended".to_sym, &block)
 #     end
 #   end
 
 #   module ClassMethods
-#     def lifestage_callbacks_for(stage)
-#       define_callback_methods_for("#{stage}_started".to_sym)
-#       define_callback_methods_for("#{stage}_ended".to_sym)
+#     def lifeperiod_callbacks_for(period)
+#       define_callback_methods_for("#{period}_started".to_sym)
+#       define_callback_methods_for("#{period}_ended".to_sym)
 #     end
 
 #     def callbacks_for(callback_name)
 #       define_callback_methods_for(callback_name)
 #     end
 
-#     def status_callbacks_for(status_name)
-#       define_callback_methods_for("status_change_to_#{status_name}")
+#     def stage_callbacks_for(stage_name)
+#       define_callback_methods_for("stage_change_to_#{stage_name}")
 #     end
 
 #     def _normalize_callback_options(options)

data/lib/acts_as_living/enum_definer.rb

@@ -11,12 +11,12 @@ module ActsAsLiving::EnumDefiner
 
   module ClassMethods
     def enum_options
-      statuses = @status_keys.map.with_index(&method(:to_enum_map)).to_h
-      statuses.merge(@death => @spread * -1)
+      stages = @stage_keys.map.with_index(&method(:to_enum_map)).to_h
+      stages.merge(@death => @spread * -1)
     end
 
-    def to_enum_map(status, index)
-      [status, index * @spread]
+    def to_enum_map(stage, index)
+      [stage, index * @spread]
     end
   end
 end

data/lib/acts_as_living/methods_definer.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module ActsAsLiving::MethodsDefiner
+  def self.call(klass)
+    klass.class_eval do
+      extend ClassMethods
+      include InstanceMethods
+
+      @stage_keys.each(&method(:define_stage_queries))
+      @periods.each(&method(:define_period_queries))
+    end
+  end
+
+  module InstanceMethods
+    def stage_after(stage)
+      self.class.stage_after(stage)
+    end
+
+    def stages
+      self.class.stages
+    end
+
+    def stage_before(stage)
+      self.class.stage_before(stage)
+    end
+
+    def to_next_stage
+      update(stage: next_stage)
+    end
+
+    def to_next_stage!
+      update!(stage: next_stage)
+    end
+
+    def next_stage
+      stage_after(stage) if stage
+    end
+
+    def to_previous_stage
+      update(stage: previous_stage)
+    end
+
+    def to_previous_stage!
+      update!(stage: previous_stage)
+    end
+
+    def previous_stage
+      stage_before(stage)
+    end
+
+    def dying?
+      self.class.dying?(stage)
+    end
+
+    def newborn?
+      self.class.newborn?(stage)
+    end
+
+    def dead?
+      self.class.death == stage
+    end
+
+    def dead_or_dying?
+      dead? || dying?
+    end
+
+    def klass_periods_with_ranges
+      self.class.periods_with_ranges
+    end
+
+    def klass_periods_for(stage)
+      self.class.periods_for(stage)
+    end
+
+    def klass_stages
+      self.class.stages
+    end
+
+    def locked?(&block)
+      return unless block
+
+      @locked_on.to_set.intersect? [stage, stage_was].to_set
+    end
+
+    def periods
+      klass_periods_for(stage)
+    end
+
+    def period_changed?
+      klass_periods_for(stage) != klass_periods_for(stage_was)
+    end
+
+    def periods_started
+      klass_periods_for(stage) - klass_periods_for(stage_was)
+    end
+
+    def periods_ended
+      klass_periods_for(stage_was) - klass_periods_for(stage)
+    end
+  end
+
+  module ClassMethods
+    def alive_stages
+      stages.except(@death).keys
+    end
+
+    def stage_keys
+      stages.keys
+    end
+
+    def stages_after(stage)
+      return [] if dying?(stage)
+
+      stages[stage_after(stage)..]
+    end
+
+    def stages_before(stage)
+      return [] if newborn?(stage)
+
+      index = stage_keys.find_index(stage)
+      stage_keys[0...index]
+    end
+
+    def stage_after(stage)
+      return if dying?(stage)
+
+      index = stage_keys.find_index(stage)
+      stage_keys[index + 1]
+    end
+
+    def stage_before(stage)
+      return if newborn?(stage)
+
+      index = stage_keys.find_index(stage)
+      stage_keys[index - 1]
+    end
+
+    def final_stage
+      stage_keys.last
+    end
+
+    def dying?(stage)
+      final_stage == stage
+    end
+
+    def newborn_stage
+      stages.key(0)
+    end
+
+    def death
+      @death
+    end
+
+    def newborn?(stage)
+      initial_stage == stage
+    end
+
+    def periods_with_ranges
+      @periods.map(&method(:to_period_with_range)).to_h
+    end
+
+    def to_period_with_range(period, delimiter)
+      [period, (stages[delimiter.first]..stages[delimiter.last])]
+    end
+
+    def periods
+      @periods
+    end
+
+    def periods_for(stage)
+      periods_with_ranges.keys.select do |period|
+        periods_with_ranges[period].include? stages[stage]
+      end
+    end
+
+    def define_period_queries(period, delimiters)
+      define_method("#{period}?") do
+        if delimiters.length == 1
+          klass_stages[stage] == klass_stages[delimiters]
+        else
+          klass_stages[stage] >= klass_stages[delimiters.first] &&
+            klass_stages[stage] <= klass_stages[delimiters.second]
+        end
+      end
+
+      define_method("pre_#{period}?") do
+        klass_stages[stage] < klass_stages[delimiters.first] unless cancelled?
+      end
+
+      define_method("past_#{period}?") do
+        klass_stages[stage] > klass_stages[delimiters.last] || cancelled?
+      end
+    end
+
+    def define_stage_queries(stage_key)
+      define_method("stage_changed_to_#{stage_key}?") do
+        stage_changed? && stage_was == stage_key
+      end
+
+      define_method("stage_saved_to_#{stage_key}?") do
+        saved_change_to_stage? && stage == stage_key
+      end
+
+      define_method("pre_#{stage_key}?") do
+        klass_stages[stage] < klass_stages[stage_key] unless cancelled?
+      end
+
+      define_method("past_#{stage_key}?") do
+        klass_stages[stage] > klass_stages[stage_key] || cancelled?
+      end
+
+      define_method("cancelled_from_#{stage_key}?") do
+        stage == 'cancelled' && stage_was == stage_key
+      end
+    end
+  end
+end

data/lib/acts_as_living/railtie.rb

@@ -7,8 +7,12 @@ module ActsAsLiving
   class Railtie < Rails::Railtie
     config.to_prepare do
       ActiveSupport.on_load(:active_record) do
-        extend ActsAsLiving::ClassMethods
+        include ActsAsLiving::ActsAsLiving
       end
     end
+
+    rake_tasks do
+      load 'tasks/acts_as_living.rake'
+    end
   end
 end

data/lib/acts_as_living/scopes_definer.rb

@@ -1,20 +1,20 @@
 module ActsAsLiving::ScopesDefiner
   def self.call(klass)
     klass.class_eval do
-      statuses.each do |status, _num|
-        scope "past_#{status}", -> { where('status >= ?', statuses[status]) }
-        scope "pre_#{status}", -> { where('status < ?', statuses[status]) }
-        scope "not_#{status}", -> { where.not(status: status) }
+      stages.each do |stage, _num|
+        scope "past_#{stage}", -> { where('stage >= ?', stages[stage]) }
+        scope "pre_#{stage}", -> { where('stage < ?', stages[stage]) }
+        scope "not_#{stage}", -> { where.not(stage: stage) }
       end
 
-      scope :cancelled, -> { where('status < 0') }
+      scope :cancelled, -> { where('stage < 0') }
 
-      @life_stages.each do |stage, delimiters|
+      @periods.each do |period, delimiters|
         if delimiters.length == 1
-          scope stage, -> { where(status: delimiters.first) }
+          scope period, -> { where(stage: delimiters.first) }
         else
-          scope stage, lambda {
-            where('status >= ? AND status <= ?', statuses[delimiters.first], statuses[delimiters.second])
+          scope period, lambda {
+            where('stage >= ? AND stage <= ?', stages[delimiters.first], stages[delimiters.second])
           }
         end
       end

data/lib/acts_as_living/validations_definer.rb

@@ -3,30 +3,30 @@ module ActsAsLiving::ValidationsDefiner
     klass.class_eval do
       include InstanceMethods
 
-      validates :status, presence: true
+      validates :stage, presence: true
 
-      validate :status_progression, on: :update, if: :status_changed?
-      validate :initialized_status, on: :create, if: :status_changed?
+      validate :stage_progression, on: :update, if: :stage_changed?
+      validate :initialized_stage, on: :create, if: :stage_changed?
     end
   end
 
   module InstanceMethods
-    def status_progression
-      return if status.to_s == self.class.dead_status.to_s || status == status_after(status_was)
+    def stage_progression
+      return if stage.to_s == self.class.death.to_s || stage == stage_after(stage_was)
 
-      message = if status_was == self.class.final_status
-                  "The contract can only be updated to '#{self.class.dead_status}'"
+      message = if stage_was == self.class.final_stage
+                  "The contract can only be updated to '#{self.class.death}'"
                 else
-                  "The contract can only be updated to '#{self.class.dead_status}' or '#{status_after(status_was)}'"
+                  "The contract can only be updated to '#{self.class.death}' or '#{stage_after(stage_was)}'"
                 end
 
-      errors.add(:status, message)
+      errors.add(:stage, message)
     end
 
-    def initialized_status
-      return if status == self.class.initial_status
+    def initialized_stage
+      return if stage == self.class.initial_stage
 
-      errors.add(:status, "Contract has to be initialized with '#{self.class.initial_status}' status")
+      errors.add(:stage, "Contract has to be initialized with '#{self.class.initial_stage}' stage")
     end
   end
 end

data/lib/acts_as_living/version.rb

@@ -1,3 +1,3 @@
 module ActsAsLiving
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

data/lib/tasks/acts_as_living.rake

@@ -0,0 +1,18 @@
+namespace :acts_as_living do
+  desc 'Install'
+  task install_migration: :environment do
+    options = {}
+    OptionParser.new do |opts|
+      opts.banner = 'Usage: rake add [options]'
+      opts.on('-m', '--model ARG', String) { |model| options[:model] = model }
+      opts.on('-s', '--stages ARG', Array) { |stages| options[:stages] = stages }
+    end.parse!
+
+    migration_name = "add_life_stages_to_#{options[:model]}"
+    timestamps_code = stages.map { |stage| "#{stage}_at:datetime" }.join(' ')
+    stages_code = 'stage:integer past_stages:string{array: true, default: []}'
+
+    system "rails g migration #{migration_name} #{stages_code} #{timestamps_code}"
+  end
+end
+ 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_living
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Guilherme Andrade
@@ -70,7 +70,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 6.0.3
-description: An ActiveRecord plugin that assists in acts_as_living status progressions.
+description: An ActiveRecord plugin that assists in acts_as_living stage progressions.
 email:
 - guilherme.andrade.ao@gmail.com
 executables: []
@@ -80,14 +80,15 @@ files:
 - Changelog.md
 - README.md
 - lib/acts_as_living.rb
+- lib/acts_as_living/acts_as_living.rb
 - lib/acts_as_living/callbacks_definer.rb
-- lib/acts_as_living/class_methods.rb
 - lib/acts_as_living/enum_definer.rb
-- lib/acts_as_living/instance_methods_definer.rb
+- lib/acts_as_living/methods_definer.rb
 - lib/acts_as_living/railtie.rb
 - lib/acts_as_living/scopes_definer.rb
 - lib/acts_as_living/validations_definer.rb
 - lib/acts_as_living/version.rb
+- lib/tasks/acts_as_living.rake
 homepage: https://github.com/guilherme-andrade/acts_as_living
 licenses:
 - MIT
@@ -103,7 +104,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -113,5 +114,5 @@ requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: An ActiveRecord plugin that assists in acts_as_living status progressions.
+summary: An ActiveRecord plugin that assists in acts_as_living stage progressions.
 test_files: []

data/lib/acts_as_living/class_methods.rb

@@ -1,97 +0,0 @@
-
-module ActsAsLiving::ClassMethods
-  # validates :status, presence: true
-
-  def acts_as_living(keys, **options)
-    @status_keys = keys
-    @life_stages = options.dig(:life_stages)
-    @locked_statuses = options.dig(:lock_on)
-    @death = options.dig(:death)
-    @spread = options.dig(:spread)
-    @column = options.dig(:column)
-
-    ActsAsLiving::EnumDefiner.call(self)
-
-    run_definers
-  end
-
-  def run_definers
-    ActsAsLiving::ScopesDefiner.call(self)
-    ActsAsLiving::InstanceMethodsDefiner.call(self)
-    # ActsAsLiving::CallbacksDefiner.call(self)
-    ActsAsLiving::ValidationsDefiner.call(self)
-  end
-
-  def alive_statuses
-    statuses.except(@death).keys
-  end
-
-  def status_keys
-    statuses.keys
-  end
-
-  def statuses_after(status)
-    return [] if final_status?(status)
-
-    statuses[status_after(status)..]
-  end
-
-  def statuses_before(status)
-    return [] if initial_status?(status)
-
-    index = status_keys.find_index(status)
-    status_keys[0...index]
-  end
-
-  def status_after(status)
-    return if final_status?(status)
-
-    index = status_keys.find_index(status)
-    status_keys[index + 1]
-  end
-
-  def status_before(status)
-    return if initial_status?(status)
-
-    index = status_keys.find_index(status)
-    status_keys[index - 1]
-  end
-
-  def final_status
-    status_keys.last
-  end
-
-  def final_status?(status)
-    final_status == status
-  end
-
-  def initial_status
-    statuses.key(0)
-  end
-
-  def dead_status
-    @death
-  end
-
-  def initial_status?(status)
-    initial_status == status
-  end
-
-  def stages_with_ranges
-    @life_stages.map(&method(:to_stage_with_range)).to_h
-  end
-
-  def to_stage_with_range(stage, delimiter)
-    [stage, (statuses[delimiter.first]..statuses[delimiter.last])]
-  end
-
-  def life_stages
-    @life_stages
-  end
-
-  def life_stages_for(status)
-    stages_with_ranges.keys.select do |stage|
-      stages_with_ranges[stage].include? statuses[status]
-    end
-  end
-end

data/lib/acts_as_living/instance_methods_definer.rb

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-module ActsAsLiving::InstanceMethodsDefiner
-  def self.call(klass)
-    klass.class_eval do
-      extend ClassMethods
-      include InstanceMethods
-
-      @life_stages.each(&method(:define_stage_queries))
-
-      @status_keys.each(&method(:define_changed_queries))
-    end
-  end
-
-  module InstanceMethods
-    def status_after(status)
-      self.class.status_after(status)
-    end
-
-    def statuses
-      self.class.statuses
-    end
-
-    def status_before(status)
-      self.class.status_before(status)
-    end
-
-    def to_next_status
-      update(status: next_status)
-    end
-
-    def to_next_status!
-      update!(status: next_status)
-    end
-
-    def next_status
-      status_after(status) if status
-    end
-
-    def to_previous_status
-      update(status: previous_status)
-    end
-
-    def to_previous_status!
-      update!(status: previous_status)
-    end
-
-    def previous_status
-      status_before(status)
-    end
-
-    def final_status?
-      self.class.final_status?(status)
-    end
-
-    def initial_status?
-      self.class.initial_status?(status)
-    end
-
-    def dead_status?
-      self.class.dead_status == status
-    end
-
-    def dead_or_finalized?
-      dead_status? || final_status?
-    end
-
-    def klass_stages_with_ranges
-      self.class.stages_with_ranges
-    end
-
-    def klass_life_stages_for(status)
-      self.class.life_stages_for(status)
-    end
-
-    def klass_statuses
-      self.class.statuses
-    end
-
-    def locked?(&block)
-      return unless block
-
-      @locked_on.to_set.intersect? [status, status_was].to_set
-    end
-
-    def life_stages
-      klass_life_stages_for(status)
-    end
-
-    def life_stage_changed?
-      klass_life_stages_for(status) != klass_life_stages_for(status_was)
-    end
-
-    def life_stages_started
-      klass_life_stages_for(status) - klass_life_stages_for(status_was)
-    end
-
-    def life_stages_ended
-      klass_life_stages_for(status_was) - klass_life_stages_for(status)
-    end
-  end
-
-  module ClassMethods
-    def define_stage_queries(stage, delimiters)
-      define_method("#{stage}?") do
-        if delimiters.length == 1
-          klass_statuses[status] == klass_statuses[delimiters]
-        else
-          klass_statuses[status] >= klass_statuses[delimiters.first] &&
-            klass_statuses[status] <= klass_statuses[delimiters.second]
-        end
-      end
-
-      define_method("pre_#{stage}?") do
-        klass_statuses[status] < klass_statuses[delimiters.first] unless cancelled?
-      end
-
-      define_method("past_#{stage}?") do
-        klass_statuses[status] > klass_statuses[delimiters.last] || cancelled?
-      end
-    end
-
-    def define_changed_queries(status_key)
-      define_method("status_changed_to_#{status_key}?") do
-        status_changed? && status_was == status_key
-      end
-
-      define_method("pre_#{status_key}?") do
-        klass_statuses[status] < klass_statuses[status_key] unless cancelled?
-      end
-
-      define_method("past_#{status_key}?") do
-        klass_statuses[status] > klass_statuses[status_key] || cancelled?
-      end
-
-      define_method("cancelled_from_#{status_key}?") do
-        status == 'cancelled' && status_was == status_key
-      end
-    end
-  end
-end