xip 0.0.1 → 2.0.0.beta2

data/lib/xip/errors.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Xip
+  class Errors < StandardError
+
+    class ConfigurationError < Errors
+    end
+
+    class ReplyFormatNotSupported < Errors
+    end
+
+    class ServiceImpaired < Errors
+    end
+
+    class ServiceError < Errors
+    end
+
+    class ServiceNotRecognized < Errors
+    end
+
+    class ControllerRoutingNotImplemented < Errors
+    end
+
+    class UndefinedVariable < Errors
+    end
+
+    class RedisNotConfigured < Errors
+    end
+
+    class InvalidStateTransition < Errors
+    end
+
+    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/xip/flow/base.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'xip/flow/specification'
+require 'xip/flow/state'
+
+module Xip
+  module Flow
+
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def flow(flow_name, &specification)
+        flow_spec[flow_name.to_sym] = Specification.new(flow_name, &specification)
+      end
+    end
+
+    included do
+      class_attribute :flow_spec, default: {}
+
+      attr_accessor :flow, :flow_state, :user_id
+
+      def current_state
+        res = self.spec.states[@flow_state.to_sym] if @flow_state
+        res || self.spec.initial_state
+      end
+
+      def current_flow
+        @flow || self.class.flow_spec.keys.first
+      end
+
+      def spec
+        self.class.flow_spec[current_flow]
+      end
+
+      def states
+        self.spec.states.keys
+      end
+
+      def init(flow:, state:)
+        new_flow = flow.to_sym
+        new_state = state.to_sym
+
+        unless state_exists?(potential_flow: new_flow, potential_state: new_state)
+          raise(Xip::Errors::InvalidStateTransition, "Unknown state '#{new_state}' for '#{new_flow}' flow")
+        end
+
+        @flow = new_flow
+        @flow_state = new_state
+
+        self
+      end
+
+      private
+
+        def flow_and_state
+          [current_flow, current_state].join(Xip::Session::SLUG_SEPARATOR)
+        end
+
+        def state_exists?(potential_flow:, potential_state:)
+          if self.class.flow_spec[potential_flow].present?
+            self.class.flow_spec[potential_flow].states.include?(potential_state)
+          else
+            raise(Xip::Errors::InvalidStateTransition, "Unknown flow '#{potential_flow}'")
+          end
+        end
+    end
+
+  end
+end

data/lib/xip/flow/specification.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Xip
+  module Flow
+    class Specification
+      attr_reader :flow_name
+      attr_accessor :states, :initial_state
+
+      def initialize(flow_name, &specification)
+        @states = Hash.new
+        @flow_name = flow_name
+        instance_eval(&specification)
+      end
+
+      def state_names
+        states.keys
+      end
+
+      private
+
+        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)
+
+          new_state = Xip::Flow::State.new(
+            name: name,
+            spec: self,
+            fails_to: fail_state,
+            redirects_to: redirect_state,
+            opts: opts
+          )
+
+          @initial_state = new_state if @states.empty?
+          @states[name.to_sym] = new_state
+        end
+
+        def get_fail_or_redirect_state(specified_state)
+          if specified_state.present?
+            session = Xip::Session.new
+
+            if Xip::Session.is_a_session_string?(specified_state)
+              session.session = specified_state
+            else
+              session.session = Xip::Session.canonical_session_slug(
+                flow: flow_name,
+                state: specified_state
+              )
+            end
+
+            return session
+          end
+        end
+
+    end
+  end
+end

data/lib/xip/flow/state.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Xip
+  module Flow
+    class State
+
+      include Comparable
+
+      attr_accessor :name
+      attr_reader :spec, :fails_to, :redirects_to, :opts
+
+      def initialize(name:, spec:, fails_to: nil, redirects_to: nil, opts:)
+        if fails_to.present? && !fails_to.is_a?(Xip::Session)
+          raise(ArgumentError, 'fails_to state should be a Xip::Session')
+        end
+
+        if redirects_to.present? && !redirects_to.is_a?(Xip::Session)
+          raise(ArgumentError, 'redirects_to state should be a Xip::Session')
+        end
+
+        @name, @spec = name, spec
+        @fails_to, @redirects_to, @opts = fails_to, redirects_to, opts
+      end
+
+      def <=>(other_state)
+        state_position(self) <=> state_position(other_state)
+      end
+
+      def +(steps)
+        if steps < 0
+          new_position = state_position(self) + steps
+
+          # we don't want to allow the array index to wrap here so we return
+          # the first state instead
+          if new_position < 0
+            new_state = spec.states.keys.first
+          else
+            new_state = spec.states.keys.at(new_position)
+          end
+        else
+          new_state = spec.states.keys[state_position(self) + steps]
+
+          # we may have been told to access an out-of-bounds state
+          # return the last state
+          if new_state.blank?
+            new_state = spec.states.keys.last
+          end
+        end
+
+        new_state
+      end
+
+      def -(steps)
+        if steps < 0
+          return self + steps.abs
+        else
+          return self + (-steps)
+        end
+      end
+
+      def to_s
+        "#{name}"
+      end
+
+      def to_sym
+        name.to_sym
+      end
+
+      private
+
+        def state_position(state)
+          states = spec.states.keys
+
+          unless states.include?(state.to_sym)
+            raise(ArgumentError, "state `#{state}' does not exist")
+          end
+
+          states.index(state.to_sym)
+        end
+    end
+  end
+end

