stealth 0.9.8 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8e354e371b86c32fbd88873d2c99fd81b1b2e7c
-  data.tar.gz: d68dfa6ed766e034d43cf3c1ebbd1f8e237f633c
+  metadata.gz: 05a79205c1c753dc6ab5b49f1c23695cf13b7d5c
+  data.tar.gz: bff5e9b18f8b6fb5608f23834f65e2526460f440
 SHA512:
-  metadata.gz: af5f5ceb58561a7697ba353eeca4c3bf7e5393016fc7e3edaa4178d89dc437c8f2d937208f46488ee67db110ba456f38e8e25a33fea95ed093a1bcd8c7ec46e3
-  data.tar.gz: d3c6d97b1ec63eeca65ae9be3867e6d3a422bcf99c0110afca0ee5ede9caa55143b7e6c08d801a2fcf363797e90fecfc7ea838f7c22840755944ad3fb0e84289
+  metadata.gz: 8a0997a30591438682bc14fd7c5a61f45935cc0780572bef8a0bd3fc92e2d0beb7d88dd730dd3391088457a953150485b0c6670ade82dc58c869e621af43e1f3
+  data.tar.gz: 68973f3f68bd5c9c8f0b85405fe45f7f0d55e5b8f3a3aa4467d21fef2c6429ff715d144196ac934b4e1a00b76de90d0d48433b370be17914672723c1a62dcca3

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    stealth (0.9.5)
+    stealth (0.10.0)
       activesupport (~> 5.1)
       multi_json (~> 1.12)
       puma (~> 3.10)
@@ -23,10 +23,11 @@ GEM
     i18n (0.9.1)
       concurrent-ruby (~> 1.0)
     minitest (5.10.3)
+    mock_redis (0.17.3)
     multi_json (1.12.2)
     mustermann (1.0.1)
     oj (3.3.6)
-    puma (3.10.0)
+    puma (3.11.0)
     rack (2.0.3)
     rack-protection (2.0.0)
       rack
@@ -68,6 +69,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  mock_redis (~> 0.17)
   oj (~> 3.3)
   rack-test (~> 0.7)
   rspec (~> 3.6)
@@ -75,4 +77,4 @@ DEPENDENCIES
   stealth!
 
 BUNDLED WITH
-   1.15.3
+   1.16.1

data/VERSION

@@ -1 +1 @@
-0.9.8
+0.10.0

data/lib/stealth/base.rb

@@ -19,7 +19,9 @@ require 'stealth/scheduled_reply'
 require 'stealth/service_reply'
 require 'stealth/service_message'
 require 'stealth/session'
-require 'stealth/controller'
+require 'stealth/controller/callbacks'
+require 'stealth/controller/catch_all'
+require 'stealth/controller/controller'
 require 'stealth/flow/base'
 require 'stealth/services/base_client'
 

data/lib/stealth/controller/callbacks.rb

@@ -0,0 +1,64 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Stealth
+  class Controller
+    module Callbacks
+
+      extend ActiveSupport::Concern
+
+      include ActiveSupport::Callbacks
+
+      included do
+        define_callbacks :action, skip_after_callbacks_if_terminated: true
+      end
+
+      module ClassMethods
+        def _normalize_callback_options(options)
+          _normalize_callback_option(options, :only, :if)
+          _normalize_callback_option(options, :except, :unless)
+        end
+
+        def _normalize_callback_option(options, from, to)
+          if from = options[from]
+            _from = Array(from).map(&:to_s).to_set
+            from = proc { |c| _from.include?(c.action_name) }
+            options[to] = Array(options[to]).unshift(from)
+          end
+        end
+
+        def _insert_callbacks(callbacks, block = nil)
+          options = callbacks.extract_options!
+          _normalize_callback_options(options)
+          callbacks.push(block) if block
+          callbacks.each do |callback|
+            yield callback, options
+          end
+        end
+
+        [:before, :after, :around].each do |callback|
+          define_method "#{callback}_action" do |*names, &blk|
+            _insert_callbacks(names, blk) do |name, options|
+              set_callback(:action, callback, name, options)
+            end
+          end
+
+          define_method "prepend_#{callback}_action" do |*names, &blk|
+            _insert_callbacks(names, blk) do |name, options|
+              set_callback(:action, callback, name, options.merge(prepend: true))
+            end
+          end
+
+          define_method "skip_#{callback}_action" do |*names|
+            _insert_callbacks(names) do |name, options|
+              skip_callback(:action, callback, name, options)
+            end
+          end
+
+          alias_method :"append_#{callback}_action", :"#{callback}_action"
+        end
+      end
+
+    end
+  end
+end

