acts_as_living 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87b4c93d1a35a495a858bfbc9233dcc51ddbc2ec78f87f2d0bdf9e26aeecda1e
-  data.tar.gz: c1cd8bfd44adb565e05300d9e2f5e47c5f48e2812785001f669a43d9ab8a5995
+  metadata.gz: ac1707ac917d7ca82291b1653915c2c3000147c96d443500b30a6fa9788551b1
+  data.tar.gz: ec6655308b3868412dfc7bc83b14e50a76c515d4e60906df6afc0af7fd59a376
 SHA512:
-  metadata.gz: b08703608fc4b3f7f95c3a0bfb28fb33dfef1467ba93b1a6cc7e1dbc98d5c626fab2c2351c47297eb91b9d37e7590f16c0e4b164ffe370f30ce98c3817667864
-  data.tar.gz: 742a2ea7875ce18ec0bd03d42f774485005aa3adf508a12944ff97f9491b89516e52d9f073d12262e74d664434f858ecc28f47ddcadc4858a732fa20d6515e3b
+  metadata.gz: 2a37603ec1613cb1129b8b2778bac79d735e81ec8e76587f867bce38222a67820973d453e4c64b6f29b93cf4c25557a6a6296591923c6e8c1dac9952240b90fe
+  data.tar.gz: 2c7d3c92eec9bbc6e25e6e8df18741ce016232622ac13eb70c3afabc909fd731512cd0138507ab7326848398c89737a51e54731f6ec6950d3e031b96f430098f

data/lib/acts_as_living/acts_as_living.rb

@@ -5,9 +5,9 @@ module ActsAsLiving::ActsAsLiving
   extend ActiveSupport::Concern
 
   class_methods do
-    def acts_as_living(keys, periods:, lock_on:, death:, spread:, column:)
+    def acts_as_living(keys, phases:, lock_on:, death:, spread:, column:)
       @stage_keys     = keys
-      @periods        = periods
+      @phases         = phases
       @locked_stages  = lock_on
       @death          = death
       @spread         = spread

data/lib/acts_as_living/callbacks_definer.rb

@@ -7,7 +7,7 @@
 #                           ->(_target, result) { result == false }
 #                         end
 
-#   # defines before, after and around callbaks for each period of the acts_as_living
+#   # defines before, after and around callbaks for each phase of the acts_as_living
 #   #   e.g. before_cancelled { do_something }
 #   #   e.g. after_activated :run_method
 #   #   e.g. after_stage_change :run_method
@@ -19,9 +19,9 @@
 #       include InstanceMethods
 
 #       callbacks_for(:stage_change)
-#       callbacks_for(:period_change)
+#       callbacks_for(:phase_change)
 #       stage_keys.each(&method(:stage_callbacks_for))
-#       @periods.keys.each(&method(:lifeperiod_callbacks_for))
+#       @phases.keys.each(&method(:lifephase_callbacks_for))
 #     end
 #   end
 
@@ -32,7 +32,7 @@
 #       _run_stage_change_callbacks do
 #         run_callbacks("stage_change_to_#{stage}") do
 #           binding.pry if notice_of_termination_received?
-#           period_changed? ? run_period_callbacks { binding.pry; 'hey'; super(*args) } : super(*args)
+#           phase_changed? ? run_phase_callbacks { binding.pry; 'hey'; super(*args) } : super(*args)
 #         end
 #       end
 #     end
@@ -42,46 +42,46 @@
 
 #       _run_stage_change_callbacks do
 #         run_callbacks("stage_change_to_#{stage}") do
-#           period_changed? ? run_period_callbacks { binding.pry; 'hey'; super(*args) } : super(*args)
+#           phase_changed? ? run_phase_callbacks { binding.pry; 'hey'; super(*args) } : super(*args)
 #         end
 #       end
 #     end
 
 #     protected
 
-#     def run_period_callbacks(&block)
-#       _run_period_change_callbacks do
-#         _run_period_started_callbacks do
-#           _run_period_ended_callbacks(&block)
+#     def run_phase_callbacks(&block)
+#       _run_phase_change_callbacks do
+#         _run_phase_started_callbacks do
+#           _run_phase_ended_callbacks(&block)
 #         end
 #       end
 #     end
 
-#     def _run_period_started_callbacks(&block)
-#       periods_started.inject(block) do |blk, period|
-#         _run_period_started_callbacks(period, &blk)
+#     def _run_phase_started_callbacks(&block)
+#       phases_started.inject(block) do |blk, phase|
+#         _run_phase_started_callbacks(phase, &blk)
 #       end
 #     end
 
-#     def _run_period_ended_callbacks(&block)
-#       periods_ended.inject(block) do |blk, period|
-#         _run_period_ended_callbacks(period, &blk)
+#     def _run_phase_ended_callbacks(&block)
+#       phases_ended.inject(block) do |blk, phase|
+#         _run_phase_ended_callbacks(phase, &blk)
 #       end
 #     end
 
