transitions_listener 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b80f1e14787d8e9fb36dbecdf16ab61ee0af545aad73e6eb6264ed88a676187c
-  data.tar.gz: dbb6ec94ee53192ed571d61467a0805d3e67369953033fd1461ba89460a60a9c
+  metadata.gz: 89990d2302710513e08eca9a6131e56e7ce160a51d6a2beee7e78d49671d1050
+  data.tar.gz: 4e1996531fd05f0ef6f1796a97776517a6462b22dcbf050a5e69a27bf245f195
 SHA512:
-  metadata.gz: a576d7536337cbfeea23b48061d974f3670cf9002dfc3fb0b05bc1e52daa1739e1fdb3775c2331eb96dd83c5227ca90be4d544d6a5c2141435a986acd8a4a31d
-  data.tar.gz: 455b5e5d04dc184f769c4afe3e29c808488cc7eb5815667f14411015cccd8e655dcc2bd8d20bfd78659d5c37be91fc2148eacf23aa3c16a73eeb3fd1fa62b5c9
+  metadata.gz: 273301a304e5a9c724ab99cbcdb9b71d7a610ee0f0ef1e8a35138f83a07a8835bd1c6bce130af8171f83161c5d00824c30ae2dbc6732a903297d82479190705b
+  data.tar.gz: 6a24b40fb750518661fe4e18e0cb7dceb93122cb18feeeca701a107711383ce836691744a5fdf411943e90a7b28e99cbfba9bc8ce123b370831646e8ec682c21

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+# Release 0.3.0 (May 5, 2020)
+- reformat: reformat state definitions to define using from:, to: (more understandable)
+
 # Release 0.2.1 (April 24, 2020)
 - Method callback does not receive transition info
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    transitions_listener (0.2.1)
+    transitions_listener (0.3.0)
       activerecord
       activesupport
 

data/README.md

@@ -26,35 +26,54 @@ And then execute: ```bundle install```
 class Article < ActiveRecord::Base
   include TransitionsListener
   listen_transitions :state do
-    after_transition active: :inactive do |article, transition|
+    after_transition from: :active, to: :inactive do |article, transition|
       # article.send_inactive_email
     end
-    before_transition any => :deleted do |article, transition|
+    before_transition from: any, to: :deleted do |article, transition|
       # article.errors.add(:base, "not possible") if article.active_carts.any?
     end
     
-    before_transition({ any => any }, :any_to_any_callback)
+    before_transition({ from: any, to: any }, if: :valid_article?, unless: :destroyed?, callback: :any_to_any_callback)
   end
   
   def any_to_any_callback
     puts "any to any callback called"
   end