data/lib/stealth/controller/catch_all.rb

@@ -0,0 +1,54 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Stealth
+  class Controller
+    module CatchAll
+
+      extend ActiveSupport::Concern
+
+      included do
+
+        def run_catch_all(reason: nil)
+          error_level = fetch_error_level
+          Stealth::Logger.l(topic: "catch_all", message: "CatchAll #{catch_all_state(error_level)} triggered for #{error_slug}: #{reason}")
+
+          if defined?(CatchAllsController)
+            step_to flow: 'catch_all', state: catch_all_state(error_level)
+          end
+        end
+
+        private
+
+          def fetch_error_level
+            if fail_attempts = $redis.get(error_slug)
+              begin
+                fail_attempts = Integer(fail_attempts)
+              rescue ArgumentError
+                fail_attempts = 1
+              end
+
+              fail_attempts += 1
+            else
+              fail_attempts = 1
+            end
+
+            # Set the error with an expiration to avoid filling Redis
+            $redis.setex(error_slug, 15.minutes.to_i, fail_attempts)
+
+            fail_attempts
+          end
+
+          def error_slug
+            ['error', current_user_id, current_session.flow_string, current_session.state_string].join('-')
+          end
+
+          def catch_all_state(error_level)
+            "level#{error_level}"
+          end
+
+      end
+
+    end
+  end
+end

data/lib/stealth/{controller.rb → controller/controller.rb}

@@ -4,18 +4,18 @@
 module Stealth
   class Controller
 
-    include ActiveSupport::Callbacks
-
-    define_callbacks :action
+    include Stealth::Controller::Callbacks
+    include Stealth::Controller::CatchAll
 
     attr_reader :current_message, :current_user_id, :current_flow,
-                :current_service, :flow_controller
+                :current_service, :flow_controller, :action_name
 
     def initialize(service_message:, current_flow: nil)
       @current_message = service_message
       @current_service = service_message.service
       @current_user_id = service_message.sender_id
       @current_flow = current_flow
+      @progressed = false
     end
 
     def has_location?
@@ -26,6 +26,10 @@ module Stealth
       current_message.attachments.present?
     end
 
+    def progressed?
+      @progressed.present?
+    end
+
     def route
       raise(Stealth::Errors::ControllerRoutingNotImplemented, "Please implement `route` method in BotController")
     end
@@ -57,10 +61,12 @@ module Stealth
           end
         end
       end
+
+      @progressed = :sent_replies
     end
 
     def flow_controller