-#     def _run_period_started_callbacks(period, &block)
-#       run_callbacks("#{period}_started".to_sym, &block)
+#     def _run_phase_started_callbacks(phase, &block)
+#       run_callbacks("#{phase}_started".to_sym, &block)
 #     end
 
-#     def _run_period_ended_callbacks(period, &block)
-#       run_callbacks("#{period}_ended".to_sym, &block)
+#     def _run_phase_ended_callbacks(phase, &block)
+#       run_callbacks("#{phase}_ended".to_sym, &block)
 #     end
 #   end
 
 #   module ClassMethods
-#     def lifeperiod_callbacks_for(period)
-#       define_callback_methods_for("#{period}_started".to_sym)
-#       define_callback_methods_for("#{period}_ended".to_sym)
+#     def lifephase_callbacks_for(phase)
+#       define_callback_methods_for("#{phase}_started".to_sym)
+#       define_callback_methods_for("#{phase}_ended".to_sym)
 #     end
 
 #     def callbacks_for(callback_name)

data/lib/acts_as_living/methods_definer.rb

@@ -7,7 +7,7 @@ module ActsAsLiving::MethodsDefiner
       include InstanceMethods
 
       @stage_keys.each(&method(:define_stage_queries))
-      @periods.each(&method(:define_period_queries))
+      @phases.each(&method(:define_phase_queries))
     end
   end
 
@@ -64,12 +64,12 @@ module ActsAsLiving::MethodsDefiner
       dead? || dying?
     end
 
-    def klass_periods_with_ranges
-      self.class.periods_with_ranges
+    def klass_phases_with_ranges
+      self.class.phases_with_ranges
     end
 
-    def klass_periods_for(stage)
-      self.class.periods_for(stage)
+    def klass_phases_for(stage)
+      self.class.phases_for(stage)
     end
 
     def klass_stages
@@ -82,20 +82,20 @@ module ActsAsLiving::MethodsDefiner
       @locked_on.to_set.intersect? [stage, stage_was].to_set
     end
 
-    def periods
-      klass_periods_for(stage)
+    def phases
+      klass_phases_for(stage)
     end
 
-    def period_changed?
-      klass_periods_for(stage) != klass_periods_for(stage_was)
+    def phase_changed?
+      klass_phases_for(stage) != klass_phases_for(stage_was)
     end
 
-    def periods_started
-      klass_periods_for(stage) - klass_periods_for(stage_was)
+    def phases_started
+      klass_phases_for(stage) - klass_phases_for(stage_was)
     end
 
-    def periods_ended
-      klass_periods_for(stage_was) - klass_periods_for(stage)
+    def phases_ended
+      klass_phases_for(stage_was) - klass_phases_for(stage)
     end
   end
 
@@ -155,26 +155,26 @@ module ActsAsLiving::MethodsDefiner
       initial_stage == stage
     end
 
-    def periods_with_ranges
-      @periods.map(&method(:to_period_with_range)).to_h
+    def phases_with_ranges
+      @phases.map(&method(:to_phase_with_range)).to_h
     end
 
-    def to_period_with_range(period, delimiter)
-      [period, (stages[delimiter.first]..stages[delimiter.last])]
+    def to_phase_with_range(phase, delimiter)
+      [phase, (stages[delimiter.first]..stages[delimiter.last])]
     end
 
-    def periods
-      @periods
+    def phases
+      @phases
     end
 
-    def periods_for(stage)
-      periods_with_ranges.keys.select do |period|
-        periods_with_ranges[period].include? stages[stage]
+    def phases_for(stage)
+      phases_with_ranges.keys.select do |phase|
+        phases_with_ranges[phase].include? stages[stage]
       end
     end
 
-    def define_period_queries(period, delimiters)
-      define_method("#{period}?") do
+    def define_phase_queries(phase, delimiters)
+      define_method("#{phase}?") do
         if delimiters.length == 1
           klass_stages[stage] == klass_stages[delimiters]
         else
@@ -183,11 +183,11 @@ module ActsAsLiving::MethodsDefiner
         end
       end
 
-      define_method("pre_#{period}?") do
+      define_method("pre_#{phase}?") do
         klass_stages[stage] < klass_stages[delimiters.first] unless cancelled?
       end
 
-      define_method("past_#{period}?") do
+      define_method("past_#{phase}?") do
         klass_stages[stage] > klass_stages[delimiters.last] || cancelled?
       end
     end

data/lib/acts_as_living/scopes_definer.rb

@@ -9,11 +9,11 @@ module ActsAsLiving::ScopesDefiner
 
       scope :cancelled, -> { where('stage < 0') }
 
-      @periods.each do |period, delimiters|
+      @phases.each do |phase, delimiters|
         if delimiters.length == 1
-          scope period, -> { where(stage: delimiters.first) }
+          scope phase, -> { where(stage: delimiters.first) }
         else
-          scope period, lambda {
+          scope phase, lambda {
             where('stage >= ? AND stage <= ?', stages[delimiters.first], stages[delimiters.second])
           }
         end

data/lib/acts_as_living/version.rb

@@ -1,3 +1,3 @@
 module ActsAsLiving
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_living
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Guilherme Andrade