stealth 1.1.2 → 2.0.0.beta1

data/lib/stealth/logger.rb

@@ -13,7 +13,8 @@ module Stealth
       magenta:      35,
       cyan:         36,
       gray:         37,
-      light_cyan:   96
+      light_cyan:   96,
+      white:        97
     ].freeze
 
     def self.color_code(code)
@@ -26,29 +27,37 @@ module Stealth
 
     def self.log(topic:, message:)
       unless ENV['STEALTH_ENV'] == 'test'
-        puts "#{print_topic(topic)} #{message}"
+        puts "TID-#{Stealth.tid} #{print_topic(topic)} #{message}"
       end
     end
 
     def self.print_topic(topic)
       topic_string = "[#{topic}]"
 
-      case topic.to_sym
-      when :session
-        colorize(topic_string, color: :green)
-      when :previous_session
-        colorize(topic_string, color: :yellow)
-      when :facebook, :twilio
-        colorize(topic_string, color: :blue)
-      when :smooch
-        colorize(topic_string, color: :magenta)
-      when :alexa
-        colorize(topic_string, color: :light_cyan)
-      when :catch_all
-        colorize(topic_string, color: :red)
-      else
-        colorize(topic_string, color: :gray)
-      end
+      color = case topic.to_sym
+              when :primary_session
+                :green
+              when :previous_session, :back_to_session
+                :yellow
+              when :interrupt
+                :magenta
+              when :facebook, :twilio, :bandwidth
+                :blue
+              when :smooch
+                :magenta
+              when :alexa, :unrecognized_message
+                :light_cyan
+              when :nlp
+                :cyan
+              when :catch_all, :err
+                :red
+              when :user
+                :white
+              else
+                :gray
+              end
+
+      colorize(topic_string, color: color)
     end
 
     class << self

data/lib/stealth/nlp/client.rb

@@ -0,0 +1,22 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Stealth
+  module Nlp
+    class Client
+
+      def client
+        nil
+      end
+
+      def understand(query:)
+        nil
+      end
+
+      def understand_speech(audio_file:, audio_config: nil)
+        nil
+      end
+    end
+
+  end
+end

data/lib/stealth/nlp/result.rb

@@ -0,0 +1,57 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Stealth
+  module Nlp
+    class Result
+
+      ENTITY_TYPES = %i(number currency email percentage phone age
+                        url ordinal geo dimension temp datetime duration
+                        key_phrase name)
+
+      attr_reader :result
+
+      def initialize(result:)
+        @result = result
+      end
+
+      def parsed_result
+        nil
+      end
+
+      def intent_id
+        nil
+      end
+
+      def intent
+        nil
+      end
+
+      def intent_score
+        nil
+      end
+
+      def raw_entities
+        {}
+      end
+
+      def entities
+        {}
+      end
+
+      # :postive, :negative, :neutral
+      def sentiment
+        nil
+      end
+
+      def sentiment_score
+        nil
+      end
+
+      def present?
+        parsed_result.present?
+      end
+
+    end
+  end
+end

data/lib/stealth/reloader.rb

@@ -0,0 +1,90 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+require 'zeitwerk'
+
+module Stealth
+  class Reloader
+
+    def initialize
+      @reloader = Class.new(ActiveSupport::Reloader)
+      @loader = Zeitwerk::Loader.new
+      # @loader.logger = method(:puts)
+      @loader
+    end
+
+    def load_bot!
+      load_autoload_paths!
+      enable_reloading!
+      enable_eager_load!
+      @loader.setup
+    end
+
+    def load_autoload_paths!
+      if Stealth.config.autoload_paths.present?
+        Stealth.config.autoload_paths.each do |autoload_path|
+          @loader.push_dir(autoload_path)
+        end
+
+        # Bot-specific ignores
+        Stealth.config.autoload_ignore_paths.each do |autoload_ignore_path|
+          @loader.ignore(autoload_ignore_path)
+        end
+
+        # Ignore setup files
+        @loader.ignore(File.join(Stealth.root, 'config', 'initializers'))
+        @loader.ignore(File.join(Stealth.root, 'config', 'boot.rb'))
+        @loader.ignore(File.join(Stealth.root, 'config', 'environment.rb'))
+        @loader.ignore(File.join(Stealth.root, 'config', 'puma.rb'))
+      end
+    end
+
+    def enable_eager_load!
+      if Stealth.config.eager_load
+        @loader.eager_load
+        Stealth::Logger.l(topic: 'stealth', message: 'Eager loading enabled.')
+      end
+    end
+
+    def enable_reloading!
+      if Stealth.config.hot_reload
+        @checker = ActiveSupport::EventedFileUpdateChecker.new([], files_to_watch) do
+          reload!
+        end
+
+        @loader.enable_reloading
+        Stealth::Logger.l(topic: 'stealth', message: 'Hot reloading enabled.')
+      end
+    end
+
+    # Only reloads if a change has been detected in one of the autoload files`
+    def reload
+      if Stealth.config.hot_reload
+        @checker.execute_if_updated
+      end
+    end
+
+    # Force reloads reglardless of filesystem changes
+    def reload!
+      if Stealth.config.hot_reload
+        @loader.reload
+      end
+    end
+
+    def call
+      @reloader.wrap do
+        reload
+        yield
+      end
+    end
+
+    private
+
+      def files_to_watch
+        Stealth.config.autoload_paths.map do |path|
+          [path, 'rb']
+        end.to_h
+      end
+
+  end
+end

