stealth 1.1.2 → 2.0.0.beta1

data/lib/stealth/controller/unrecognized_message.rb

@@ -0,0 +1,62 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Stealth
+  class Controller
+    module UnrecognizedMessage
+
+      extend ActiveSupport::Concern
+
+      included do
+
+        def run_unrecognized_message(err:)
+          err_message = "The message \"#{current_message.message}\" was not recognized in the original context."
+
+          Stealth::Logger.l(
+            topic: 'unrecognized_message',
+            message: err_message
+          )
+
+          unless defined?(UnrecognizedMessagesController)
+            Stealth::Logger.l(
+              topic: 'unrecognized_message',
+              message: 'Running catch_all; UnrecognizedMessagesController not defined.'
+            )
+
+            run_catch_all(err: err)
+            return false
+          end
+
+          unrecognized_msg_controller = UnrecognizedMessagesController.new(
+            service_message: current_message
+          )
+
+          begin
+            # Run handle_unrecognized_message action
+            unrecognized_msg_controller.handle_unrecognized_message
+
+            if unrecognized_msg_controller.progressed?
+              Stealth::Logger.l(
+                topic: 'unrecognized_message',
+                message: 'A match was detected. Skipping catch-all.'
+              )
+            else
+              # Log, but we don't want to run the catch_all for a poorly
+              # coded UnrecognizedMessagesController
+              Stealth::Logger.l(
+                topic: 'unrecognized_message',
+                message: 'Did not send replies, update session, or step'
+              )
+            end
+          rescue StandardError => e
+            # Run the catch_all directly since we're already in an unrecognized
+            # message state
+            run_catch_all(err: e)
+          end
+        end
+
+      end
+
+    end
+  end
+end

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/{flow/core_ext.rb → core_ext/numeric.rb}

@@ -1,4 +1,3 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 class Numeric

data/lib/stealth/core_ext/string.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class String
+
+  EXCLUDED_CHARS = %w[" ' . , ! ? ( ) - _ ` ‘ ’ “ ”].freeze
+  EXCLUDED_CHARS_ESC = EXCLUDED_CHARS.map { |c| "\\#{c}" }
+  EXCLUDED_CHARS_RE = /#{EXCLUDED_CHARS_ESC.join('|')}/
+
+  # Removes blank padding and double+single quotes
+  def normalize
+    self.upcase.strip
+  end
+
+  def without_punctuation
+    self.gsub(EXCLUDED_CHARS_RE, '')
+  end
+
+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.1'
 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