+  
+  def valid_article?
+    true
+  end
+  
+  def destroyed?
+    false
+  end
 end
 ```
 
 ## API
-- ````listen_transitions(attr_name){block}```` permit to define state transitions listener for a specific model attribute
-- ````before_transition(states){block}```` permit to listen transitions before the new state is saved (Before update)
-- ````after_transition(states){block}```` permit to listen transitions after the new state was saved (After update)
-- ````before_transition(states, :callback_name)```` model method to listen transition callbacks
-- ````after_transition(states, :callback_name)```` model method to listen transition callbacks
+- ````listen_transitions(attr_name){block}````   
+    permit to define state transitions listener for a specific model attribute
+
+-   Before update   
+    ````before_transition(states, if: :action?, unless: :action?, callback: :action) { block }````   
+    Permit to listen transitions before the new state is saved
+    * states: (Mandatory) State Transition(s) to listen for
+    * if: (Optional) Positive conditional action(s) to execute callback. Sample: ```if: :deleted? | if: [:deleted?, :ready?]```  
+    * unless: (Optional) Negative conditional action(s) to execute callback. Sample: ```unless: :deleted? | unless: [:deleted?, :ready?]```
+    * callback: (Optional) Model method to be called as a callback (Will be overridden If block is defined)
+
+-   After update (Args are similar to before update)   
+    ````after_transition(states, if: :action?, unless: :action?, callback: :action){ block }````   
+    permit to listen transitions after the new state was saved
+
 
 States can be defined as the following:
-- ```before_transition(any => any){}``` block will be called when attr value is changed from any value to any value
-- ```before_transition(any => :active){}``` block will be called when attr value is changed from any value to :active
-- ```before_transition(:active => any){}``` block will be called when attr value is changed from :active value to any value
-- ```before_transition(%i[active inactive] => %i[deleted cancelled]){}``` block will be called when attr value is changed from :active or inactive to :deleted or :cancelled
-- ```before_transition(active: :inactive, inactive: :deleted){}``` block will be called when attr value is changed from :active to :inactive or :inactive to :deleted
+- ```before_transition(from: any, to: any){}``` block will be called when attr value is changed from any value to any value
+- ```before_transition(from: any, to: :active){}``` block will be called when attr value is changed from any value to :active
+- ```before_transition(from: :active, to: any){}``` block will be called when attr value is changed from :active value to any value
+- ```before_transition(from: %i[active inactive], to: %i[deleted cancelled]){}``` block will be called when attr value is changed from :active or inactive to :deleted or :cancelled
+- ```before_transition([{ from: :active, to: :inactive }, { from: :inactive: :deleted }]){}``` block will be called when attr value is changed from :active to :inactive or :inactive to :deleted
+- ```before_transition([{ active: :inactive, inactive: :deleted }]){}``` block will be called when attr value is changed from :active to :inactive or :inactive to :deleted (Shorter state definitions. Same as above)
 
 ## Development
 

data/lib/transitions_listener.rb

@@ -24,13 +24,11 @@ module TransitionsListener
 
     def perform_transition_listeners(model, kind = :before)
       transition_listeners.each do |listener|
-        c_transition = current_transition_for(model, listener.attr)
-        listener.filter_transitions(kind, c_transition).each do |transition|
-          if transition[:block].is_a?(Proc)
-            transition[:block].call(model, c_transition.merge(transition))
-          else # method name
-            model.public_send(transition[:block])
-          end
+        c_trans = current_transition_for(model, listener.attr)
+        listener.filter_transitions(kind, model, c_trans).each do |trans|
+          block = trans[:args][:callback]
+          args = c_trans.dup.merge(trans)
+          block.is_a?(Proc) ? block.call(model, args) : model.public_send(block)
         end
       end
     end

data/lib/transitions_listener/listener.rb

@@ -8,30 +8,55 @@ module TransitionsListener
       instance_eval(&block)
     end
 
-    def before_transition(states, callback_method = nil, &block)
-      before_transitions(states: states, block: callback_method || block)
+    # @param states: (Array) Array of transitions [{ from:, to: }, {}, ...]
+    #   Multiple transitions: [{ from: [..], to: [..] }, ...]
+    #   Single transitions: [{ from: :state, to: :new_state }, ...]
+    #   Single transition: { from: :state, to: :new_state }
+    # @param args (Hash): { callback: nil, if: nil, unless: nil }
+    #   callback: (Sym) Method name to be used as the callback
+    #   if: (Sym) conditional methods
+    #   else: (Sym) conditional methods
+    def before_transition(states, args = {}, &block)
+      args[:callback] ||= block if block
+      before_transitions(states: parse_states(states), args: args)
     end
 
-    def after_transition(states, callback_method = nil, &block)
-      after_transitions(states: states, block: callback_method || block)
+    # @param states (Array): Same as before transitions
+    # @param args (Hash): Same as before args
+    def after_transition(states, args = {}, &block)
+      args[:callback] ||= block if block
+      after_transitions(states: parse_states(states), args: args)
     end
 
-    def filter_transitions(kind, from:, to:)
+    def filter_transitions(kind, model, from:, to:)
       transitions = kind == :before ? before_transitions : after_transitions
       transitions.select do |transition|
-        match_states?(transition[:states], from, to)
+        match_conditions?(model, transition) &&
+          match_states?(transition, from, to)
       end
     end
 
     private
 
-    def match_states?(states, from_state, to_state)
-      parse_states(states).any? do |t_from, t_to|
+    def match_states?(transition, from_state, to_state)
+      transition[:states].any? do |state|
+        t_from = state[:from]
+        t_to = state[:to]
         (t_from == [any] || t_from.include?(from_state.to_s)) &&
           (t_to == [any] || t_to.include?(to_state.to_s))
       end
     end
 
+    def match_conditions?(model, transition)
+      args = transition[:args]
+      yes_actions = Array(args[:if])
+      no_actions = Array(args[:unless])
+      return false unless yes_actions.all? { |action| model.send(action) }
+      return false unless no_actions.all? { |action| !model.send(action) }
+
+      true
+    end
+
     def any
       'any_transition_key'
     end
@@ -49,11 +74,15 @@ module TransitionsListener
     end
 
     def parse_states(states)
-      states.map do |from, to|
-        from = [from] unless from.is_a? Array
-        to = [to] unless to.is_a? Array
-        [from.map(&:to_s), to.map(&:to_s)]
-      end.to_h
+      is_shorter_definition = states.is_a?(Hash) && !states[:from]
+      states = states.map { |k, v| { from: k, to: v } } if is_shorter_definition
+      is_single_definition = !states.is_a?(Array)
+      states = [states] if is_single_definition
+      states.map do |trans|
+        from = Array(trans[:from]).map(&:to_s)
+        to = Array(trans[:to]).map(&:to_s)
+        { from: from, to: to }
+      end
     end
   end
 end

data/lib/transitions_listener/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TransitionsListener
-  VERSION = '0.2.1'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: transitions_listener
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Owen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-24 00:00:00.000000000 Z
+date: 2020-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord