stealth 1.1.2 → 2.0.0.beta1

data/lib/stealth/cli.rb

@@ -80,7 +80,6 @@ module Stealth
 
     $ > stealth console --engine=pry
     EOS
-    method_option :environment, desc: 'Path to environment configuration (config/environment.rb)'
     method_option :engine, desc: "Choose a specific console engine: (#{Stealth::Commands::Console::ENGINES.keys.join('/')})"
     method_option :help, desc: 'Displays the usage method'
     def console
@@ -114,7 +113,7 @@ module Stealth
     EOS
     define_method 'sessions:clear' do
       Stealth.load_environment
-      $redis.flushdb if Stealth.env == 'development'
+      $redis.flushdb if Stealth.env.development?
     end
 
 

data/lib/stealth/commands/console.rb

@@ -53,7 +53,7 @@ module Stealth
         # Add convenience methods to the main:Object binding
         TOPLEVEL_BINDING.eval('self').__send__(:include, CodeReloading)
 
-        Stealth.load_environment
+        Stealth.boot
       end
 
       def engine_lookup

data/lib/stealth/configuration.rb

@@ -1,8 +1,6 @@
 # coding: utf-8
 # frozen_string_literal: true
 
-require 'thread'
-
 module Stealth
   class Configuration < Hash
 
@@ -20,7 +18,6 @@ module Stealth
       if setter?(method)
         self[key] = args.first
       else
-        super(method, args) && return unless key?(key)
         self[key]
       end
     end

data/lib/stealth/controller/callbacks.rb

@@ -13,7 +13,7 @@ module Stealth
         define_callbacks :action, skip_after_callbacks_if_terminated: true
       end
 
-      module ClassMethods
+      class_methods do
         def _normalize_callback_options(options)
           _normalize_callback_option(options, :only, :if)
           _normalize_callback_option(options, :except, :unless)

data/lib/stealth/controller/catch_all.rb

@@ -9,18 +9,41 @@ module Stealth
 
       included do
 
-        def run_catch_all(reason: nil)
+        def run_catch_all(err:)
           error_level = fetch_error_level
-          Stealth::Logger.l(topic: "catch_all", message: "CatchAll #{calculate_catch_all_state(error_level)} triggered for #{error_slug}: #{reason}")
+
+          if err.class == Stealth::Errors::UnrecognizedMessage
+            Stealth::Logger.l(
+              topic: 'catch_all',
+              message: "[Level #{error_level}] for user #{current_session_id} #{err.message}"
+            )
+          else
+            Stealth::Logger.l(
+              topic: 'catch_all',
+              message: "[Level #{error_level}] for user #{current_session_id} #{[err.class, err.message, err.backtrace.join("\n")].join("\n")}"
+            )
+          end
+
+          # Store the reason so it can be accessed by the CatchAllsController
+          current_message.catch_all_reason = {
+            err: err.class,
+            err_msg: err.message
+          }
+
+          # Don't run catch_all from the catch_all controller
+          if current_session.flow_string == 'catch_all'
+            Stealth::Logger.l(topic: 'catch_all', message: "CatchAll triggered for user #{current_session_id} from within CatchAll; ignoring.")
+            return false
+          end
 
           if defined?(CatchAllsController) && FlowMap.flow_spec[:catch_all].present?
             catch_all_state = calculate_catch_all_state(error_level)
 
             if FlowMap.flow_spec[:catch_all].states.keys.include?(catch_all_state.to_sym)
-              step_to flow: 'catch_all', state: catch_all_state
+              step_to flow: :catch_all, state: catch_all_state
             else
               # We are out of bounds, do nothing to prevent an infinite loop
-              Stealth::Logger.l(topic: "catch_all", message: "Stopping; we've exceeded the number of defined catch_all states.")
+              Stealth::Logger.l(topic: 'catch_all', message: "Stopping; we\'ve exceeded the number of defined catch_all states for user #{current_session_id}.")
               return false
             end
           end

data/lib/stealth/controller/controller.rb

@@ -7,18 +7,24 @@ module Stealth
     include Stealth::Controller::Callbacks
     include Stealth::Controller::DynamicDelay
     include Stealth::Controller::Replies
+    include Stealth::Controller::Messages
+    include Stealth::Controller::UnrecognizedMessage
     include Stealth::Controller::CatchAll
     include Stealth::Controller::Helpers
+    include Stealth::Controller::InterruptDetect
+    include Stealth::Controller::DevJumps
+    include Stealth::Controller::Nlp
 
-    attr_reader :current_message, :current_user_id, :current_flow,
-                :current_service, :flow_controller, :action_name,
-                :current_session_id
+    attr_reader :current_message, :current_service, :flow_controller,
+                :action_name, :current_session_id
+    attr_accessor :nlp_result, :pos
 
-    def initialize(service_message:, current_flow: nil)
+    def initialize(service_message:, pos: nil)
       @current_message = service_message
       @current_service = service_message.service
-      @current_user_id = @current_session_id = service_message.sender_id
-      @current_flow = current_flow
+      @current_session_id = service_message.sender_id
+      @nlp_result = service_message.nlp_result
+      @pos = pos
       @progressed = false
     end
 
