bot_framework 0.1.0beta → 0.1.0beta2

data/lib/bot_framework/dialogs/reg_exp_recognizer.rb

@@ -0,0 +1,41 @@
+require_relative 'action_set'
+module BotFramework
+  module Dialogs
+    class RegExpRecognizer
+      attr_accessor :intent, :expressions
+      def initialize(intent,expressions)
+        @intent = intent
+        if expressions.is_a? Regexp
+          @expressions = {'*': expressions}
+        else
+          @expressions = expressions || {}
+        end
+      end
+
+      def recognize(context)
+        raise ArgumentError, "context must be a hash" unless context.is_a? Hash
+        result = {score: 0.0, intent: nil}
+        if context.fetch(:message, {}).fetch(:text, nil)
+          utterance = context[:message][:text]
+          locale = context[:message][:locale] || :*
+          exp = @expressions[locale] ? @expressions[locale] : @expressions[:*]
+          if exp
+            matches = exp.match(utterance)
+            if matches
+              matched = matches.to_s
+              result[:score] = matched.length / utterance.length
+              result[:intent] = intent
+              result[:expression] = exp
+              result[:matched] = matches
+            end
+            yield nil, result
+          else
+            yield(ExpressionNotFoundForLocale, nil)
+          end
+        else
+          yield(nil, result)
+        end
+      end
+    end
+  end
+end

data/lib/bot_framework/dialogs/simple_dialog.rb

@@ -0,0 +1,29 @@
+require_relative '../session'
+require_relative 'action_set'
+module BotFramework
+  # Abstract class for dialog
+  module Dialogs
+    class SimpleDialog < Dialog
+      def initialize
+        raise 'No block given' unless block_given?
+        super
+      end
+
+      def begin(session, _opts = {})
+        reply_recieved(session)
+      end
+
+      def reply_recieved(_session, _recognize_result = {})
+        raise NotImplementedError
+      end
+
+      def dialog_resumed(session, result)
+        session.error(result[:error]) if result[:error]
+      end
+
+      def recognize(_context)
+        yield nil, { score: 0.1 }
+      end
+    end
+  end
+end

data/lib/bot_framework/events/event_emitter.rb

@@ -0,0 +1,6 @@
+module BotFramework
+  module Events
+    class EventEmitter
+    end
+  end
+end

data/lib/bot_framework/message.rb

@@ -0,0 +1,80 @@
+module BotFramework
+  class Message
+    TEXT_FORMAT = {
+      plain: 'plain',
+      markdown: 'markdown',
+      xml: 'xml'
+    }.freeze
+    ATTACHMENT_LAYOUT = {
+      list: 'list',
+      carousel: 'carousel'
+    }.freeze
+
+    def initialize(_session = nil)
+      @data = {}
+      @data[:type] = 'consts.MessageType' # FIXME
+      @data[:agent] = 'consts.agent'
+      if @session
+        m = @session.message
+        @data[:source] = m[:source] if m[:source]
+        @data[:text_locale] = m[:text_locale] if m[:text_locale]
+        @data[:address] = m[:address] if m[:address]
+      end
+    end
+
+    def text_locale(locale)
+      @data[:text_locale] = locale
+      self
+    end
+
+    def text_format(style)
+      @data[:text_format] = style
+      self
+    end
+
+    def text(text, *_args)
+      @data[:text] = text.present? ? format_text(text) : ''
+      self
+    end
+
+    def ntext(msg, _msg_plural, count)
+      fmt = count == 1 ? self.class.random_prompt(msg) : self.class.random_prmpt(message_plural)
+      fmt = @session.get_text(fmt) if @session
+      @data[:text] = fmt, count # FIXME
+      self
+    end
+
+    def compose(prompts, *args)
+      if prompts
+        @data[:text] = Message.compose_prompt(@session, prompts, *args)
+        self
+      end
+    end
+
+    def summary; end
+
+    def attachment_layout; end
+
+    def attachments; end
+
+    def add_attachment; end
+
+    def entities; end
+
+    def add_entity; end
+
+    def address; end
+
+    def timestamp; end
+
+    def source_event; end
+
+    def to_message; end
+
+    class << self
+      def random_prompt; end
+
+      def compose_prompt; end
+    end
+  end
+end

data/lib/bot_framework/models/object.rb

@@ -1,6 +1,5 @@
 module BotFramework
   class Object < Base
