xip 0.0.1 → 2.0.0.beta2

data/lib/xip/cli_base.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Xip
+  module CliBase
+    def define_commands(&blk)
+      class_eval(&blk) if block_given?
+    end
+
+    def banner(command, nspace = true, subcommand = false)
+      super(command, nspace, namespace != 'xip:cli')
+    end
+
+    def handle_argument_error(command, error, args, arity)
+      name = [(namespace == 'xip:cli' ? nil : namespace), command.name].compact.join(" ")
+
+      msg = "ERROR: \"#{basename} #{name}\" was called with "
+      msg << "no arguments"               if     args.empty?
+      msg << "arguments " << args.inspect unless args.empty?
+      msg << "\nUsage: #{banner(command).inspect}"
+
+      raise Thor::InvocationError, msg
+    end
+  end
+end

data/lib/xip/commands/command.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'xip'
+
+module Xip
+  module Commands
+    class Command
+      def initialize(options)
+
+      end
+    end
+  end
+end

data/lib/xip/commands/console.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'xip/commands/command'
+
+module Xip
+  module Commands
+    # REPL that supports different engines.
+    #
+    # It is run with:
+    #
+    #   `bundle exec xip console`
+    class Console < Command
+      module CodeReloading
+        def reload!
+          puts 'Reloading...'
+          Kernel.exec "#{$PROGRAM_NAME} console"
+        end
+      end
+
+      # Supported engines
+      ENGINES = {
+        'pry'  => 'Pry',
+        'ripl' => 'Ripl',
+        'irb'  => 'IRB'
+      }.freeze
+
+      DEFAULT_ENGINE = ['irb'].freeze
+
+      attr_reader :options
+
+      def initialize(options)
+        super(options)
+
+        @options = options
+      end
+
+      def start
+        prepare
+        engine.start
+      end
+
+      def engine
+        load_engine options.fetch(:engine) { engine_lookup }
+      end
+
+    private
+
+      def prepare
+        # Clear out ARGV so Pry/IRB don't attempt to parse the rest
+        ARGV.shift until ARGV.empty?
+
+        # Add convenience methods to the main:Object binding
+        TOPLEVEL_BINDING.eval('self').__send__(:include, CodeReloading)
+
+        Xip.boot
+      end
+
+      def engine_lookup
+        (ENGINES.find { |_, klass| Object.const_defined?(klass) } || DEFAULT_ENGINE).first
+      end
+
+      def load_engine(engine)
+        require engine
+      rescue LoadError
+      ensure
+        return Object.const_get(
+          ENGINES.fetch(engine) do
+            raise ArgumentError.new("Unknown console engine: `#{engine}'")
+          end
+        )
+      end
+    end
+  end
+end