@@ -31,7 +37,7 @@ module Stealth
     end
 
     def progressed?
-      @progressed.present?
+      @progressed
     end
 
     def route
@@ -41,104 +47,217 @@ module Stealth
     def flow_controller
       @flow_controller ||= begin
         flow_controller = [current_session.flow_string.pluralize, 'controller'].join('_').classify.constantize
-        flow_controller.new(
-          service_message: @current_message,
-          current_flow: current_flow
-        )
+        flow_controller.new(service_message: @current_message, pos: @pos)
       end
     end
 
     def current_session
-      @current_session ||= Stealth::Session.new(user_id: current_session_id)
+      @current_session ||= Stealth::Session.new(id: current_session_id)
     end
 
     def previous_session
-      @previous_session ||= Stealth::Session.new(user_id: current_session_id, previous: true)
+      @previous_session ||= Stealth::Session.new(
+        id: current_session_id,
+        type: :previous
+      )
     end
 
     def action(action: nil)
-      @action_name = action
-      @action_name ||= current_session.state_string
-
-      # Check if the user needs to be redirected
-      if current_session.flow.current_state.redirects_to.present?
-        Stealth::Logger.l(
-          topic: "redirect",
-          message: "From #{current_session.session} to #{current_session.flow.current_state.redirects_to.session}"
+      begin
+        # Grab a mutual exclusion lock on the session
+        lock_session!(
+          session_slug: Session.slugify(
+            flow: current_session.flow_string,
+            state: current_session.state_string
+          )
         )
-        step_to(session: current_session.flow.current_state.redirects_to)
-        return
-      end
 
-      run_callbacks :action do
-        begin
-          flow_controller.send(@action_name)
-          run_catch_all(reason: 'Did not send replies, update session, or step') unless flow_controller.progressed?
-        rescue StandardError => e
-          Stealth::Logger.l(topic: "catch_all", message: e.backtrace.join("\n"))
-          run_catch_all(reason: e.message)
+        @action_name = action
+        @action_name ||= current_session.state_string
+
+        # Check if the user needs to be redirected
+        if current_session.flow.current_state.redirects_to.present?
+          Stealth::Logger.l(
+            topic: "redirect",
+            message: "From #{current_session.session} to #{current_session.flow.current_state.redirects_to.session}"
+          )
+          step_to(session: current_session.flow.current_state.redirects_to, pos: @pos)
+          return
+        end
+
+        run_callbacks :action do
+          begin
+            flow_controller.send(@action_name)
+            unless flow_controller.progressed?
+              run_catch_all(reason: 'Did not send replies, update session, or step')
+            end
+          rescue StandardError => e
+            if e.class == Stealth::Errors::UnrecognizedMessage
+              run_unrecognized_message(err: e)
+            else
+              run_catch_all(err: e)
+            end
+          end
         end
+      ensure
+        # Release mutual exclusion lock on the session
+        release_lock!
       end
     end
 
-    def step_to_in(delay, session: nil, flow: nil, state: nil)
-      flow, state = get_flow_and_state(session: session, flow: flow, state: state)
+    def step_to_in(delay, session: nil, flow: nil, state: nil, slug: nil)
+      if interrupt_detected?
+        run_interrupt_action
+        return :interrupted
+      end
+
+      flow, state = get_flow_and_state(
+        session: session,
+        flow: flow,
+        state: state,
+        slug: slug
+      )
 
       unless delay.is_a?(ActiveSupport::Duration)
         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_session_id, flow, state)
+      Stealth::ScheduledReplyJob.perform_in(delay, current_service, current_session_id, flow, state, current_message.target_id)
       Stealth::Logger.l(topic: "session", message: "User #{current_session_id}: scheduled session step to #{flow}->#{state} in #{delay} seconds")
     end
 
-    def step_to_at(timestamp, session: nil, flow: nil, state: nil)
-      flow, state = get_flow_and_state(session: session, flow: flow, state: state)
+    def step_to_at(timestamp, session: nil, flow: nil, state: nil, slug: nil)
+      if interrupt_detected?
+        run_interrupt_action
+        return :interrupted
+      end
+
+      flow, state = get_flow_and_state(
+        session: session,
+        flow: flow,
+        state: state,
+        slug: slug
+      )
 
       unless timestamp.is_a?(DateTime)
         raise ArgumentError, "Please specify your step_to_at `timestamp` parameter as a DateTime"
       end
 
-      Stealth::ScheduledReplyJob.perform_at(timestamp, current_service, current_session_id, flow, state)
+      Stealth::ScheduledReplyJob.perform_at(timestamp, current_service, current_session_id, flow, state, current_message.target_id)
       Stealth::Logger.l(topic: "session", message: "User #{current_session_id}: scheduled session step to #{flow}->#{state} at #{timestamp.iso8601}")
     end
 
