stealth 1.1.6 → 2.0.0.beta1

data/lib/stealth/controller/interrupt_detect.rb

@@ -0,0 +1,100 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Stealth
+  class Controller
+    module InterruptDetect
+
+      extend ActiveSupport::Concern
+
+      include Stealth::Redis
+
+      included do
+
+        attr_reader :current_lock
+
+        def current_lock
+          @current_lock ||= Stealth::Lock.find_lock(
+            session_id: current_session_id
+          )
+        end
+
+        def run_interrupt_action
+          Stealth::Logger.l(
+            topic: 'interrupt',
+            message: "Interrupt detected for session #{current_session_id}"
+          )
+
+          unless defined?(InterruptsController)
+            Stealth::Logger.l(
+              topic: 'interrupt',
+              message: 'Ignoring interrupt; InterruptsController not defined.'
+            )
+
+            return false
+          end
+
+          interrupt_controller = InterruptsController.new(
+            service_message: current_message
+          )
+
+          begin
+            # Run say_interrupted action
+            interrupt_controller.say_interrupted
+
+            unless interrupt_controller.progressed?
+              # Log, but we cannot run the catch_all here
+              Stealth::Logger.l(
+                topic: 'interrupt',
+                message: 'Did not send replies, update session, or step'
+              )
+            end
+          rescue StandardError => e
+            # Log, but we cannot run the catch_all here
+            Stealth::Logger.l(
+              topic: 'interrupt',
+              message: [e.message, e.backtrace.join("\n")].join("\n")
+            )
+          end
+        end
+
+        private
+
+          def interrupt_detected?
+            # No interruption if there isn't an existing lock for this session
+            return false if current_lock.blank?
+
+            # No interruption if we are in the same thread
+            return false if current_thread_has_control?
+
+            true
+          end
+
+          def current_thread_has_control?
+            current_lock.tid == Stealth.tid
+          end
+
+          def lock_session!(session_slug:, position: nil)
+            lock = Stealth::Lock.new(
+              session_id: current_session_id,
+              session_slug: session_slug,
+              position: position
+            )
+
+            lock.create
+          end
+
+          # Yields control to other threads to take action on this session
+          # by releasing the lock.
+          def release_lock!
+            # We don't want to release the lock from within InterruptsController
+            # otherwise the InterruptsController can get interrupted.
+            unless self.class.to_s == 'InterruptsController'
+              current_lock&.release
+            end
+          end
+      end
+
+    end
+  end
+end

