xip 0.0.1 → 2.0.0.beta2

data/lib/xip/controller/dev_jumps.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Xip
+  class Controller
+    module DevJumps
+
+      DEV_JUMP_REGEX = /\A\/(.*)\/(.*)\z|\A\/\/(.*)\z|\A\/(.*)\z/
+
+      extend ActiveSupport::Concern
+
+      included do
+        private
+
+        def dev_jump_detected?
+          if Xip.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?
+
+          Xip::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/xip/controller/dynamic_delay.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Xip
+  class Controller
+
+    module DynamicDelay
+      extend ActiveSupport::Concern
+
+      SHORT_DELAY = 3.0
+      STANDARD_DELAY = 4.3
+      LONG_DELAY = 7.0
+
+      included do
+        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'])
+          when 'image'
+            STANDARD_DELAY
+          when 'audio'
+            STANDARD_DELAY
+          when 'video'
+            STANDARD_DELAY
+          when 'file'
+            STANDARD_DELAY
+          when 'cards'
+            STANDARD_DELAY
+          when 'list'
+            STANDARD_DELAY
+          when nil
+            SHORT_DELAY
+          else
+            SHORT_DELAY
+          end
+        end
+      end
+
+      def calculate_delay_from_text(text)
+        case text.size
+        when 0..55
+          SHORT_DELAY
+        when 56..140
+          STANDARD_DELAY
+        when 141..256
+          STANDARD_DELAY * 1.5
+        else
+          LONG_DELAY
+        end
+      end
+    end
+
+  end
+end

data/lib/xip/controller/helpers.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "active_support/dependencies"
+
+module Xip
+  class Controller
+    module Helpers
+
+      extend ActiveSupport::Concern
+
+      class MissingHelperError < LoadError
+        def initialize(error, path)
+          @error = error
+          @path  = "helpers/#{path}.rb"
+          set_backtrace error.backtrace
+
+          if error.path =~ /^#{path}(\.rb)?$/
+            super("Missing helper file helpers/%s.rb" % path)
+          else
+            raise error
+          end
+        end
+      end
+
+      # class << self; attr_accessor :helpers_path; end
+
+      included do
+        class_attribute :_helpers, default: Module.new
+        class_attribute :helpers_path, default: ["bot/helpers"]
+        class_attribute :include_all_helpers, default: true
+      end
+
+      class_methods do
+        # When a class is inherited, wrap its helper module in a new module.
+        # This ensures that the parent class's module can be changed
+        # independently of the child class's.
+        def inherited(subclass)
+          helpers = _helpers
+          subclass._helpers = Module.new { include helpers }
+
+          if subclass.superclass == Xip::Controller && Xip::Controller.include_all_helpers
+            subclass.helper :all
+          else
+            subclass.class_eval { default_helper_module! } unless subclass.anonymous?
+          end
+
+          include subclass._helpers
+
+          super
+        end
+
+        def modules_for_helpers(args)
+          # Allow all helpers to be included
+          args += all_bot_helpers if args.delete(:all)
+
+          # Add each helper_path to the LOAD_PATH
+          Array(helpers_path).each {|path| $:.unshift(path) }
+
+          args.flatten.map! do |arg|
+            case arg
+            when String, Symbol
+              file_name = "#{arg.to_s.underscore}_helper"
+              begin
+                require_dependency(file_name)
+              rescue LoadError => e
+                raise Xip::Controller::Helpers::MissingHelperError.new(e, file_name)
+              end
+
+              mod_name = file_name.camelize
+              begin
+                mod_name.constantize
+              rescue LoadError
+                raise NameError, "Couldn't find #{mod_name}, expected it to be defined in helpers/#{file_name}.rb"
+              end
+            when Module
+              arg
+            else
+              raise ArgumentError, "helper must be a String, Symbol, or Module"
+            end
+          end
+        end
+
+        def helper(*args, &block)
+          modules_for_helpers(args).each do |mod|
+            add_template_helper(mod)
+          end
+
+          _helpers.module_eval(&block) if block_given?
+        end
+
+        def default_helper_module!
+          module_name = name.sub(/Controller$/, "".freeze)
+          module_path = module_name.underscore
+          helper module_path
+        rescue LoadError => e
+          raise e unless e.is_missing? "helpers/#{module_path}_helper"
+        rescue NameError => e
+          raise e unless e.missing_name? "#{module_name}Helper"
+        end
+
+        # Returns a list of helper names in a given path.
+        #
+        #   Xip::Controller.all_helpers_from_path 'bot/helpers'
+        #   # => ["bot", "estimates", "tickets"]
+        def all_helpers_from_path(path)
+          helpers = Array(path).flat_map do |_path|
+            extract = /^#{Regexp.quote(_path.to_s)}\/?(.*)_helper.rb$/
+            names = Dir["#{_path}/**/*_helper.rb"].map { |file| file.sub(extract, '\1'.freeze) }
+            names.sort!
+          end
+          helpers.uniq!
+          helpers
+        end
+
+        private
+          def add_template_helper(mod)
+            _helpers.module_eval { include mod }
+          end
+
+          # Extract helper names from files in "bot/helpers/**/*_helper.rb"
+          def all_bot_helpers
+            all_helpers_from_path(helpers_path)
+          end
+      end
+
+    end
+  end
+end

data/lib/xip/controller/interrupt_detect.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Xip
+  class Controller
+    module InterruptDetect
+
+      extend ActiveSupport::Concern
+
+      include Xip::Redis
+
+      included do
+
+        attr_reader :current_lock
+
+        def current_lock
+          @current_lock ||= Xip::Lock.find_lock(
+            session_id: current_session_id
+          )
+        end
+
+        def run_interrupt_action
+          Xip::Logger.l(
+            topic: 'interrupt',
+            message: "Interrupt detected for session #{current_session_id}"
+          )
+
+          unless defined?(InterruptsController)
+            Xip::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
+              Xip::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
+            Xip::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 == Xip.tid
+          end
+
+          def lock_session!(session_slug:, position: nil)
+            lock = Xip::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/xip/controller/messages.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+module Xip
+  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(
+              Xip::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(
+              Xip::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 Xip.config.log_all_nlp_results # Already logged
+
+          if raise_on_mismatch
+            raise(
+              Xip::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 Xip.config.log_all_nlp_results # Already logged
+
+              raise(
+                Xip::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 Xip.config.log_all_nlp_results # Already logged
+                leftover_count = nlp_entities[entity].size
+                raise(
+                  Xip::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?
+            Xip::Logger.l(
+              topic: :nlp,
+              message: "User #{current_session_id} -> NLP Result: #{nlp_result.parsed_result.inspect}"
+            )
+          end
+        end
+
+      end
+    end
+  end
+end