-      @flow_controller = begin
+      @flow_controller ||= begin
         flow_controller = [current_session.flow_string.pluralize, 'controller'].join('_').classify.constantize
         flow_controller.new(
           service_message: @current_message,
@@ -73,10 +79,21 @@ module Stealth
       @current_session ||= Stealth::Session.new(user_id: current_user_id)
     end
 
+    def previous_session
+      @previous_session ||= Stealth::Session.new(user_id: current_user_id, previous: true)
+    end
+
     def action(action: nil)
+      @action_name = action
+      @action_name ||= current_session.state_string
+
       run_callbacks :action do
-        action ||= current_session.state_string
-        flow_controller.send(action)
+        begin
+          flow_controller.send(@action_name)
+          run_catch_all(reason: 'Did not send replies, update session, or step') unless progressed?
+        rescue StandardError => e
+          run_catch_all(reason: e.message)
+        end
       end
     end
 
@@ -84,7 +101,7 @@ module Stealth
       flow, state = get_flow_and_state(session: session, flow: flow, state: state)
 
       unless delay.is_a?(ActiveSupport::Duration)
-        raise ArgumentError, "Please specify your schedule_step_to `in` parameter using ActiveSupport::Duration, e.g. `1.day` or `5.hours`"
+        raise ArgumentError, "Please specify your step_to_in `delay` parameter using ActiveSupport::Duration, e.g. `1.day` or `5.hours`"
       end
 
       Stealth::ScheduledReplyJob.perform_in(delay, current_service, current_user_id, flow, state)
@@ -110,18 +127,6 @@ module Stealth
       update_session(flow: flow, state: state)
     end
 
-    def self.before_action(*args, &block)
-      set_callback(:action, :before, *args, &block)
-    end
-
-    def self.around_action(*args, &block)
-      set_callback(:action, :around, *args, &block)
-    end
-
-    def self.after_action(*args, &block)
-      set_callback(:action, :after, *args, &block)
-    end
-
     private
 
       def reply_handler
@@ -156,11 +161,14 @@ module Stealth
 
       def update_session(flow:, state:)
         @current_session = Stealth::Session.new(user_id: current_user_id)
+        @progressed = :updated_session
         @current_session.set(flow: flow, state: state)
       end
 
       def step(flow:, state:)
         update_session(flow: flow, state: state)
+        @progressed = :stepped
+        @flow_controller = nil
         @current_flow = current_session.flow
 
         action(action: state)

data/lib/stealth/errors.rb

@@ -34,5 +34,11 @@ module Stealth
     class ReplyNotFound < Errors
     end
 
+    class FlowError < Errors
+    end
+
+    class FlowDefinitionError < Errors
+    end
+
   end
 end

data/lib/stealth/flow/base.rb

@@ -1,153 +1,38 @@
 # coding: utf-8
 # frozen_string_literal: true
 
-require 'stealth/flow/errors'
+require 'stealth/flow/core_ext'
 require 'stealth/flow/specification'
-require 'stealth/flow/event_collection'
-require 'stealth/flow/event'
 require 'stealth/flow/state'
 
 module Stealth
   module Flow
 
-    module ClassMethods
+    extend ActiveSupport::Concern
+
+    class_methods do
       attr_reader :flow_spec
 
       def flow(&specification)
-        assign_flow Specification.new(Hash.new, &specification)
-      end
-
-      private
-
-      # Creates the convinience methods like `my_transition!`
-      def assign_flow(specification_object)
-
-        # Merging two workflow specifications can **not** be done automically, so
-        # just make the latest specification win. Same for inheritance -
-        # definition in the subclass wins.
-        if respond_to? :inherited_flow_spec # undefine methods defined by the old flow_spec
-          inherited_flow_spec.states.values.each do |state|
-            state_name = state.name
-            module_eval do
-              undef_method "#{state_name}?"
-            end
-
-            state.events.flat.each do |event|
-              event_name = event.name
-              module_eval do
-                undef_method "#{event_name}!".to_sym
-                undef_method "can_#{event_name}?"
-              end
-            end
-          end
-        end
-
-        @flow_spec = specification_object
-        @flow_spec.states.values.each do |state|
-          state_name = state.name
-          module_eval do
-            define_method "#{state_name}?" do
-              state_name == current_state.name
-            end
-          end
-
-          state.events.flat.each do |event|
-            event_name = event.name
-            module_eval do
-              define_method "#{event_name}!".to_sym do |*args|
-                process_event!(event_name, *args)
-              end
-
-              define_method "can_#{event_name}?" do
-                return !!current_state.events.first_applicable(event_name, self)
-              end
-            end
-          end
-        end
+        @flow_spec = Specification.new(&specification)
       end
     end
 
-    module InstanceMethods
+    included do
       attr_accessor :flow_state, :user_id
 
       def current_state
-        loaded_state = load_flow_state
-        res = spec.states[loaded_state.to_sym] if loaded_state
+        res = spec.states[@flow_state.to_sym] if @flow_state
         res || spec.initial_state
       end
 
-      # Return true if the last transition was halted by one of the transition callbacks.
-      def halted?
-        @halted
-      end
-
-      # Return the reason of the last transition abort as set by the previous
-      # call of `halt` or `halt!` method.
-      def halted_because
-        @halted_because
-      end
-
-      def process_event!(name, *args)
-        event = current_state.events.first_applicable(name, self)
-        raise NoTransitionAllowed.new(
-          "There is no event #{name.to_sym} defined for the #{current_state} state") \
-          if event.nil?
-        @halted_because = nil
-        @halted = false
-
-        check_transition(event)
-
-        from = current_state
-        to = spec.states[event.transitions_to]
-
-        run_before_transition(from, to, name, *args)
-        return false if @halted
-
-        begin
-          return_value = run_action(event.action, *args) || run_action_callback(event.name, *args)
-        rescue StandardError => e
-          run_on_error(e, from, to, name, *args)
-        end
-
-        return false if @halted
-
-        run_on_transition(from, to, name, *args)
-
-        run_on_exit(from, to, name, *args)
-
-        transition_value = persist_flow_state(to.to_s)
-
-        run_on_entry(to, from, name, *args)
-
-        run_after_transition(from, to, name, *args)
-
-        return_value.nil? ? transition_value : return_value
-      end
-
-      def halt(reason = nil)
-        @halted_because = reason
-        @halted = true
-      end
-
-      def halt!(reason = nil)
-        @halted_because = reason
-        @halted = true
-        raise TransitionHalted.new(reason)
-      end
-
       def spec
         # check the singleton class first
         class << self
           return flow_spec if flow_spec
         end
 
-        c = self.class
-        # using a simple loop instead of class_inheritable_accessor to avoid
-        # dependency on Rails' ActiveSupport
-        until c.flow_spec || !(c.include? Stealth::Flow)
-          c = c.superclass
-        end
-        c.flow_spec
+        self.class.flow_spec
       end
 
       def states
@@ -155,102 +40,23 @@ module Stealth
       end
 
       def init_state(state)
-        res = spec.states[state.to_sym] if state
-        @flow_state = res || spec.initial_state
-        self
-      end
+        raise(ArgumentError, 'No state was specified.') if state.blank?
 
-      private
-
-      def check_transition(event)
-        # Create a meaningful error message instead of
-        # "undefined method `on_entry' for nil:NilClass"
-        # Reported by Kyle Burton
-        if !spec.states[event.transitions_to]
-          raise StealthFlowError.new("Event[#{event.name}]'s " +
-              "transitions_to[#{event.transitions_to}] is not a declared state")
+        new_state = state.to_sym
+        unless states.include?(new_state)
+          raise(Stealth::Errors::InvalidStateTransition)
         end
-      end
-
-      def run_before_transition(from, to, event, *args)
-        instance_exec(from.name, to.name, event, *args, &spec.before_transition_proc) if spec.before_transition_proc
-      end
+        @flow_state = new_state
 
-      def run_on_error(error, from, to, event, *args)
-        if spec.on_error_proc
-          instance_exec(error, from.name, to.name, event, *args, &spec.on_error_proc)
-          halt(error.message)
-        else
-          raise error
-        end
-      end
-
-      def run_on_transition(from, to, event, *args)
-        instance_exec(from.name, to.name, event, *args, &spec.on_transition_proc) if spec.on_transition_proc
-      end
-
-      def run_after_transition(from, to, event, *args)
-        instance_exec(from.name, to.name, event, *args, &spec.after_transition_proc) if spec.after_transition_proc
-      end
-
-      def run_action(action, *args)
-        instance_exec(*args, &action) if action
-      end
-
-      def has_callback?(action)
-        # 1. public callback method or
-        # 2. protected method somewhere in the class hierarchy or
-        # 3. private in the immediate class (parent classes ignored)
-        action = action.to_sym
-        self.respond_to?(action) or
-          self.class.protected_method_defined?(action) or
-          self.private_methods(false).map(&:to_sym).include?(action)
-      end
-
-      def run_action_callback(action_name, *args)
-        action = action_name.to_sym
-        self.send(action, *args) if has_callback?(action)
-      end
-
-      def run_on_entry(state, prior_state, triggering_event, *args)
-        if state.on_entry
-          instance_exec(prior_state.name, triggering_event, *args, &state.on_entry)
-        else
-          hook_name = "on_#{state}_entry"
-          self.send(hook_name, prior_state, triggering_event, *args) if has_callback?(hook_name)
-        end
-      end
-
-      def run_on_exit(state, new_state, triggering_event, *args)
-        if state
-          if state.on_exit
-            instance_exec(new_state.name, triggering_event, *args, &state.on_exit)
-          else
-            hook_name = "on_#{state}_exit"
-            self.send(hook_name, new_state, triggering_event, *args) if has_callback?(hook_name)
-          end
-        end
+        self
       end
 
-      def load_flow_state
-        @flow_state
-      end
+      private
 
-      def persist_flow_state(new_value)
-        @flow_state = new_value
-        if defined?($redis)
-          $redis.set(user_id, flow_and_state)
+        def flow_and_state
+          [self.class.to_s, current_state].join("->")
         end
-      end
-
-      def flow_and_state
-        [self.class.to_s, current_state].join("->")
-      end
     end
 
-    def self.included(klass)
-      klass.send :include, InstanceMethods
-      klass.extend ClassMethods
-    end
   end
 end

data/lib/stealth/flow/core_ext.rb

@@ -0,0 +1,11 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+class Numeric
+
+  def states
+    self
+  end
+  alias :state :states
+
+end

data/lib/stealth/flow/specification.rb

@@ -4,12 +4,10 @@
 module Stealth
   module Flow
     class Specification
-      attr_accessor :states, :initial_state, :meta,
-        :on_transition_proc, :before_transition_proc, :after_transition_proc, :on_error_proc
+      attr_accessor :states, :initial_state
 
-      def initialize(meta = {}, &specification)
+      def initialize(&specification)
         @states = Hash.new
-        @meta = meta
         instance_eval(&specification)
       end
 
@@ -19,49 +17,18 @@ module Stealth
 
       private
 
-      def state(name, meta = {:meta => {}}, &events_and_etc)
-        # meta[:meta] to keep the API consistent..., gah
-        new_state = Stealth::Flow::State.new(name, self, meta[:meta])
-        @initial_state = new_state if @states.empty?
-        @states[name.to_sym] = new_state
-        @scoped_state = new_state
-        instance_eval(&events_and_etc) if events_and_etc
-      end
-
-      def event(name, args = {}, &action)
-        target = args[:transitions_to] || args[:transition_to]
-        condition = args[:if]
-        raise StealthFlowDefinitionError.new(
-          "missing ':transitions_to' in workflow event definition for '#{name}'") \
-          if target.nil?
-        @scoped_state.events.push(
-          name, Stealth::Flow::Event.new(name, target, condition, (args[:meta] or {}), &action)
-        )
-      end
+        def state(name, fails_to: nil)
+          fail_state = nil
+          if fails_to.present?
+            fail_state = Stealth::Flow::State.new(fails_to, self)
+          end
 
-      def on_entry(&proc)
-        @scoped_state.on_entry = proc
-      end
+          new_state = Stealth::Flow::State.new(name, self, fail_state)
+          @initial_state = new_state if @states.empty?
+          @states[name.to_sym] = new_state
+          @scoped_state = new_state
+        end
 
-      def on_exit(&proc)
-        @scoped_state.on_exit = proc
-      end
-
-      def after_transition(&proc)
-        @after_transition_proc = proc
-      end
-
-      def before_transition(&proc)
-        @before_transition_proc = proc
-      end
-
-      def on_transition(&proc)
-        @on_transition_proc = proc
-      end
-
-      def on_error(&proc)
-        @on_error_proc = proc
-      end
     end
   end
 end