sequins 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4262d19a9cf34f35abf9368c79c98c496a6e84a9
-  data.tar.gz: a7dce47d5edd4c0f1c6091b2f55fba96c0bc58fd
+  metadata.gz: 056e21b0bc192d4c206223492dde4f2e0b77f6e9
+  data.tar.gz: 994041d33fec1c90138ce71579e042dd57e144b5
 SHA512:
-  metadata.gz: 481a85ea6424756081c5c23ba00f7f5284cfc880b252725b558d7a9ecceebfa5f8b4da4b6d2a4ab4f9998bfca4c6f430956d15dfbbe8caaaff455ca55580905f
-  data.tar.gz: b6256a9b9989104f070fde84cf3f2482170f834bb0ff055695e18a5aa4360718f33105cdd72308dac5e8998832839cadedddf83f2441225d200b3fde01625c51
+  metadata.gz: 1ae876d988d4817e944b75ff1119f593cc43d10eb8efbaac3c023639044a0d07dbf7093fe0232009c269aa2098aef3a501e3b9f412e1b4f6fdb019610c2ab662
+  data.tar.gz: 7ae79622feb2eb4af69937592eeff9c04dcf6189c7c9ea234f33b7d3922b95d3834f9146a26bfa3a39051c79fc23b6793708c8160c2912ca19a9955b5eb98974

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sequins (0.1.0)
+    sequins (0.1.1)
       autoloaded (~> 2)
       docile
       rails (>= 5.0)

data/README.md

@@ -42,13 +42,59 @@ class ExampleSequence < Sequins::Base
 end
 ```
 
+### Steps
+
+A step is a Ruby block. It has the following attributes available:
+
+* `target` is the target object that you pass into `trigger` or `run_step_for_target`
+* `step_name` is the step that's currently running
+* `sequence` is an instance of `Sequins::Sequence`. From this you have access to the sequence class via `sequence.klass`
+
+You also have direct access to class methods on your `Sequence::Base` subclass. For example:
+
+```ruby
+class Example2Sequence < Sequins::Base
+  sequence do
+    step :start, initial: true do
+      send_message target, "hi there"
+    end
+  end
+
+  def self.send_message(target, text)
+    SomeMailer.send_message(target.id, text).deliver_later
+  end
+end
+```
+
+You can also send arguments to `trigger` or `run_step_for_target` which will be passed as block arguments. Example:
+
+```ruby
+class Example3Sequence < Sequins::Base
+  sequence do
+    step :start, initial: true do |something|
+      if something.present?
+        delay 3.days, then: :next_step
+      else
+        end_sequence
+      end
+    end
+
+    step :next_step do
+      # something interesting
+    end
+  end
+end
+
+Example3Sequence.trigger(User.first, "this will trigger a delay")
+```
+
 ### Delay Options
 
 The first argument to `delay` is always an interval, usually expressed as a number of days. Ex: `3.days`.
 In addition, it can take these arguments:
 
 * `then` (always required) this tells delay which step to run next
-* `at` specifies a time relative to the user's local timezone to run the next step
+* `at` specifies a time relative to the target's local timezone to run the next step
 * `only` limits what days to send on. Currently the only valid option is `:weekdays`
 
 ### Trigger a Sequence
@@ -66,11 +112,12 @@ Sequences can define hooks. The available hooks are:
 
 ```
 before_each_step # runs before every step.