data/lib/stealth/controller/messages.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+module Stealth
+  class Controller
+    module Messages
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :normalized_msg, :homophone_translated_msg
+
+        unless defined?(ALPHA_ORDINALS)
+          ALPHA_ORDINALS = ('A'..'Z').to_a.freeze
+        end
+
+        unless defined?(NO_MATCH)
+          NO_MATCH = 0xdeadbeef
+        end
+
+        unless defined?(HOMOPHONES)
+          HOMOPHONES = {
+            'EH' => 'A',
+            'BE' => 'B',
+            'BEE' => 'B',
+            'CEE' => 'C',
+            'SEA' => 'C',
+            'SEE' => 'C',
+            'DEE' => 'D',
+            'GEE' => 'G',
+            'EYE' => 'I',
+            'AYE' => 'I',
+            'JAY' => 'J',
+            'KAY' => 'K',
+            'KAYE' => 'K',
+            'OH' => 'O',
+            'OWE' => 'O',
+            'PEA' => 'P',
+            'PEE' => 'P',
+            'CUE' => 'Q',
+            'QUEUE' => 'Q',
+            'ARR' => 'R',
+            'YOU' => 'U',
+            'YEW' => 'U',
+            'EX' => 'X',
+            'WHY' => 'Y',
+            'ZEE' => 'Z'
+          }
+        end
+
+        def normalized_msg
+          @normalized_msg ||= current_message.message.normalize
+        end
+
+        # Converts homophones into alpha-ordinals
+        def homophone_translated_msg
+          @homophone_translated_msg ||= begin
+            ord = normalized_msg.without_punctuation
+            if HOMOPHONES[ord].present?
+              HOMOPHONES[ord]
+            else
+              ord
+            end
+          end
+        end
+
+        # Hash for message and lambda pairs. If the message is matched, the
+        # lambda will be called.
+        #
+        # Example: {
+        #   "100k" => proc { step_back }, "200k" => proc { step_to flow :hello }
+        # }
+        def handle_message(message_tuples)
+          match = NO_MATCH # dummy value since nils are used for matching
+
+          if reserved_homophones_used = contains_homophones?(message_tuples.keys)
+            raise(
+              Stealth::Errors::ReservedHomophoneUsed,
+              "Cannot use `#{reserved_homophones_used.join(', ')}`. Reserved for homophones."
+            )
+          end
+
+          # Before checking content, match against our ordinals
+          if idx = message_is_an_ordinal?
+            # find the value stored in the message tuple via the index
+            matched_value = message_tuples.keys[idx]
+            match = matched_value unless matched_value.nil?
+          end
+
+          if match == NO_MATCH
+            message_tuples.keys.each_with_index do |msg, i|
+              # intent detection
+              if msg.is_a?(Symbol)
+                perform_nlp! unless nlp_result.present?
+
+                if intent_matched?(msg)
+                  match = msg
+                  break
+                else
+                  next
+                end
+              end
+
+              if msg.is_a?(Regexp)
+                if normalized_msg =~ msg
+                  match = msg
+                  break
+                else
+                  next
+                end
+              end
+
+              # custom mismatch handler; any nil key results in a match
+              if msg.nil?
+                match = msg
+                break
+              end
+
+              # check if the normalized message matches exactly
+              if message_matches?(msg)
+                match = msg
+                break
+              end
+            end
+          end
+
+          if match != NO_MATCH
+            instance_eval(&message_tuples[match])
+          else
+            handle_mismatch(true)
+          end
+        end
+
+        # Matches the message or the oridinal value entered (via SMS)
+        # Ignores case and strips leading and trailing whitespace before matching.
+        def get_match(messages, raise_on_mismatch: true, fuzzy_match: true)
+          if reserved_homophones_used = contains_homophones?(messages)
+            raise(
+              Stealth::Errors::ReservedHomophoneUsed,
+              "Cannot use `#{reserved_homophones_used.join(', ')}`. Reserved for homophones."
+            )
+          end
+
+          # Before checking content, match against our ordinals
+          if idx = message_is_an_ordinal?
+            return messages[idx] unless messages[idx].nil?
+          end
+
+          messages.each_with_index do |msg, i|
+            # entity detection
+            if msg.is_a?(Symbol)
+              perform_nlp! unless nlp_result.present?
+
+              if match = entity_matched?(msg, fuzzy_match)
+                return match
+              else
+                next
+              end
+            end
+
+            # multi-entity detection
+            if msg.is_a?(Array)
+              perform_nlp! unless nlp_result.present?
+
+              if match = entities_matched?(msg, fuzzy_match)
+                return match
+              else
+                next
+              end
+            end
+
+            if message_matches?(msg)
+              return msg
+            end
+          end
+
+          handle_mismatch(raise_on_mismatch)
+        end
+
+        private
+
+        def handle_mismatch(raise_on_mismatch)
+          log_nlp_result unless Stealth.config.log_all_nlp_results # Already logged
+
+          if raise_on_mismatch
+            raise(
+              Stealth::Errors::UnrecognizedMessage,
+              "The reply '#{current_message.message}' was not recognized."
+            )
+          else
+            current_message.message
+          end
+        end
+
+        def contains_homophones?(arr)
+          arr = arr.map do |elem|
+            elem.normalize if elem.is_a?(String)
+          end.compact
+
+          homophones = arr & HOMOPHONES.keys
+          homophones.any? ? homophones : false
+        end
+
+        # Returns the index of the ordinal, nil if not found
+        def message_is_an_ordinal?
+          ALPHA_ORDINALS.index(homophone_translated_msg)
+        end
+
+        def message_matches?(msg)
+          normalized_msg == msg.upcase
+        end
+
+        def intent_matched?(intent)
+          nlp_result.intent == intent
+        end
+
+        def entity_matched?(entity, fuzzy_match)
+          if nlp_result.entities.has_key?(entity)
+            match_count = nlp_result.entities[entity].size
+            if match_count > 1 && !fuzzy_match
+              log_nlp_result unless Stealth.config.log_all_nlp_results # Already logged
+
+              raise(
+                Stealth::Errors::UnrecognizedMessage,
+                "Encountered #{match_count} entity matches of type #{entity.inspect} and expected 1. To allow, set fuzzy_match to true."
+              )
+            else
+              # For single entity matches, just return the value
+              # rather than a single-element array
+              matched_entity = nlp_result.entities[entity].first
+
+              # Custom LUIS List entities return a single element array for some
+              # reason
+              if matched_entity.is_a?(Array) && matched_entity.size == 1
+                matched_entity.first
+              else
+                matched_entity
+              end
+            end
+          end
+        end
+
+        def entities_matched?(entities, fuzzy_match)
+          nlp_entities = nlp_result.entities.deep_dup
+          results = []
+
+          entities.each do |entity|
+            # If we run out of matches for the entity type
+            # (or never had any to begin with)
+            return false if nlp_entities[entity].blank?
+
+            results << nlp_entities[entity].shift
+          end
+
+          # Check for leftover entities for the types we were looking for
+          unless fuzzy_match
+            entities.each do |entity|
+              unless nlp_entities[entity].blank?
+                log_nlp_result unless Stealth.config.log_all_nlp_results # Already logged
+                leftover_count = nlp_entities[entity].size
+                raise(
+                  Stealth::Errors::UnrecognizedMessage,
+                  "Encountered #{leftover_count} additional entity matches of type #{entity.inspect} for match #{entities.inspect}. To allow, set fuzzy_match to true."
+                )
+              end
+            end
+          end
+
+          results
+        end
+
+        def log_nlp_result
+          # Log the results from the nlp_result if NLP was performed
+          if nlp_result.present?
+            Stealth::Logger.l(
+              topic: :nlp,
+              message: "User #{current_session_id} -> NLP Result: #{nlp_result.parsed_result.inspect}"
+            )
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/stealth/controller/nlp.rb

