stealth 1.1.3 → 2.0.0.beta2

data/lib/stealth/controller/replies.rb

@@ -12,19 +12,61 @@ module Stealth
         class_attribute :_preprocessors, default: [:erb]
         class_attribute :_replies_path, default: [Stealth.root, 'bot', 'replies']
 
-        def send_replies
-          yaml_reply, preprocessor = action_replies
-
-          service_reply = Stealth::ServiceReply.new(
-            recipient_id: current_session_id,
-            yaml_reply: yaml_reply,
-            preprocessor: preprocessor,
-            context: binding
+        def send_replies(custom_reply: nil, inline: nil)
+          service_reply = load_service_reply(
+            custom_reply: custom_reply,
+            inline: inline
           )
 
-          service_reply.replies.each_with_index do |reply, i|
+          # Determine if we start at the beginning or somewhere else
+          reply_range = calculate_reply_range
+          offset = reply_range.first
+
+          @previous_reply = nil
+          service_reply.replies.slice(reply_range).each_with_index do |reply, i|
+            # Updates the lock with the current position of the reply
+            lock_session!(
+              session_slug: current_session.get_session,
+              position: i + offset # Otherwise this won't account for explicit starting points
+            )
+
+            begin
+              send_reply(reply: reply)
+            rescue Stealth::Errors::UserOptOut => e
+              user_opt_out_handler(msg: e.message)
+              return
+            rescue Stealth::Errors::InvalidSessionID => e
+              invalid_session_id_handler(msg: e.message)
+              return
+            end
+
+            @previous_reply = reply
+          end
+
+          @progressed = :sent_replies
+        ensure
+          release_lock!
+        end
+
+        private
+
+          def send_reply(reply:)
+            if !reply.delay? && Stealth.config.auto_insert_delays
+              # if it's the first reply in the service_reply or the previous reply
+              # wasn't a custom delay, then insert a delay
+              if @previous_reply.blank? || !@previous_reply.delay?
+                send_reply(reply: Reply.dynamic_delay)
+              end
+            end
+
+            # Support randomized replies for text and speech replies.
+            # We select one before handing the reply off to the driver.
+            if reply['text'].is_a?(Array)
+              reply['text'] = reply['text'].sample
+            end
+
             handler = reply_handler.new(
-              recipient_id: current_session_id,
+              recipient_id: current_message.sender_id,
               reply: reply
             )
 
@@ -32,32 +74,49 @@ module Stealth
             client = service_client.new(reply: translated_reply)
             client.transmit
 
+            log_reply(reply) if Stealth.config.transcript_logging
+
             # If this was a 'delay' type of reply, we insert the delay
-            if reply.reply_type == 'delay'
-              begin
-                if reply['duration'] == 'dynamic'
-                  m = Stealth.config.dynamic_delay_muliplier
-                  duration = dynamic_delay(
-                    service_replies: service_reply.replies,
-                    position: i
-                  )
-
-                  sleep_duration = Stealth.config.dynamic_delay_muliplier * duration
-                else
-                  sleep_duration = Float(reply['duration'])
-                end
+            if reply.delay?
+              insert_delay(duration: reply['duration'])
+            end
+          end
 
-                sleep(sleep_duration)
-              rescue ArgumentError, TypeError
-                raise(ArgumentError, 'Invalid duration specified. Duration must be a float')
+          def insert_delay(duration:)
+            begin
+              sleep_duration = if duration == 'dynamic'
+                dyn_duration = dynamic_delay(previous_reply: @previous_reply)
+
+                Stealth.config.dynamic_delay_muliplier * dyn_duration
+              else
+                Float(duration)
               end
+
+              sleep(sleep_duration)
+            rescue ArgumentError, TypeError
+              raise(ArgumentError, 'Invalid duration specified. Duration must be a Numeric')
             end
           end
 
-          @progressed = :sent_replies
-        end
+          def load_service_reply(custom_reply:, inline:)
+            if inline.present?
+              Stealth::ServiceReply.new(
+                recipient_id: current_session_id,
+                yaml_reply: inline,
+                preprocessor: :none,
+                context: nil
+              )
+            else
+              yaml_reply, preprocessor = action_replies(custom_reply)
 
-        private
+              Stealth::ServiceReply.new(
+                recipient_id: current_session_id,
+                yaml_reply: yaml_reply,
+                preprocessor: preprocessor,
+                context: binding
+              )
+            end
+          end
 
           def service_client
             begin
@@ -87,17 +146,36 @@ module Stealth
             "#{current_session.state_string}.yml"
           end
 
-          def reply_filenames
-            service_filename = [base_reply_filename, current_service].join('+')
+          def reply_filenames(custom_reply_filename=nil)
+            reply_filename = if custom_reply_filename.present?
+              custom_reply_filename
+            else
+              base_reply_filename
+            end
+
+            service_filename = [reply_filename, current_service].join('+')
 
             # Service-specific filenames take precedance (returned first)
-            [service_filename, base_reply_filename]
+            [service_filename, reply_filename]
           end
 
-          def find_reply_and_preprocessor
+          def find_reply_and_preprocessor(custom_reply)
             selected_preprocessor = :none
-            reply_file_path = File.join(*reply_dir, base_reply_filename)
-            service_reply_path = File.join(*reply_dir, reply_filenames.first)
+
+            if custom_reply.present?
+              dir_and_file = custom_reply.rpartition(File::SEPARATOR)
+              _dir = dir_and_file.first
+              _file = "#{dir_and_file.last}.yml"
+              _replies_dir = [*self._replies_path, _dir]
+              possible_filenames = reply_filenames(_file)
+              reply_file_path = File.join(_replies_dir, _file)
+              service_reply_path = File.join(_replies_dir, reply_filenames(_file).first)
+            else
+              _replies_dir = *reply_dir
+              possible_filenames = reply_filenames
+              reply_file_path = File.join(_replies_dir, base_reply_filename)
+              service_reply_path = File.join(_replies_dir, reply_filenames.first)
+            end
 
             # Check if the service_filename exists
             # If so, we can skip checking for a preprocessor
@@ -108,8 +186,8 @@ module Stealth
             # Cycles through possible preprocessor and variant combinations
             # Early returns for performance
             for preprocessor in self.class._preprocessors do
-              for reply_filename in reply_filenames do
-                selected_filepath = File.join(*reply_dir, [reply_filename, preprocessor.to_s].join('.'))
+              for reply_filename in possible_filenames do
+                selected_filepath = File.join(_replies_dir, [reply_filename, preprocessor.to_s].join('.'))
                 if File.exist?(selected_filepath)
                   reply_file_path = selected_filepath
                   selected_preprocessor = preprocessor
@@ -121,18 +199,82 @@ module Stealth
             return reply_file_path, selected_preprocessor
           end
 
-          def action_replies
-            reply_file_path, selected_preprocessor = find_reply_and_preprocessor
+          def action_replies(custom_reply=nil)
+            reply_path, selected_preprocessor = find_reply_and_preprocessor(custom_reply)
 
             begin
-              file_contents = File.read(reply_file_path)
+              file_contents = File.read(reply_path)
             rescue Errno::ENOENT
-              raise(Stealth::Errors::ReplyNotFound, "Could not find a reply in #{reply_dir}")
+              raise(Stealth::Errors::ReplyNotFound, "Could not find reply: '#{reply_path}'")
             end
 
             return file_contents, selected_preprocessor
           end
 
+          def user_opt_out_handler(msg:)
+            if self.respond_to?(:handle_opt_out, true)
+              self.send(:handle_opt_out)
+              Stealth::Logger.l(
+                topic: current_service,
+                message: "User #{current_session_id} opted out. [#{msg}]"
+              )
+            else
+              Stealth::Logger.l(
+                topic: :err,
+                message: "User #{current_session_id} unhandled exception due to opt-out."
+              )
+            end
+
+            do_nothing
+          end
+
+          def invalid_session_id_handler(msg:)
+            if self.respond_to?(:handle_invalid_session_id, true)
+              self.send(:handle_invalid_session_id)
+              Stealth::Logger.l(
+                topic: current_service,
+                message: "User #{current_session_id} has an invalid session_id. [#{msg}]"
+              )
+            else
+              Stealth::Logger.l(
+                topic: :err,
+                message: "User #{current_session_id} unhandled exception due to invalid session_id."
+              )
+            end
+
+            do_nothing
+          end
+
+          def calculate_reply_range
+            # if an explicit starting point is specified, use that until the
+            # end of the range, otherwise start at the beginning
+            if @pos.present?
+              (@pos..-1)
+            else
+              (0..-1)
+            end
+          end
+
+          def log_reply(reply)
+            message = case reply.reply_type
+                      when 'text'
+                        reply['text']
+                      when 'speech'
+                        reply['speech']
+                      when 'ssml'
+                        reply['ssml']
+                      when 'delay'
+                        '<typing indicator>'
+                      else
+                        "<#{reply.reply_type}>"
+                      end
+
+            Stealth::Logger.l(
+              topic: current_service,
+              message: "User #{current_session_id} -> Sending: #{message}"
+            )
+          end
+
       end # instance methods
 
     end

data/lib/stealth/controller/unrecognized_message.rb

@@ -0,0 +1,62 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Stealth
+  class Controller
+    module UnrecognizedMessage
+
+      extend ActiveSupport::Concern
+
+      included do
+
+        def run_unrecognized_message(err:)
+          err_message = "The message \"#{current_message.message}\" was not recognized in the original context."
+
+          Stealth::Logger.l(
+            topic: 'unrecognized_message',
+            message: err_message
+          )
+
+          unless defined?(UnrecognizedMessagesController)
+            Stealth::Logger.l(
+              topic: 'unrecognized_message',
+              message: 'Running catch_all; UnrecognizedMessagesController not defined.'
+            )
+
+            run_catch_all(err: err)
+            return false
+          end
+
+          unrecognized_msg_controller = UnrecognizedMessagesController.new(
+            service_message: current_message
+          )
+
+          begin
+            # Run handle_unrecognized_message action
+            unrecognized_msg_controller.handle_unrecognized_message
+
+            if unrecognized_msg_controller.progressed?
+              Stealth::Logger.l(
+                topic: 'unrecognized_message',
+                message: 'A match was detected. Skipping catch-all.'
+              )
+            else
+              # Log, but we don't want to run the catch_all for a poorly
+              # coded UnrecognizedMessagesController
+              Stealth::Logger.l(
+                topic: 'unrecognized_message',
+                message: 'Did not send replies, update session, or step'
+              )
+            end
+          rescue StandardError => e
+            # Run the catch_all directly since we're already in an unrecognized
+            # message state
+            run_catch_all(err: e)
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/stealth/core_ext.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir.glob(File.expand_path('core_ext/*.rb', __dir__)).each do |path|
+  require path
+end

data/lib/stealth/{flow/core_ext.rb → core_ext/numeric.rb}

@@ -1,4 +1,3 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 class Numeric

data/lib/stealth/core_ext/string.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class String
+
+  EXCLUDED_CHARS = %w[" ' . , ! ? ( ) - _ ` ‘ ’ “ ”].freeze
+  EXCLUDED_CHARS_ESC = EXCLUDED_CHARS.map { |c| "\\#{c}" }
+  EXCLUDED_CHARS_RE = /#{EXCLUDED_CHARS_ESC.join('|')}/
+
+  # Removes blank padding and double+single quotes
+  def normalize
+    self.upcase.strip
+  end
+
+  def without_punctuation
+    self.gsub(EXCLUDED_CHARS_RE, '')
+  end
+
+end

data/lib/stealth/dispatcher.rb

@@ -30,6 +30,11 @@ module Stealth
 
     def process
       service_message = message_handler.process
+
+      if Stealth.config.transcript_logging
+        log_incoming_message(service_message)
+      end
+
       bot_controller = BotController.new(service_message: service_message)
       bot_controller.route
     end
@@ -44,5 +49,21 @@ module Stealth
         end
       end
 
+      def log_incoming_message(service_message)
+        message = if service_message.location.present?
+                    "Received: <user shared location>"
+                  elsif service_message.attachments.present?
+                    "Received: <user sent attachment>"
+                  elsif service_message.payload.present?
+                    "Received Payload: #{service_message.payload}"
+                  else
+                    "Received Message: #{service_message.message}"
+                  end
+
+        Stealth::Logger.l(
+          topic: 'user',
+          message: "User #{service_message.sender_id} -> #{message}"
+        )
+      end
   end
 end

data/lib/stealth/errors.rb

@@ -34,11 +34,23 @@ module Stealth
     class ReplyNotFound < Errors
     end
 
+    class UnrecognizedMessage < Errors
+    end
+
     class FlowError < Errors
     end
 
     class FlowDefinitionError < Errors
     end
 
+    class InvalidSessionID < Errors
+    end
+
+    class UserOptOut < Errors
+    end
+
+    class ReservedHomophoneUsed < Errors
+    end
+
   end
 end

data/lib/stealth/flow/base.rb

@@ -1,7 +1,6 @@
 # coding: utf-8
 # frozen_string_literal: true
 
-require 'stealth/flow/core_ext'
 require 'stealth/flow/specification'
 require 'stealth/flow/state'
 
@@ -55,7 +54,7 @@ module Stealth
       private
 
         def flow_and_state
-          [current_flow, current_state].join("->")
+          [current_flow, current_state].join(Stealth::Session::SLUG_SEPARATOR)
         end
 
         def state_exists?(potential_flow:, potential_state:)