+after_each_step  # runs after each step
 before_sequence  # runs before the sequence starts. 
 after_sequence   # runs after the sequence ends with an explicit `end_sequence`
 ```
 
-Hooks are run in the same way steps are, so you have access to the `user` object if you want it.
+Hooks are run in the same way steps are, so you have access to all of the same attributes as a step. Within `before_each_step` and `after_each_step`, `step_name` will be set to the step that is about to or just finished running. Within `before_sequence` and `after_sequence` `step_name` has no meaning.
 
 ## Configuration
 

data/lib/sequins.rb

@@ -24,3 +24,5 @@ module Sequins
     yield configuration
   end
 end
+
+require 'sequins/errors'

data/lib/sequins/base.rb

@@ -13,16 +13,16 @@ module Sequins
       self.to_s.underscore.gsub(/_sequence$/, '')
     end
   
-    def self.trigger(target)
-      sequence.trigger(target)
+    def self.trigger(target, *args)
+      sequence.trigger(target, *args)
     end
   
-    def trigger(target)
-      self.class.trigger(target)
+    def trigger(target, *args)
+      self.class.trigger(target, *args)
     end
   
-    def run_step_for_target(step_name, target)
-      self.class.sequence.run_step_for_target(step_name, target)
+    def run_step_for_target(step_name, target, *args)
+      self.class.sequence.run_step_for_target(step_name, target, *args)
     end    
   end
 end

data/lib/sequins/errors.rb

@@ -1,4 +1,5 @@
 module Sequins
   class UnknownStepError < StandardError; end  
+  class NoInitialStepError < StandardError; end
 end
 

data/lib/sequins/sequence.rb

@@ -7,60 +7,42 @@ module Sequins
     def initialize(klass)
       @klass = klass
       @steps = {}
-      @before_each_step_hooks = []
-      @before_sequence_hooks = []
-      @after_sequence_hooks = []
+      @hooks = {}
     end
 
     def add_step(name, options={}, &block)
       @steps[name] = StepProxy.new(options, block)
     end
 
-    def add_before_each_step_hook(&block)
-      @before_each_step_hooks << StepProxy.new({}, block)
+    def add_hook(stage, &block)
+      @hooks[stage] ||= []
+      @hooks[stage] << StepProxy.new({}, block)
     end
 
-    def add_before_sequence_hook(&block)
-      @before_sequence_hooks << StepProxy.new({}, block)
-    end    
-
-    def add_after_sequence_hook(&block)
-      @after_sequence_hooks << StepProxy.new({}, block)      
-    end
-
-    def run_step_for_target(step_name, target)
+    def run_step_for_target(step_name, target, *args)
       proxy = @steps[step_name]
       raise UnknownStepError.new(step_name) if proxy.nil?
 
-      unless run_before_each_step_hooks_for_target(target)
-        run_after_sequence_hooks_for_target(target)
+      unless run_hooks_for_target(:before_each_step, target, step_name)
+        run_hooks_for_target(:after_sequence, target, :_after_sequence)
         return false
       end
 
-      step = Docile.dsl_eval(Step.new(target, self), &(proxy.block))
-      if step.sequence_ended?
-        run_after_sequence_hooks_for_target(target)
-        return false
-      end
-    end
+      step = Docile.dsl_eval(Step.new(target, self, step_name), args, &(proxy.block))
 
-    def run_before_each_step_hooks_for_target(target)
-      @before_each_step_hooks.each do |hook|
-        step = Docile.dsl_eval(Step.new(target, self), &(hook.block))
-        return false if step.sequence_ended?
+      ended_after_each = !run_hooks_for_target(:after_each_step, target, step_name)      
+
+      if step.sequence_ended? || ended_after_each
+        run_hooks_for_target(:after_sequence, target, :_after_sequence)
+        return false
       end
     end
 
-    def run_before_sequence_hooks_for_target(target)
-      @before_sequence_hooks.each do |hook|
-        step = Docile.dsl_eval(Step.new(target, self), &(hook.block))
-        return false if step.sequence_ended?
-      end        
-    end
+    def run_hooks_for_target(stage, target, step_name)
+      return if @hooks[stage].nil? || @hooks[stage].empty?
 
-    def run_after_sequence_hooks_for_target(target)
-      @after_sequence_hooks.each do |hook|
-        step = Docile.dsl_eval(Step.new(target, self), &(hook.block))
+      @hooks[stage].each do |hook|
+        step = Docile.dsl_eval(Step.new(target, self, step_name), &(hook.block))
         return false if step.sequence_ended?
       end        
     end    
@@ -94,14 +76,16 @@ module Sequins
       Sequins::DelayWorker.set(wait_until: delay_until).perform_later(@klass.to_s, target.class.to_s, target.id, next_step.to_s)
     end
 
-    def trigger(target)
-      unless run_before_sequence_hooks_for_target(target)
-        run_after_sequence_hooks_for_target(target)
+    def trigger(target, *args)
+      step_name, _ = @steps.detect { |_, s| s.options[:initial] }
+      raise NoInitialStepError.new unless step_name.present?
+
+      unless run_hooks_for_target(:before_sequence, target, :_before_sequence)
+        run_hooks_for_target(:after_sequence, target, :_after_sequence)
         return false
       end
 
-      step_name, _ = @steps.detect { |_, s| s.options[:initial] }
-      run_step_for_target(step_name, target)
+      run_step_for_target(step_name, target, *args)
     end
 
   end

data/lib/sequins/sequence_builder.rb

@@ -11,15 +11,19 @@ module Sequins
     end
 
     def before_each_step(&block)
-      @seq.add_before_each_step_hook(&block)
+      @seq.add_hook(:before_each_step, &block)
+    end
+
+    def after_each_step(&block)
+      @seq.add_hook(:after_each_step, &block)
     end
 
     def before_sequence(&block)
-      @seq.add_before_sequence_hook(&block)
+      @seq.add_hook(:before_sequence, &block)
     end
 
     def after_sequence(&block)
-      @seq.add_after_sequence_hook(&block)
+      @seq.add_hook(:after_sequence, &block)
     end
 
     def build

data/lib/sequins/step.rb

@@ -1,10 +1,11 @@
 module Sequins
   class Step
-    attr_reader :target
+    attr_reader :target, :step_name
 
-    def initialize(target, sequence)
+    def initialize(target, sequence, step_name)
       @target = target
       @sequence = sequence
+      @step_name = step_name
     end
 
     def end_sequence

data/lib/sequins/version.rb

@@ -1,3 +1,3 @@
 module Sequins
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequins
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Pete Keen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-08-23 00:00:00.000000000 Z
+date: 2018-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: docile