@@ -0,0 +1,50 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Stealth
+  class Controller
+    module Nlp
+
+      extend ActiveSupport::Concern
+
+      included do
+        # Memoized in order to prevent multiple requests to the NLP provider
+        def perform_nlp!
+          Stealth::Logger.l(
+            topic: :nlp,
+            message: "User #{current_session_id} -> Performing NLP."
+          )
+
+          unless Stealth.config.nlp_integration.present?
+            raise Stealth::Errors::ConfigurationError, "An NLP integration has not yet been configured (Stealth.config.nlp_integration)"
+          end
+
+          @nlp_result ||= begin
+            nlp_client = nlp_client_klass.new
+            @nlp_result = @current_message.nlp_result = nlp_client.understand(
+              query: current_message.message
+            )
+
+            if Stealth.config.log_all_nlp_results
+              Stealth::Logger.l(
+                topic: :nlp,
+                message: "User #{current_session_id} -> NLP Result: #{@nlp_result.parsed_result.inspect}"
+              )
+            end
+
+            @nlp_result
+          end
+        end
+
+        private
+
+        def nlp_client_klass
+          integration = Stealth.config.nlp_integration.to_s.titlecase
+          klass = "Stealth::Nlp::#{integration}::Client"
+          klass.classify.constantize
+        end
+      end
+
+    end
+  end
+end

data/lib/stealth/controller/replies.rb

@@ -12,17 +12,59 @@ 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_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,78 @@ 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', 'speech'
+                        reply['text']
+                      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