stealth 1.1.5 → 2.0.0.beta3

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/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:)

data/lib/stealth/flow/specification.rb

@@ -19,7 +19,7 @@ module Stealth
 
       private
 
-        def state(name, fails_to: nil, redirects_to: nil)
+        def state(name, fails_to: nil, redirects_to: nil, **opts)
           fail_state = get_fail_or_redirect_state(fails_to)
           redirect_state = get_fail_or_redirect_state(redirects_to)
 
@@ -27,7 +27,8 @@ module Stealth
             name: name,
             spec: self,
             fails_to: fail_state,
-            redirects_to: redirect_state
+            redirects_to: redirect_state,
+            opts: opts
           )
 
           @initial_state = new_state if @states.empty?

data/lib/stealth/flow/state.rb

@@ -8,9 +8,9 @@ module Stealth
       include Comparable
 
       attr_accessor :name
-      attr_reader :spec, :fails_to, :redirects_to
+      attr_reader :spec, :fails_to, :redirects_to, :opts
 
-      def initialize(name:, spec:, fails_to: nil, redirects_to: nil)
+      def initialize(name:, spec:, fails_to: nil, redirects_to: nil, opts:)
         if fails_to.present? && !fails_to.is_a?(Stealth::Session)
           raise(ArgumentError, 'fails_to state should be a Stealth::Session')
         end
@@ -20,7 +20,7 @@ module Stealth
         end
 
         @name, @spec = name, spec
-        @fails_to, @redirects_to = fails_to, redirects_to
+        @fails_to, @redirects_to, @opts = fails_to, redirects_to, opts
       end
 
       def <=>(other_state)

data/lib/stealth/generators/builder/Gemfile

@@ -1,9 +1,9 @@
 source 'https://rubygems.org'
 
-gem 'stealth', '~> 1.0'
+gem 'stealth', '~> 2.0'
 
-gem 'railties', '~> 5.2'
-gem 'activerecord', '~> 5.2'
+gem 'railties', '~> 6.0'
+gem 'activerecord', '~> 6.0'
 # Use sqlite3 as the database for Active Record
 gem 'sqlite3'
 
@@ -15,4 +15,5 @@ gem 'sqlite3'
 
 group :development do
   gem 'foreman'
+  gem 'listen', '~> 3.3'
 end

data/lib/stealth/generators/builder/bot/controllers/bot_controller.rb

@@ -1,8 +1,24 @@
+# frozen_string_literal: true
+
 class BotController < Stealth::Controller
 
   helper :all
 
   def route
+    if current_message.payload.present?
+      handle_payloads
+      # Clear out the payload to prevent duplicate handling
+      current_message.payload = nil
+      return
+    end
+
+    # Allow devs to jump around flows and states by typing:
+    #   /flow_name/state_name or
+    #   /flow_name (jumps to first state) or
+    #   //state_name (jumps to state in current flow)
+    # (only works for bots in development)
+    return if dev_jump_detected?
+
     if current_session.present?
       step_to session: current_session
     else
@@ -10,4 +26,30 @@ class BotController < Stealth::Controller
     end
   end
 
+private
+
+  # Handle payloads globally since payload buttons remain in the chat
+  # and we cannot guess in which states they will be tapped.
+  def handle_payloads
+    case current_message.payload
+    when 'developer_restart', 'new_user'
+      step_to flow: 'hello', state: 'say_hello'
+    when 'goodbye'
+      step_to flow: 'goodbye'
+    end
+  end
+
+  # Automatically called when clients receive an opt-out error from
+  # the platform. You can write your own steps for handling.
+  def handle_opt_out
+    do_nothing
+  end
+
+  # Automatically called when clients receive an invalid session_id error from
+  # the platform. For example, attempting to text a landline.
+  # You can write your own steps for handling.
+  def handle_invalid_session_id
+    do_nothing
+  end
+
 end

data/lib/stealth/generators/builder/bot/controllers/catch_alls_controller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CatchAllsController < BotController
 
   def level1

data/lib/stealth/generators/builder/bot/controllers/goodbyes_controller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class GoodbyesController < BotController
 
   def say_goodbye

data/lib/stealth/generators/builder/bot/controllers/hellos_controller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class HellosController < BotController
 
   def say_hello

data/lib/stealth/generators/builder/bot/controllers/interrupts_controller.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class InterruptsController < BotController
+
+  def say_interrupted
+    do_nothing
+  end
+
+end

data/lib/stealth/generators/builder/bot/controllers/unrecognized_messages_controller.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class UnrecognizedMessagesController < BotController
+
+  def handle_unrecognized_message
+    do_nothing
+  end
+
+end

data/lib/stealth/generators/builder/config/flow_map.rb

@@ -10,6 +10,14 @@ class FlowMap
     state :say_goodbye
   end
 
+  flow :interrupt do
+    state :say_interrupted
+  end
+
+  flow :unrecognized_message do
+    state :handle_unrecognized_message
+  end
+
   flow :catch_all do
     state :level1
   end

data/lib/stealth/generators/builder/config/initializers/autoload.rb