-    def step_to(session: nil, flow: nil, state: nil)
-      flow, state = get_flow_and_state(session: session, flow: flow, state: state)
-      step(flow: flow, state: state)
+    def step_to(session: nil, flow: nil, state: nil, slug: nil, pos: nil)
+      if interrupt_detected?
+        run_interrupt_action
+        return :interrupted
+      end
+
+      flow, state = get_flow_and_state(
+        session: session,
+        flow: flow,
+        state: state,
+        slug: slug
+      )
+
+      step(flow: flow, state: state, pos: pos)
     end
 
-    def update_session_to(session: nil, flow: nil, state: nil)
-      flow, state = get_flow_and_state(session: session, flow: flow, state: state)
+    def update_session_to(session: nil, flow: nil, state: nil, slug: nil)
+      if interrupt_detected?
+        run_interrupt_action
+        return :interrupted
+      end
+
+      flow, state = get_flow_and_state(
+        session: session,
+        flow: flow,
+        state: state,
+        slug: slug
+      )
+
       update_session(flow: flow, state: state)
     end
 
+    def set_back_to(session: nil, flow: nil, state: nil, slug: nil)
+      if interrupt_detected?
+        run_interrupt_action
+        return :interrupted
+      end
+
+      flow, state = get_flow_and_state(
+        session: session,
+        flow: flow,
+        state: state,
+        slug: slug
+      )
+
+      store_back_to_session(flow: flow, state: state)
+    end
+
+    def step_back
+      back_to_session = Stealth::Session.new(
+        id: current_session_id,
+        type: :back_to
+      )
+
+      if back_to_session.blank?
+        raise(
+          Stealth::Errors::InvalidStateTransition,
+          'back_to_session not found; make sure set_back_to was called first'
+        )
+      end
+
+      step_to(session: back_to_session)
+    end
+
+    def do_nothing
+      @progressed = :do_nothing
+    end
+
     private
 
       def update_session(flow:, state:)
-        @current_session = Stealth::Session.new(user_id: current_session_id)
         @progressed = :updated_session
-        @current_session.set(flow: flow, state: state)
+        @current_session = Session.new(id: current_session_id)
+
+        unless current_session.flow_string == flow.to_s && current_session.state_string == state.to_s
+          @current_session.set_session(new_flow: flow, new_state: state)
+        end
+      end
+
+      def store_back_to_session(flow:, state:)
+        back_to_session = Session.new(
+          id: current_session_id,
+          type: :back_to
+        )
+        back_to_session.set_session(new_flow: flow, new_state: state)
       end
 
-      def step(flow:, state:)
+      def step(flow:, state:, pos: nil)
         update_session(flow: flow, state: state)
         @progressed = :stepped
         @flow_controller = nil
         @current_flow = current_session.flow
+        @pos = pos
 
-        action(action: state)
+        flow_controller.action(action: state)
       end
 
-      def get_flow_and_state(session: nil, flow: nil, state: nil)
-        if session.nil? && flow.nil? && state.nil?
-          raise(ArgumentError, "A session, flow, or state must be specified")
+      def get_flow_and_state(session: nil, flow: nil, state: nil, slug: nil)
+        if session.nil? && flow.nil? && state.nil? && slug.nil?
+          raise(ArgumentError, "A session, flow, state, or slug must be specified")
         end
 
         if session.present?
           return session.flow_string, session.state_string
         end
 
+        if slug.present?
+          flow_state = Session.flow_and_state_from_session_slug(slug: slug)
+          return flow_state[:flow], flow_state[:state]
+        end
+
         if flow.present?
           if state.blank?
             state = FlowMap.flow_spec[flow.to_sym].states.keys.first.to_s

data/lib/stealth/controller/dev_jumps.rb

@@ -0,0 +1,41 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Stealth
+  class Controller
+    module DevJumps
+
+      DEV_JUMP_REGEX = /\A\/(.*)\/(.*)\z|\A\/\/(.*)\z|\A\/(.*)\z/
+
+      extend ActiveSupport::Concern
+
+      included do
+        private
+
+        def dev_jump_detected?
+          if Stealth.env.development?
+            if current_message.message&.match(DEV_JUMP_REGEX)
+              handle_dev_jump
+              return true
+            end
+          end
+
+          false
+        end
+
+        def handle_dev_jump
+          _, flow, state = current_message.message.split('/')
+          flow = nil if flow.blank?
+
+          Stealth::Logger.l(
+            topic: 'dev_jump',
+            message: "Dev Jump detected: Flow: #{flow.inspect} State: #{state.inspect}"
+          )
+
+          step_to flow: flow, state: state
+        end
+      end
+
+    end
+  end
+end

data/lib/stealth/controller/dynamic_delay.rb

@@ -12,17 +12,15 @@ module Stealth
       LONG_DELAY = 7.0
 
       included do
-        def dynamic_delay(service_replies:, position:)
-          if position <= 0
-            calculate_delay(previous_reply: {})
-          else
-            calculate_delay(previous_reply: service_replies[position - 1])
-          end
+        def dynamic_delay(previous_reply:)
+          calculate_delay(previous_reply: previous_reply)
         end
 
         private
 
         def calculate_delay(previous_reply:)
+          return SHORT_DELAY if previous_reply.blank?
+
           case previous_reply['reply_type']
           when 'text'
             calculate_delay_from_text(previous_reply['text'])