stealth 1.1.3 → 2.0.0.beta2

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,7 +30,7 @@ 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)
@@ -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
@@ -60,6 +60,14 @@ module Stealth
         reply_format_not_supported(format: 'delay')
       end
 
+      def speech
+        reply_format_not_supported(format: 'speech')
+      end
+
+      def ssml
+        reply_format_not_supported(format: 'ssml')
+      end
+
     end
   end
 end

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
 

data/spec/configuration_spec.rb

@@ -1,7 +1,6 @@
-# coding: utf-8
 # frozen_string_literal: true
 
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'spec_helper'
 
 describe "Stealth::Configuration" do
 
@@ -29,6 +28,14 @@ describe "Stealth::Configuration" do
     it "should handle multiple keys at the root level" do
       expect(config.twilio_sms.account_sid).to eq parsed_config['twilio_sms']['account_sid']
     end
+
+    it "should return nil if the key is not present at the node" do
+      expect(config.twilio_sms.api_key).to be nil
+    end
+
+    it "should raise a NoMethodError when accessing multi-levels of missing nodes" do
+      expect { config.slack.api_key }.to raise_error(NoMethodError)
+    end
   end
 
   describe "config files with ERB" do
@@ -50,4 +57,37 @@ describe "Stealth::Configuration" do
     end
   end
 
+  describe "configuring with default values" do
+    let(:config) {
+      Stealth::Configuration.new(
+        { 'a' => nil, 'x' => 0, 'y' => false, 'z' => '' }
+      )
+    }
+
+    it 'should replace a nil value' do
+      config.set_default('a', 99)
+      expect(config.a).to eq 99
+    end
+
+    it 'should NOT replace a zero value' do
+      config.set_default('x', 99)
+      expect(config.x).to eq 0
+    end
+
+    it 'should NOT replace a false value' do
+      config.set_default('y', 99)
+      expect(config.y).to be false
+    end
+
+    it 'should NOT replace a blank string value' do
+      config.set_default('z', 99)
+      expect(config.z).to eq ''
+    end
+
+    it 'should replace a not-set key' do
+      config.set_default('zz', 99)
+      expect(config.zz).to eq 99
+    end
+  end
+
 end