-    
     # Attribute type mapping.
     def self.swagger_types
       {

data/lib/bot_framework/prompt.rb

@@ -0,0 +1,62 @@
+module BotFramework
+  class Prompt < Dialog
+    @@options = {
+      recognizer: BotFramework::SimplePromptRecognizer.new,
+      prompt_after_action: true
+    }
+
+    @@default_retry_prompt = {
+      text: 'default_text',
+      number: 'default_number',
+      confirm: 'daefault_confirm',
+      choice: 'default_choice',
+      time: 'default_time',
+      attachment: 'default_file'
+    }
+
+    def self.configure(_options)
+    end
+
+    def begin(session, options = {})
+      options[:prompt_after_action] = options[:prompt_after_action] || options[:prompt_after_action]
+      options[:retry_count] = 0
+      options.each do |option|
+        # Store in dialog data
+      end
+      send_prompt(session, options)
+    end
+
+    def reply_received(session, args = {}); end
+
+    def dialog_resumed; end
+
+    def recognize; end
+
+    def send_prompt(session, options); end
+
+    def create_prompt; end
+
+    def self.text
+    end
+
+    def self.number
+    end
+
+    def self.confirm
+    end
+
+    def self.choice
+    end
+
+    def self.time
+    end
+
+    def self.attachment
+    end
+
+    def self.disambiguate
+    end
+
+    private
+  end
+end

data/lib/bot_framework/server.rb

@@ -40,7 +40,7 @@ module BotFramework
       if validator.valid?
         return true
       else
-        p "Errors: #{validator.errors}"
+        BotFramework.logger.error "Errors: #{validator.errors}"
         return false
       end
     rescue JWT::DecodeError

data/lib/bot_framework/session.rb

@@ -0,0 +1,407 @@
+module BotFramework
+  class Session # < Events::EventEmitter
+    attr_accessor :library, :message, :user_data, :conversation_data, :private_conversation_data,
+                  :session_state, :dialog_state, :localizer
+    def initialize(options)
+      super
+      @library = options[:library]
+      @localizer = options[:localizer]
+      @msg_sent = false
+      @is_reset = false
+      @last_send_time = Time.now # TODO: Move to proc?
+      @batch = []
+      @batch_timer = Timers::Group.new
+      @batch_started = false
+      @sending_batch = false
+      @in_middleware = false
+      @_locale = nil
+
+      @options = options || {
+        on_save: nil,
+        on_send: nil,
+        library: nil,
+        localizer: nil,
+        middleware: nil,
+        dialog_id: nil,
+        dialog_args: nil,
+        auto_batch_delay: nil,
+        dialog_error_message: nil,
+        actions: nil
+      }
+      @auto_batch_delay = 250 unless options[:auto_batch_delay].is_a? Integer
+      @timers = Timers::Group.new
+    end
+
+    def to_recognize_context
+      {
+        message: message,
+        user_data: user_data,
+        conversation_data: conversation_data,
+        private_conversation_data: private_conversation_data,
+        localizer: localizer,
+        dialog_stack: dialog_stack,
+        preferred_locale: preferred_locale,
+        get_text: get_text,
+        nget_text: nget_text,
+        locale: preferred_locale
+      }
+    end
+
+    def dispatch(session_state, message)
+      index = 0
+      session = self
+      now = Time.now
+      middleware = @options[:middleware] || []
+
+      _next = lambda do
+        handler = middleware[index] if index < middleware.length
+        if handler
+          index += 1
+          handler(session, _next)
+        else
+          @in_middleware = false
+          @session_state[:last_acess] = now
+          done
+        end
+      end
+      session_state ||= { call_stack: [], last_acess: Time.now, version: 0.0 }
+      # Making sure that dialog is properly initialized
+      cur = cur_dialog
+      self.dialog_data = cur.state if cur
+      # Dispatch message
+      message ||= { text: '' }
+      message[:type] ||= 'message'
+      # Ensure that localized prompts are loaded
+      # TODO
+      self
+    end
+
+    def error(_error)
+      logger.info 'Session error'
+      if options[:dialog_error_message]
+        end_conversation(options[:dialog_error_message])
+      else
+        # TODO: Add localisation
+        locale = preferred_locale
+        end_conversation 'Error in conversation'
+      end
+
+      # TODO: Log error
+    end
+
+    def preferred_locale(locale = nil)
+      if locale
+        @_locale = locale
+        @user_data['BotBuilder.Data.PreferredLocale'] = locale if @user_data
+        @localizer.load if @localizer # TODO
+      elsif !@_locale
+        if @user_data && @user_data['BotBuilder.Data.PreferredLocale']
+          @_locale = @user_data['BotBuilder.Data.PreferredLocale']
+        elsif @message && @message[:text_locale]
+          @_locale = @message[:text_locale]
+        elsif @localizer
+          @_locale = @localizer[:default_locale]
+        end
+      end
+      @_locale
+    end
+
+    # Gets and formats localized text string
+    def gettext(message_id, options = {})
+      # TODO
+      # stub
+    end
+
+    # Gets and formats the singular/plural form of a localized text string.
+    def ngettext(message_id, message_id_plural, count); end
+
+    # Manually save current session state
+    def save
+      logger.info 'Session.save'
+      start_batch
+      self
+    end
+
+    def send(message, args = [])
+      args.unshift(@cur_library_name, message)
+      send_localized(args, message)
+    end
+
+    def send_localized(_localization_namspace, message, _args = [])
+      # TODO: Incomplete
+      @msg_sent = true
+      m = { text: message }
+      prepare_message(m)
+      @batch << m
+      self
+    end
+
+    # Sends a typing indicator to the user
+    def send_typing
+      @msg_sent = true
+      m = { type: 'typing' }
+      m = prepare_message(m)
+      @batch.push(m)
+      logger.info 'Send Typing'
+      send_batch
+    end
+
+    def send_batch
+      logger.info "Sending batch with elements #{@batch.count}"
+      return if sending_batch?
+      # TODO: timer
+      @batch_timer = nil
+      batch = @batch
+      @batch_started = false
+      @sending_batch = true
+      cur = cur_dialog
+      cur.state = @dialog_data
+      options[:on_save] = proc do |err|
+        if err
+          @sending_batch = false
+          case (err.code || '')
+          when 'EBADMSG'
+          when 'EMSGSIZE'
+            # Something went wrong , let's reset everything
+            @user_data = {}
+            @batch = []
+            end_conversation(@options[:dialog_error_message] || 'Something went wrong and we need to startover')
+          end
+          yield(err) if block_given?
+        else
+          if batch.length
+            options[:on_send].call(batch) do |err|
+              @sending_batch = false
+              start_batch if @batch_started # What is this :o
+              yield(err) if block_given?
+            end
+          else
+            @sending_batch = false
+            start_batch if @batch_started
+            yield(err) if block_given?
+          end
+        end
+      end
+    end
+
+    # Begin a new dialog
+    def begin_dialog(id, args = nil)
+      logger.info "Beginning new dialog #{id}"
+      id = resolve_dialog_id(id)
+      dialog = find_dialog(id)
+      raise "Dialog #{id} Not found" unless dialog
+      push_dialog(id: id, state: {})
+      start_batch
+      dialog.begin(self, args)
+      self
+    end
+
+    def replace_dialog(id, args = nil)
+      logger.info "Session replace dialog #{id}"
+      id = resolve_dialog_id(id)
+      dialog = find_dialog(id)
+      raise "Dialog #{id} Not found" unless dialog
+
+      # Update the stack and start dialog
+      pop_dialog
+      push_dialog(id: id, state: {})
+      start_batch
+      dialog.begin(self, args)
+      self
+    end
+
+    # End conversation with the user
+    def end_conversation(message = nil, _args = {})
+      if message
+        # TODO: sent message
+      end
+      # Clear private conversation data
+      @private_conversation_data = {}
+
+      # Clear stack and save
+      logger.info 'End conversation'
+      ss = @session_state
+      ss.call_stack = []
+      send_batch
+      self
+    end
+
+    def end_dialog(message = nil, args = {})
+      if message
+        # TODO: end_dialog_with_result
+      end
+      cur = cur_dialog
+      if cur
+        if message
+          m = if (message.is_a? String) || (message.is_a? Array)
+                create_message(cur_library_name, message, args)
+              else
+                message
+              end
+          @msg_sent = true
+          prepare_message(m)
+          @batch.push(m)
+        end
+
+        # Pop the dialog of the stack and resume the parent
+        logger.info 'Session.end_dialog'
+        child_id = cur.id
+        cur = pop_dialog
+        start_batch
+        if cur
+          dialog = find_dialog(cur.id)
+          if dialog
+            dialog.dialog_resumed(self, resumed: :completed, response: true, child_id: child_id)
+          else
+            # Bad dialog !! , we should never reach here
+            raise "Can't resume , missing parent"
+          end
+        end
+      end
+    end
+
+    # Ends current dialog and returns a value to the caller
+    def end_dialog_with_result(result)
+      # Validate call stack
+      cur = cur_dialog
+      if cur
+        # Validate the result
+        result ||= {}
+        result[:resumed] ||= :completed
+        result.child_id = cur.id
+        logger.info 'Session.end_dialog_with_result'
+
+        # Pop dialog of the stack and resume parent dialog
+        cur = pop_dialog
+        start_batch
+        if cur
+          dialog = find_dialog(cur.id)
+          if dialog
+            dialog.dialog_resumed(self, result)
+          else
+            # Bad dialog state
+            raise "Can't resume , missing parent dialog"
+          end
+        end
+      end
+      self
+    end
+
+    def cancel_dialog; end
+
+    def reset; end
+
+    ############### Dialog Stack Management ############################33
+
+    # Gets and Sets current dialog stack
+    def dialog_stack(new_stack = nil)
+      if new_stack
+        # Update stack and dialog data
+
+        stack = @session_state[:call_stack] = new_stack || []
+        @dialog_data = stack.empty? nil || stack.last
+      else
+        # Copy over dialog data to slack
+        stack = @session_state[:call_stack] || []
+        stack.last.state = @dialog_data || {}
+      end
+      stack
+    end
+
+    # Clears the current Dialog stack
+    def clear_dialog_stack
+      @session_state[:call_stack] = []
+      @dialog_data = nil
+    end
+
+    # Enumerates all a stacks dialog entries in either a forward or reverse direction.
+    def self.forEachDialogStackEntry(stack)
+      stack.each { |item| yield(item) }
+    end
+
+    # Searches a dialog stack for a specific dialog, in either a forward or reverse direction, returning its index.
+    def self.findEachDialogStackEntry(stack, dialog_id)
+      stack.each_with_index do |item, index|
+        return index if item[:id] = dialog_id
+      end
+      -1
+    end
+
+    # Returns a active stack entry or nil
+    def self.active_dialog_stack_entry(stack)
+      stack.last || nil
+    end
+
+    # Pushes a new dialog into stack and return it as active dialog
+    def self.push_dialog_stack_entry(statck, entry)
+      entry[:state] ||= {}
+      statck ||= []
+      stack.push(entry)
+      entry
+    end
+
+    # Pop active dialog out of the stack
+    def self.pop_dialog_stack_entry(stack)
+      stack.pop if stack
+      Session.active_dialog_stack_entry(stack)
+    end
+
+    #  Deletes all dialog stack entries starting with the specified index and returns the new active dialog.
+    def self.prune_dialog_stack(_stack, _start)
+    end
+
+    # Ensures that all of the entries on a dialog stack reference valid dialogs within a library hierarchy.
+    def self.validate_dialog_stack(_stack, _root)
+    end
+
+    ## Message routing
+    #########################
+
+    # Dispatches handling of the current message to the active dialog stack entry.
+    def route_to_active_dialog; end
+
+    private
+
+    def start_batch
+      @batch_started = true
+      unless @sending_batch
+        @batch_timer.cancel if @batch_timer
+        # TODO: send_batch after config[:auto_batch_delay] seconds
+        @batch_timer = @timers.after(config[:auto_batch_delay]) do
+          send_batch
+        end
+      end
+    end
+
+    def create_message; end
+
+    def prepare_message(msg)
+      msg[:type] ||= 'message'
+      msg[:address] ||= message[:address]
+      msg[:text_locale] ||= message[:text_locale]
+      msg
+    end
+
+    def vget_text; end
+
+    def validate_call_stack; end
+
+    def resolve_dialog_id; end
+
+    def cur_library_name; end
+
+    def find_dialog; end
+
+    def push_dialog; end
+
+    def pop_dialog; end
+
+    def delete_dialogs; end
+
+    def cur_dialog
+      ss = @session_sate
+      cur = ss.call_stack.last unless ss.call_stack.empty?
+      cur
+    end
+  end
+end