data/lib/stealth/reply.rb

@@ -15,5 +15,22 @@ module Stealth
       @reply[key]
     end
 
+    def []=(key, value)
+      @reply[key] = value
+    end
+
+    def delay?
+      reply_type == 'delay'
+    end
+
+    def self.dynamic_delay
+      self.new(
+        unstructured_reply: {
+          'reply_type' => 'delay',
+          'duration' => 'dynamic'
+        }
+      )
+    end
+
   end
 end

data/lib/stealth/scheduled_reply.rb

@@ -6,12 +6,12 @@ module Stealth
   class ScheduledReplyJob < Stealth::Jobs
     sidekiq_options queue: :stealth_replies, retry: false
 
-    def perform(service, user_id, flow, state)
+    def perform(service, user_id, flow, state, target_id=nil)
       service_message = ServiceMessage.new(service: service)
       service_message.sender_id = user_id
+      service_message.target_id = target_id
       controller = BotController.new(service_message: service_message)
-      controller.update_session_to(flow: flow, state: state)
-      controller.route
+      controller.step_to(flow: flow, state: state)
     end
   end
 

data/lib/stealth/server.rb

@@ -30,10 +30,10 @@ module Stealth
     end
 
     get_or_post '/incoming/:service' do
-      Stealth::Logger.l(topic: "incoming", message: "Received webhook from #{params[:service]}")
+      Stealth::Logger.l(topic: params[:service], message: 'Received webhook.')
 
       # JSON params need to be parsed and added to the params
-      if request.env['CONTENT_TYPE'].match(/application\/json/i)
+      if request.env['CONTENT_TYPE']&.match(/application\/json/i)
         json_params = MultiJson.load(request.body.read)
         params.merge!(json_params)
       end
@@ -50,8 +50,8 @@ module Stealth
     private
 
       def get_helpers_from_request(request)
-        request.env.reject do |header, value|
-          header.match(/rack\.|puma\.|sinatra\./)
+        request.env.select do |header, value|
+          %w[HTTP_HOST].include?(header)
         end
       end
 

data/lib/stealth/service_message.rb

@@ -4,8 +4,9 @@
 module Stealth
   class ServiceMessage
 
-    attr_accessor :sender_id, :timestamp, :service, :message, :location,
-                  :attachments, :payload, :referral
+    attr_accessor :sender_id, :target_id, :timestamp, :service, :message,
+                  :location, :attachments, :payload, :referral, :nlp_result,
+                  :catch_all_reason
 
     def initialize(service:)
       @service = service

data/lib/stealth/service_reply.rb

@@ -18,7 +18,11 @@ module Stealth
         @yaml_reply
       end
 
-      @replies = load_replies(YAML.load(processed_reply))
+      if yaml_reply.is_a?(Array)
+        @replies = load_replies(@yaml_reply)
+      else
+        @replies = load_replies(YAML.load(processed_reply))
+      end
     end
 
     private

data/lib/stealth/services/base_reply_handler.rb

@@ -8,8 +8,8 @@ module Stealth
       attr_reader :recipient_id, :reply
 
       def initialize(recipient_id:, reply:)
-        @client = client
-        @options = options
+        @recipient_id = recipient_id
+        @reply = reply
       end
 
       def text

data/lib/stealth/session.rb

@@ -4,21 +4,30 @@
 module Stealth
   class Session
 
+    include Stealth::Redis
+
     SLUG_SEPARATOR = '->'
 
-    attr_reader :flow, :state, :user_id, :previous
+    attr_reader :flow, :state, :id, :type
     attr_accessor :session
 
-    def initialize(user_id: nil, previous: false)
-      @user_id = user_id
-      @previous = previous
+    # Session types:
+    #   - :primary
+    #   - :previous
+    #   - :back_to
+    def initialize(id: nil, type: :primary)
+      @id = id
+      @type = type
 
-      if user_id.present?
+      if id.present?
         unless defined?($redis) && $redis.present?
-          raise(Stealth::Errors::RedisNotConfigured, "Please make sure REDIS_URL is configured before using sessions")
+          raise(
+            Stealth::Errors::RedisNotConfigured,
+            "Please make sure REDIS_URL is configured before using sessions"
+          )
         end
 
-        get
+        get_session
       end
 
       self
@@ -31,6 +40,14 @@ module Stealth
       }
     end
 