data/lib/xip/commands/server.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'rack/handler/puma'
+require 'xip/commands/command'
+
+module Xip
+  module Commands
+    class Server < Command
+      def initialize(port:)
+        @port = port
+        $stdout.sync = true
+      end
+
+      def start
+        # Rack::Handler::Puma.run(Xip::Server)
+        puts ascii_art
+        exec "foreman start -f Procfile.dev -p #{@port}"
+      end
+
+      private
+
+        def ascii_art
+          <<~ART
+            \e[36m,,,,,,,,,,,\e[0m                                      \e[32m,,,,,,..,,,,,\e[0m
+          \e[36m░░░░░░░░░░░░░░≥\e[0m                                  \e[32m╔╬╠╠╠╠╠╠╠╠╠╠╠╠╠⌐\e[0m
+          \e[36m░░░░░░░░░░░░░░░░≥,\e[0m                             \e[32mé╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠⌐\e[0m
+          \e[36m░░░░░░░░░░░░░░░░░░░,\e[0m                        \e[32m,@╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠⌐\e[0m
+          \e[36m░░░░░░░░░░░░░░░░░░░░▒≥\e[0m                    \e[32m╓╬╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠⌐\e[0m
+          \e[36m░░░░░░░░░░░░░░░░░░░░░░░≥\e[0m                \e[32m╓╬╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠⌐\e[0m
+          \e[36m░░░░░░░░░░░░░░░░░░░░░░░░░≥\e[0m            \e[32m╔╬╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠⌐\e[0m
+           \e[36m`╚░░░░░░░░░░░░░░░░░░░░░░░░≥,\e[0m       \e[32mé╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╜\e[0m
+             \e[36m`╙░░░░░░░░░░░░░░░░░░░░░░░░\e[0m      \e[32m╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╙\e[0m
+                \e[36m%░░░░░░░░░░░░░░░░░░░░░░\e[0m      \e[32m╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╬"\e[0m
+                  \e[36m"░░░░░░░░░░░░░░░░░░░░\e[0m      \e[32m╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╩\e[0m
+                    \e[36m"░░░░░░░░░░░░░░░░░░\e[0m      \e[32m╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╩²\e[0m
+                      \e[36m`╚░░░░░░░░░░░░░░░\e[0m      \e[32m╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╜\e[0m
+                        \e[36m`╙░░░░░░░░░░░░░\e[0m      \e[32m╠╠╠╠╠╠╠╠╠╠╠╠╠╠╙\e[0m
+
+
+                        \e[32m╔φφφφφφφφφφφφφ\e[0m       \e[36m≥≥≥≥≥≥≥≥≥≥≥≥≥≥\e[0m
+                       \e[32m╔╬╠╠╠╠╠╠╠╠╠╠╠╠╠╠\e[0m      \e[36m░░░░░░░░░░░░░░░≥\e[0m
+                    \e[32m,#╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠\e[0m      \e[36m░░░░░░░░░░░░░░░░░≥\e[0m
+                  \e[32m,ê╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠\e[0m      \e[36m░░░░░░░░░░░░░░░░░░░≥,\e[0m
+                \e[32m²╬╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠\e[0m      \e[36m░░░░░░░░░░░░░░░░░░░░░░,\e[0m
+              \e[32m╔╬╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠\e[0m      \e[36m░░░░░░░░░░░░░░░░░░░░░░░▒≥\e[0m
+            \e[32m╔╬╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╩\e[0m      \e[36m"░░░░░░░░░░░░░░░░░░░░░░░░░≥\e[0m
+          \e[32m#╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╜ \e[0m         \e[36m"░░░░░░░░░░░░░░░░░░░░░░░░░≥\e[0m
+          \e[32m╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╙ \e[0m             \e[36m`≥░░░░░░░░░░░░░░░░░░░░░░░\e[0m
+          \e[32m╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╩" \e[0m                  \e[36m░░░░░░░░░░░░░░░░░░░░░░\e[0m
+          \e[32m╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╩ \e[0m                       \e[36m²░░░░░░░░░░░░░░░░░░░\e[0m
+          \e[32m╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╩ \e[0m                           \e[36m"░░░░░░░░░░░░░░░░░\e[0m
+          \e[32m╠╠╠╠╠╠╠╠╠╠╠╠╠╠╠╜ \e[0m                               \e[36m"░░░░░░░░░░░░░░░\e[0m
+          \e[32m╚╚╚╚╚╩╩╩╩╩╩╩╩╙ \e[0m                                   \e[36m`============²\e[0m
+
+
+
+                                Xip v#{Xip::VERSION}
+
+          ART
+        end
+    end
+  end
+end

data/lib/xip/configuration.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Xip
+  class Configuration < Hash
+
+    def initialize(hash)
+      hash.each do |k, v|
+        self[k] = store(v)
+      end
+
+      self
+    end
+
+    def method_missing(method, *args)
+      key = create_config_attribute(method)
+
+      if setter?(method)
+        self[key] = args.first
+      else
+        self[key]
+      end
+    end
+
+    def set_default(key, default_value)
+      if self[key.to_s] == nil
+        self[key.to_s] = store(default_value)
+      end
+    end
+
+    private
+
+      def store(value)
+        if value.is_a?(Hash)
+          Xip::Configuration.new(value)
+        else
+          value
+        end
+      end
+
+      def setter?(method)
+        method.slice(-1, 1) == "="
+      end
+
+      def create_config_attribute(method)
+        key = basic_config_attribute_from_method(method)
+
+        key?(key.to_s) ? key.to_s : key
+      end
+
+      def basic_config_attribute_from_method(method)
+        setter?(method) ? method.to_s.chop : method
+      end
+
+  end
+
+end

data/lib/xip/controller/callbacks.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Xip
+  class Controller
+    module Callbacks
+
+      extend ActiveSupport::Concern
+
+      include ActiveSupport::Callbacks
+
+      included do
+        define_callbacks :action, skip_after_callbacks_if_terminated: true
+      end
+
+      class_methods do
+        def _normalize_callback_options(options)
+          _normalize_callback_option(options, :only, :if)
+          _normalize_callback_option(options, :except, :unless)
+        end
+
+        def _normalize_callback_option(options, from, to)
+          if from = options[from]
+            _from = Array(from).map(&:to_s).to_set
+            from = proc { |c| _from.include?(c.action_name) }
+            options[to] = Array(options[to]).unshift(from)
+          end
+        end
+
+        def _insert_callbacks(callbacks, block = nil)
+          options = callbacks.extract_options!
+          _normalize_callback_options(options)
+          callbacks.push(block) if block
+          callbacks.each do |callback|
+            yield callback, options
+          end
+        end
+
+        [:before, :after, :around].each do |callback|
+          define_method "#{callback}_action" do |*names, &blk|
+            _insert_callbacks(names, blk) do |name, options|
+              set_callback(:action, callback, name, options)
+            end
+          end
+
+          define_method "prepend_#{callback}_action" do |*names, &blk|
+            _insert_callbacks(names, blk) do |name, options|
+              set_callback(:action, callback, name, options.merge(prepend: true))
+            end
+          end
+
+          define_method "skip_#{callback}_action" do |*names|
+            _insert_callbacks(names) do |name, options|
+              skip_callback(:action, callback, name, options)
+            end
+          end
+
+          alias_method :"append_#{callback}_action", :"#{callback}_action"
+        end
+      end
+
+    end
+  end
+end

data/lib/xip/controller/catch_all.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Xip
+  class Controller
+    module CatchAll
+
+      extend ActiveSupport::Concern
+
+      included do
+
+        def run_catch_all(err:)
+          error_level = fetch_error_level
+
+          if err.class == Xip::Errors::UnrecognizedMessage
+            Xip::Logger.l(
+              topic: 'catch_all',
+              message: "[Level #{error_level}] for user #{current_session_id} #{err.message}"
+            )
+          else
+            Xip::Logger.l(
+              topic: 'catch_all',
+              message: "[Level #{error_level}] for user #{current_session_id} #{[err.class, err.message, err.backtrace.join("\n")].join("\n")}"
+            )
+          end
+
+          # Store the reason so it can be accessed by the CatchAllsController
+          current_message.catch_all_reason = {
+            err: err.class,
+            err_msg: err.message
+          }
+
+          # Don't run catch_all from the catch_all controller
+          if current_session.flow_string == 'catch_all'
+            Xip::Logger.l(topic: 'catch_all', message: "CatchAll triggered for user #{current_session_id} from within CatchAll; ignoring.")
+            return false
+          end
+
+          if defined?(CatchAllsController) && FlowMap.flow_spec[:catch_all].present?
+            catch_all_state = calculate_catch_all_state(error_level)
+
+            if FlowMap.flow_spec[:catch_all].states.keys.include?(catch_all_state.to_sym)
+              step_to flow: :catch_all, state: catch_all_state
+            else
+              # We are out of bounds, do nothing to prevent an infinite loop
+              Xip::Logger.l(topic: 'catch_all', message: "Stopping; we\'ve exceeded the number of defined catch_all states for user #{current_session_id}.")
+              return false
+            end
+          end
+        end
+
+        private
+
+          def fetch_error_level
+            if fail_attempts = $redis.get(error_slug)
+              begin
+                fail_attempts = Integer(fail_attempts)
+              rescue ArgumentError
+                fail_attempts = 1
+              end
+
+              fail_attempts += 1
+            else
+              fail_attempts = 1
+            end
+
+            # Set the error with an expiration to avoid filling Redis
+            $redis.setex(error_slug, 15.minutes.to_i, fail_attempts)
+
+            fail_attempts
+          end
+
+          def error_slug
+            ['error', current_session_id, current_session.flow_string, current_session.state_string].join('-')
+          end
+
+          def calculate_catch_all_state(error_level)
+            "level#{error_level}"
+          end
+
+      end
+
+    end
+  end
+end

data/lib/xip/controller/controller.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+module Xip
+  class Controller
+
+    include Xip::Controller::Callbacks
+    include Xip::Controller::DynamicDelay
+    include Xip::Controller::Replies
+    include Xip::Controller::Messages
+    include Xip::Controller::UnrecognizedMessage
+    include Xip::Controller::CatchAll
+    include Xip::Controller::Helpers
+    include Xip::Controller::InterruptDetect
+    include Xip::Controller::DevJumps
+    include Xip::Controller::Nlp
+
+    attr_reader :current_message, :current_service, :flow_controller,
+                :action_name, :current_session_id
+    attr_accessor :nlp_result, :pos
+
+    def initialize(service_message:, pos: nil)
+      @current_message = service_message
+      @current_service = service_message.service
+      @current_session_id = service_message.sender_id
+      @nlp_result = service_message.nlp_result
+      @pos = pos
+      @progressed = false
+    end
+
+    def has_location?
+      current_message.location.present?
+    end
+
+    def has_attachments?
+      current_message.attachments.present?
+    end
+
+    def progressed?
+      @progressed
+    end
+
+    def route
+      raise(Xip::Errors::ControllerRoutingNotImplemented, "Please implement `route` method in BotController")
+    end
+
+    def flow_controller
+      @flow_controller ||= begin
+        flow_controller = [current_session.flow_string.pluralize, 'controller'].join('_').classify.constantize
+        flow_controller.new(service_message: @current_message, pos: @pos)
+      end
+    end
+
+    def current_session
+      @current_session ||= Xip::Session.new(id: current_session_id)
+    end
+
+    def previous_session
+      @previous_session ||= Xip::Session.new(
+        id: current_session_id,
+        type: :previous
+      )
+    end
+
+    def action(action: nil)
+      begin
+        # Grab a mutual exclusion lock on the session
+        lock_session!(
+          session_slug: Session.slugify(
+            flow: current_session.flow_string,
+            state: current_session.state_string
+          )
+        )
+
+        @action_name = action
+        @action_name ||= current_session.state_string
+
+        # Check if the user needs to be redirected
+        if current_session.flow.current_state.redirects_to.present?
+          Xip::Logger.l(
+            topic: "redirect",
+            message: "From #{current_session.session} to #{current_session.flow.current_state.redirects_to.session}"
+          )
+          step_to(session: current_session.flow.current_state.redirects_to, pos: @pos)
+          return
+        end
+
+        run_callbacks :action do
+          begin
+            flow_controller.send(@action_name)
+            unless flow_controller.progressed?
+              run_catch_all(reason: 'Did not send replies, update session, or step')
+            end
+          rescue StandardError => e
+            if e.class == Xip::Errors::UnrecognizedMessage
+              run_unrecognized_message(err: e)
+            else
+              run_catch_all(err: e)
+            end
+          end
+        end
+      ensure
+        # Release mutual exclusion lock on the session
+        release_lock!
+      end
+    end
+
+    def step_to_in(delay, session: nil, flow: nil, state: nil, slug: nil)
+      if interrupt_detected?
+        run_interrupt_action
+        return :interrupted
+      end
+
+      flow, state = get_flow_and_state(
+        session: session,
+        flow: flow,
+        state: state,
+        slug: slug
+      )
+
+      unless delay.is_a?(ActiveSupport::Duration)
+        raise ArgumentError, "Please specify your step_to_in `delay` parameter using ActiveSupport::Duration, e.g. `1.day` or `5.hours`"
+      end
+
+      Xip::ScheduledReplyJob.perform_in(delay, current_service, current_session_id, flow, state, current_message.target_id)
+      Xip::Logger.l(topic: "session", message: "User #{current_session_id}: scheduled session step to #{flow}->#{state} in #{delay} seconds")
+    end
+
+    def step_to_at(timestamp, session: nil, flow: nil, state: nil, slug: nil)
+      if interrupt_detected?
+        run_interrupt_action
+        return :interrupted
+      end
+
+      flow, state = get_flow_and_state(
+        session: session,
+        flow: flow,
+        state: state,
+        slug: slug
+      )
+
+      unless timestamp.is_a?(DateTime)
+        raise ArgumentError, "Please specify your step_to_at `timestamp` parameter as a DateTime"
+      end
+
+      Xip::ScheduledReplyJob.perform_at(timestamp, current_service, current_session_id, flow, state, current_message.target_id)
+      Xip::Logger.l(topic: "session", message: "User #{current_session_id}: scheduled session step to #{flow}->#{state} at #{timestamp.iso8601}")
+    end
+
+    def step_to(session: nil, flow: nil, state: nil, slug: nil, pos: nil)
+      if interrupt_detected?
+        run_interrupt_action
+        return :interrupted
+      end
+
+      flow, state = get_flow_and_state(
+        session: session,
+        flow: flow,
+        state: state,
+        slug: slug
+      )
+
+      step(flow: flow, state: state, pos: pos)
+    end
+
+    def update_session_to(session: nil, flow: nil, state: nil, slug: nil)
+      if interrupt_detected?
+        run_interrupt_action
+        return :interrupted
+      end
+
+      flow, state = get_flow_and_state(
+        session: session,
+        flow: flow,
+        state: state,
+        slug: slug
+      )
+
+      update_session(flow: flow, state: state)
+    end
+
+    def set_back_to(session: nil, flow: nil, state: nil, slug: nil)
+      if interrupt_detected?
+        run_interrupt_action
+        return :interrupted
+      end
+
+      flow, state = get_flow_and_state(
+        session: session,
+        flow: flow,
+        state: state,
+        slug: slug
+      )
+
+      store_back_to_session(flow: flow, state: state)
+    end
+
+    def step_back
+      back_to_session = Xip::Session.new(
+        id: current_session_id,
+        type: :back_to
+      )
+
+      if back_to_session.blank?
+        raise(
+          Xip::Errors::InvalidStateTransition,
+          'back_to_session not found; make sure set_back_to was called first'
+        )
+      end
+
+      step_to(session: back_to_session)
+    end
+
+    def do_nothing
+      @progressed = :do_nothing
+    end
+
+    private
+
+      def update_session(flow:, state:)
+        @progressed = :updated_session
+        @current_session = Session.new(id: current_session_id)
+
+        unless current_session.flow_string == flow.to_s && current_session.state_string == state.to_s
+          @current_session.set_session(new_flow: flow, new_state: state)
+        end
+      end
+
+      def store_back_to_session(flow:, state:)
+        back_to_session = Session.new(
+          id: current_session_id,
+          type: :back_to
+        )
+        back_to_session.set_session(new_flow: flow, new_state: state)
+      end
+
+      def step(flow:, state:, pos: nil)
+        update_session(flow: flow, state: state)
+        @progressed = :stepped
+        @flow_controller = nil
+        @current_flow = current_session.flow
+        @pos = pos
+
+        flow_controller.action(action: state)
+      end
+
+      def get_flow_and_state(session: nil, flow: nil, state: nil, slug: nil)
+        if session.nil? && flow.nil? && state.nil? && slug.nil?
+          raise(ArgumentError, "A session, flow, state, or slug must be specified")
+        end
+
+        if session.present?
+          return session.flow_string, session.state_string
+        end
+
+        if slug.present?
+          flow_state = Session.flow_and_state_from_session_slug(slug: slug)
+          return flow_state[:flow], flow_state[:state]
+        end
+
+        if flow.present?
+          if state.blank?
+            state = FlowMap.flow_spec[flow.to_sym].states.keys.first.to_s
+          end
+
+          return flow.to_s, state.to_s
+        end
+
+        if state.present?
+          return current_session.flow_string, state.to_s
+        end
+      end
+
+  end
+end