data/lib/xip/generators/builder.rb

@@ -0,0 +1,41 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+require 'thor/group'
+
+module Xip
+  module Generators
+    class Builder < Thor::Group
+      include Thor::Actions
+
+      argument :name
+
+      def self.source_root
+        File.dirname(__FILE__) + "/builder"
+      end
+
+      def create_bot_directory
+        empty_directory(name)
+      end
+
+      def create_bot_structure
+        directory('bot', "#{name}/bot")
+        directory('config', "#{name}/config")
+        directory('db', "#{name}/db")
+
+        # Miscellaneous Files
+        copy_file "config.ru", "#{name}/config.ru"
+        copy_file "Rakefile", "#{name}/Rakefile"
+        copy_file "Gemfile", "#{name}/Gemfile"
+        copy_file "README.md", "#{name}/README.md"
+        copy_file "Procfile.dev", "#{name}/Procfile.dev"
+        copy_file ".gitignore", "#{name}/.gitignore"
+      end
+
+      def change_directory_bundle
+        puts run("cd #{name} && bundle install")
+      end
+
+    end
+  end
+end

data/lib/xip/generators/builder/.gitignore

@@ -0,0 +1,30 @@
+# See https://help.github.com/articles/ignoring-files for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile '~/.gitignore_global'
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore the default SQLite database.
+/db/*.sqlite3
+/db/*.sqlite3-journal
+
+# Ignore all logfiles and tempfiles.
+/log/*
+/tmp/*
+!/log/.keep
+!/tmp/.keep
+
+# Ignore uploaded files in development
+/storage/*
+
+/node_modules
+/yarn-error.log
+
+/public/assets
+.byebug_history
+
+# Ignore master key for decrypting credentials and more.
+/config/master.key

data/lib/xip/generators/builder/Gemfile

@@ -0,0 +1,19 @@
+source 'https://rubygems.org'
+
+gem 'xip', '~> 2.0'
+
+gem 'railties', '~> 6.1'
+gem 'activerecord', '~> 6.1'
+# Use sqlite3 as the database for Active Record
+gem 'sqlite3'
+
+# Uncomment to enable the Xip Facebook Driver
+# gem 'xip-facebook'
+
+# Uncomment to enable the Xip Twilio SMS Driver
+# gem 'xip-twilio'
+
+group :development do
+  gem 'foreman'
+  gem 'listen', '~> 3.3'
+end

data/lib/xip/generators/builder/Procfile.dev

@@ -0,0 +1,2 @@
+web: bundle exec puma -C config/puma.rb
+sidekiq: bundle exec sidekiq -C config/sidekiq.yml -q xip_webhooks -q xip_replies -r ./config/boot.rb

data/lib/xip/generators/builder/README.md

@@ -0,0 +1,9 @@
+# <a href='https://xipkit.com'><img src='https://cdn.xipkit.com/logo-dark.svg' width='400' alt='Xip Logo' aria-label='xipkit.com' /></a>
+
+To boot this bot locally, we recommend the following:
+
+1. `bundle`
+2. Start your local Redis server
+3. `xip s`
+
+For more information, please check out the [Xip documentation](https://xipkit.com/docs).

data/lib/xip/generators/builder/Rakefile

@@ -0,0 +1,2 @@
+require_relative 'config/boot'
+Xip::Migrations::Tasks.load_tasks

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+class BotController < Xip::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
+      step_to flow: 'hello', state: 'say_hello'
+    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/xip/generators/builder/bot/controllers/catch_alls_controller.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class CatchAllsController < BotController
+
+  def level1
+    send_replies
+
+    if fail_session.present?
+      step_to session: fail_session
+    else
+      step_to session: previous_session - 2.states
+    end
+  end
+
+private
+
+   def fail_session
+     previous_session.flow.current_state.fails_to
+   end
+
+end