+    def self.slugify(flow:, state:)
+      unless flow.present? && state.present?
+        raise(ArgumentError, 'A flow and state must be specified.')
+      end
+
+      [flow, state].join(SLUG_SEPARATOR)
+    end
+
     def flow
       return nil if flow_string.blank?
 
@@ -49,31 +66,32 @@ module Stealth
       session&.split(SLUG_SEPARATOR)&.last
     end
 
-    def get
-      prev_key = previous_session_key(user_id: user_id)
-
-      @session ||= begin
-        if sessions_expire?
-          previous? ? getex(prev_key) : getex(user_id)
-        else
-          previous? ? $redis.get(prev_key) : $redis.get(user_id)
-        end
-      end
+    def get_session
+      @session ||= get_key(session_key)
     end
 
-    def set(flow:, state:)
-      store_current_to_previous(flow: flow, state: state)
-
-      @flow = nil
-      @session = self.class.canonical_session_slug(flow: flow, state: state)
+    def set_session(new_flow:, new_state:)
+      @flow = nil # override @flow's memoization
+      existing_session = session # tmp backup for previous_session storage
+      @session = self.class.canonical_session_slug(
+        flow: new_flow,
+        state: new_state
+      )
+
+      Stealth::Logger.l(
+        topic: [type, 'session'].join('_'),
+        message: "User #{id}: setting session to #{new_flow}->#{new_state}"
+      )
+
+      if primary_session?
+        store_current_to_previous(existing_session: existing_session)
+      end
 
-      Stealth::Logger.l(topic: "session", message: "User #{user_id}: setting session to #{flow}->#{state}")
+      persist_key(key: session_key, value: session)
+    end
 
-      if sessions_expire?
-        $redis.setex(user_id, Stealth.config.session_ttl, session)
-      else
-        $redis.set(user_id, session)
-      end
+    def clear_session
+      $redis.del(session_key)
     end
 
     def present?
@@ -84,17 +102,16 @@ module Stealth
       !present?
     end
 
-    def previous?
-      @previous
-    end
-
     def +(steps)
       return nil if flow.blank?
       return self if steps.zero?
 
       new_state = self.state + steps
-      new_session = Stealth::Session.new(user_id: self.user_id)
-      new_session.session = self.class.canonical_session_slug(flow: self.flow_string, state: new_state)
+      new_session = Stealth::Session.new(id: self.id)
+      new_session.session = self.class.canonical_session_slug(
+        flow: self.flow_string,
+        state: new_state
+      )
 
       new_session
     end
@@ -109,6 +126,13 @@ module Stealth
       end
     end
 
+    def ==(other_session)
+      self.flow_string == other_session.flow_string &&
+        self.state_string == other_session.state_string &&
+        self.type == other_session.type &&
+        self.id == other_session.id
+    end
+
     def self.is_a_session_string?(string)
       session_regex = /(.+)(#{SLUG_SEPARATOR})(.+)/
       !!string.match(session_regex)
@@ -118,32 +142,61 @@ module Stealth
       [flow, state].join(SLUG_SEPARATOR)
     end
 
-    private
-
-      def previous_session_key(user_id:)
-        [user_id, 'previous'].join('-')
+    def session_key
+      case type
+      when :primary
+        id
+      when :previous
+        previous_session_key
+      when :back_to
+        back_to_key
       end
+    end
 
-      def store_current_to_previous(flow:, state:)
-        new_session = self.class.canonical_session_slug(flow: flow, state: state)
+    def primary_session?
+      type == :primary
+    end
 
-        # Prevent previous_session from becoming current_session
-        if new_session == session
-          Stealth::Logger.l(topic: "previous_session", message: "User #{user_id}: skipping setting to #{session} because it is the same as current_session")
-        else
-          Stealth::Logger.l(topic: "previous_session", message: "User #{user_id}: setting to #{session}")
-          $redis.set(previous_session_key(user_id: user_id), session)
-        end
+    def previous_session?
+      type == :previous
+    end
+
+    def back_to_session?
+      type == :back_to
+    end
+
+    def to_s
+      [flow_string, state_string].join(SLUG_SEPARATOR)
+    end
+
+    private
+
+      def previous_session_key
+        [id, 'previous'].join('-')
       end
 
-      def sessions_expire?
-        Stealth.config.session_ttl > 0
+      def back_to_key
+        [id, 'back_to'].join('-')
       end
 
-      def getex(key)
-        $redis.multi do
-          $redis.expire(key, Stealth.config.session_ttl)
-          $redis.get(key)
+      def store_current_to_previous(existing_session:)
+        # Prevent previous_session from becoming current_session
+        if session == existing_session
+          Stealth::Logger.l(
+            topic: "previous_session",
+            message: "User #{id}: skipping setting to #{session}"\
+                     ' because it is the same as current_session'
+          )
+        else
+          Stealth::Logger.l(
+            topic: "previous_session",
+            message: "User #{id}: setting to #{existing_session}"
+          )
+
+          persist_key(
+            key: previous_session_key,
+            value: existing_session
+          )
         end
       end