@@ -0,0 +1,8 @@
+# Add additional directories below for hot-reloading during development.
+# You'll want to include any custom directories you create for your code.
+# To stop certain files or directories from autoloading, use autoload_ignore_paths
+
+# Stealth.config.autoload_paths << File.join(Stealth.root, 'bot', 'services')
+# Stealth.config.autoload_paths << File.join(Stealth.root, 'bot', 'jobs')
+
+# Stealth.config.autoload_ignore_paths << File.join(Stealth.root, 'bot', 'overrides')

data/lib/stealth/generators/builder/config/initializers/inflections.rb

@@ -0,0 +1,16 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new inflection rules using the following format. Inflections
+# are locale specific, and you may define rules for as many different
+# locales as you wish. All of these examples are active by default:
+# ActiveSupport::Inflector.inflections(:en) do |inflect|
+#   inflect.plural /^(ox)$/i, '\1en'
+#   inflect.singular /^(ox)en/i, '\1'
+#   inflect.irregular 'person', 'people'
+#   inflect.uncountable %w( fish sheep )
+# end
+
+# These inflection rules are supported but not enabled by default:
+# ActiveSupport::Inflector.inflections(:en) do |inflect|
+#   inflect.acronym 'RESTful'
+# end

data/lib/stealth/generators/builder/config/puma.rb

@@ -5,6 +5,21 @@ threads threads_count, threads_count
 #
 port ENV.fetch("PORT") { 3000 }
 
+# Specifies the number of `workers` to boot in clustered mode.
+# Workers are forked webserver processes. If using threads and workers together
+# the concurrency of the application would be max `threads` * `workers`.
+# Workers do not work on JRuby or Windows (both of which do not support
+# processes).
+#
+# workers ENV.fetch("WEB_CONCURRENCY") { 2 }
+
+# Use the `preload_app!` method when specifying a `workers` number.
+# This directive tells Puma to first boot the application and load code
+# before forking the application. This takes advantage of Copy On Write
+# process behavior so workers use less memory.
+#
+# preload_app!
+
 # Specifies the `environment` that Puma will run in.
 #
 environment ENV.fetch("STEALTH_ENV") { "development" }

data/lib/stealth/helpers/redis.rb

@@ -0,0 +1,40 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Stealth
+  module Redis
+    extend ActiveSupport::Concern
+
+    included do
+      private
+
+      def get_key(key, expiration: Stealth.config.session_ttl)
+        if expiration > 0
+          getex(key, expiration)
+        else
+          $redis.get(key)
+        end
+      end
+
+      def delete_key(key)
+        $redis.del(key)
+      end
+
+      def getex(key, expiration=Stealth.config.session_ttl)
+        $redis.multi do
+          $redis.expire(key, expiration)
+          $redis.get(key)
+        end.last
+      end
+
+      def persist_key(key:, value:, expiration: Stealth.config.session_ttl)
+        if expiration > 0
+          $redis.setex(key, expiration, value)
+        else
+          $redis.set(key, value)
+        end
+      end
+
+    end
+  end
+end

data/lib/stealth/lock.rb

@@ -0,0 +1,83 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Stealth
+  class Lock
+
+    include Stealth::Redis
+
+    attr_accessor :session_id, :session_slug, :position, :tid
+
+    def initialize(session_id:, session_slug: nil, position: nil)
+      @session_id = session_id
+      @session_slug = session_slug
+      @position = position
+      @tid = Stealth.tid
+    end
+
+    def self.find_lock(session_id:)
+      lock = Lock.new(session_id: session_id)
+      lock_slug = lock.slug # fetch lock from Redis
+
+      return if lock_slug.nil?
+
+      # parse the lock slug
+      tid_and_session_slug, position = lock_slug.split(':')
+      tid, session_slug = tid_and_session_slug.split('#')
+
+      # set the values from the slug to the lock object
+      lock.session_slug = session_slug
+      lock.position = position&.to_i
+      lock.tid = tid
+      lock
+    end
+
+    def create
+      if session_slug.blank?
+        raise(
+          ArgumentError,
+          'A session_slug must be specified before a lock can be created.'
+        )
+      end
+
+      # Expire locks after 30 seconds to prevent zombie locks from blocking
+      # other threads to interact with a session.
+      persist_key(
+        key: lock_key,
+        value: generate_lock,
+        expiration: Stealth.config.lock_autorelease
+      )
+    end
+
+    def release
+      delete_key(lock_key)
+    end
+
+    def slug
+      # We don't want to extend the expiration time that would result if
+      # we specified one here.
+      get_key(lock_key, expiration: 0)
+    end
+
+    # Returns a hash:
+    #   { flow: 'flow_name', state: 'state_name' }
+    def flow_and_state
+      Session.flow_and_state_from_session_slug(slug: session_slug)
+    end
+
+    private
+
+      def lock_key
+        [@session_id, 'lock'].join('-')
+      end
+
+      def generate_lock
+        if @position.present?
+          @session_slug = [@session_slug, @position].join(':')
+        end
+
+        [@tid, @session_slug].join('#')
+      end
+
+  end
+end

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, :voice, :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