bot_mob 0.2.2 → 0.3.0

data/lib/bot_mob/ambassador.rb

@@ -1,34 +0,0 @@
-module BotMob
-  class Ambassador
-    # ## BotMob::Ambassador.setup
-    #
-    # Ambassador setup delegates the ambassadorship
-    # to the correct network.
-    def self.setup(network, args = {})
-      invalid_network_error(network) unless BotMob.valid_network?(network)
-
-      ambassador = network_delegate(network)
-      invalid_delegate_error(network) unless ambassador.respond_to?(:setup)
-
-      ambassador.setup(args)
-    end
-
-    def data
-      {}
-    end
-
-    private
-
-    def self.network_delegate(network)
-      BotMob.networks[network].const_get('Ambassador')
-    end
-
-    def self.invalid_network_error(network)
-      raise BotMob::InvalidNetworkError, "The #{network.inspect} network has not been mounted"
-    end
-
-    def self.invalid_delegate_error(network)
-      raise BotMob::InvalidAmbassadorError, "The #{network.inspect} ambassador must implement the `setup` method"
-    end
-  end
-end

data/lib/bot_mob/application.rb

@@ -1,43 +0,0 @@
-require 'forwardable'
-
-module BotMob
-  # ## BotMob::Application
-  #
-  # This is the base application class for BotMob.
-  class Application
-    extend Forwardable
-
-    def_delegators :roster, :register
-
-    def start!
-      BotMob.logger.info("=> BotMob #{BotMob::VERSION} application starting")
-
-      roster.load
-      wire.listen { |auth| roster.connect(auth) }
-
-      loop do
-        sleep(10)
-        # Avoid polling at all for the time being
-        # roster.load if roster.available? && !wire.available?
-      end
-    end
-
-    private
-
-    # ## Roster
-    #
-    # The `roster` is the object that keeps track of the registration
-    # and participation of any various bots active on your mob
-    def roster
-      @roster ||= BotMob::Roster.new
-    end
-
-    # ## Wire
-    #
-    # The `wire` is the object that allows for other processes to
-    # tell your bot mob application to take some action.
-    def wire
-      @wire ||= BotMob::Wire.new
-    end
-  end
-end

data/lib/bot_mob/authority.rb

@@ -1,41 +0,0 @@
-module BotMob
-  # ## BotMob::Authority
-  #
-  # The Authority class will process an access args
-  # and retrieve an access token from the specified
-  # network
-  #
-  # Example Invocation:
-  #
-  # BotMob::Authority.new(:slack, code: params[:code])
-  class Authority
-    attr_reader :network
-
-    def initialize(network, args = {})
-      @network = network
-      @args = args
-    end
-
-    def process(bot_class)
-      return unless ambassador.success?
-
-      # wire.publish(network: :slack, external_id: 'foo', bot_class: 'MockBot', data: { token: ENV['IOBOT_TOKEN'] } )
-      wire.publish({
-        network: network,
-        external_id: ambassador.external_id,
-        bot_class: bot_class.to_s,
-        data: ambassador.data || {}
-      })
-    end
-
-    private
-
-    def ambassador
-      @ambassador ||= BotMob::Ambassador.setup(network, @args)
-    end
-
-    def wire
-      @wire ||= BotMob::Wire.new
-    end
-  end
-end

data/lib/bot_mob/development/ambassador.rb

@@ -1,21 +0,0 @@
-module BotMob
-  module Development
-    class Ambassador < BotMob::Ambassador
-      def self.setup(args)
-        new
-      end
-
-      def success?
-        true
-      end
-
-      def external_id
-        'dev'
-      end
-
-      def token
-        'na'
-      end
-    end
-  end
-end

data/lib/bot_mob/development/connection.rb

@@ -1,34 +0,0 @@
-module BotMob
-  module Development
-    class Connection < BotMob::Connection
-
-      def initialize(bot, options = {})
-        @bot = bot
-      end
-
-      def self.setup(bot, options = {})
-        new(bot, options)
-      end
-
-      def deliver(outbound_message, options = {})
-        BotMob.logger.info "  Dev Connection Sent: #{outbound_message.text.inspect}"
-      end
-
-      def connect
-        BotMob.logger.info 'Connecting... '
-      end
-
-      def reconnect
-        BotMob.logger.info 'Reconnecting... '
-      end
-
-      def refresh
-        BotMob.logger.info 'Refreshing... '
-      end
-
-      def client
-        self
-      end
-    end
-  end
-end

data/lib/bot_mob/development/inbound_message.rb

@@ -1,17 +0,0 @@
-module BotMob
-  module Development
-    class InboundMessage < BotMob::InboundMessage
-      def initialize(params)
-        @text = params[:text]
-        @network = params[:network]
-      end
-
-      def self.parse(**params)
-        new({
-          network: params[:network],
-          text: params[:text]
-        })
-      end
-    end
-  end
-end

data/lib/bot_mob/errors.rb

@@ -1,12 +0,0 @@
-module BotMob
-  class InvalidAmbassadorError < StandardError; end
-  class InvalidConnectionError < StandardError; end
-  class InvalidInboundMessageError < StandardError; end
-
-  class InvalidNetworkError < StandardError; end
-  class InvalidClientIdError < StandardError; end
-  class InvalidClientSecretError < StandardError; end
-  class InvalidCodeError < StandardError; end
-  class ConnectionNotEstablished < StandardError; end
-  class UnregisteredBotError < StandardError; end
-end

data/lib/bot_mob/install.rb

@@ -1,16 +0,0 @@
-module BotMob
-  class Install < ActiveRecord::Base
-    self.table_name = "bot_mob_installs"
-
-    def self.registered_bot(auth)
-      where(bot_class: auth['bot_class'], external_id: auth['external_id'])
-    end
-
-    def self.create_with_auth(auth)
-      registered_bot(auth).first_or_initialize.tap do |i|
-        i.data = auth['data']
-        i.save!
-      end
-    end
-  end
-end

data/lib/bot_mob/nil_connection.rb

@@ -1,29 +0,0 @@
-module BotMob
-  class NilConnection
-
-    def initialize(bot)
-      @bot = bot
-    end
-
-    def deliver(outbound_message, options = {})
-      BotMob.logger.info '! Missing connection attempting to deliver... '
-      BotMob.logger.info "  Message sent: #{outbound_message.text.inspect}"
-    end
-
-    def connect
-      BotMob.logger.info '! Missing connection attempting to connect... '
-    end
-
-    def reconnect
-      BotMob.logger.info '! Missing connection attempting to reconnect... '
-    end
-
-    def refresh
-      BotMob.logger.info '! Missing connection attempting to refresh... '
-    end
-
-    def client
-      self
-    end
-  end
-end

data/lib/bot_mob/slack.rb

@@ -1,10 +0,0 @@
-require 'bot_mob'
-require 'slack-ruby-client'
-
-module BotMob
-  module Slack
-    autoload :Ambassador, 'bot_mob/slack/ambassador'
-    autoload :Connection, 'bot_mob/slack/connection'
-    autoload :InboundMessage, 'bot_mob/slack/inbound_message'
-  end
-end

data/lib/bot_mob/slack/ambassador.rb

@@ -1,58 +0,0 @@
-module BotMob
-  module Slack
-    class Ambassador < BotMob::Ambassador
-      def initialize(code)
-        @code = code
-      end
-
-      def self.setup(args)
-        new(args[:code])
-      end
-
-      def token
-        oauth_response.bot_access_token
-      end
-
-      def external_id
-        oauth_response.bot_user_id
-      end
-
-      def data
-        { token: token }
-      end
-
-      def success?
-        !!(external_id && token)
-      end
-
-      private
-
-      def oauth_response
-        return @oauth_response if defined?(@oauth_response)
-
-        response = client.oauth_access({
-          code: @code,
-          client_id: ENV['SLACK_CLIENT_ID'],
-          client_secret: ENV['SLACK_CLIENT_SECRET']
-        })
-
-        @oauth_response = response.bot
-      rescue ::Slack::Web::Api::Error => e
-        case e.message
-        when 'invalid_client_id'
-          raise BotMob::InvalidClientIdError, 'Invalid SLACK_CLIENT_ID environment variable'
-        when 'bad_client_secret'
-          raise BotMob::InvalidClientSecretError, 'Invalid SLACK_CLIENT_SECRET environment variable'
-        when 'invalid_code'
-          raise BotMob::InvalidCodeError, 'Invalid access code'
-        else
-          raise e
-        end
-      end
-
-      def client
-        @client ||= ::Slack::Web::Client.new
-      end
-    end
-  end
-end

data/lib/bot_mob/slack/connection.rb

@@ -1,87 +0,0 @@
-module BotMob
-  module Slack
-    class Connection < BotMob::Connection
-      attr_reader :bot, :token
-
-      def initialize(bot, options = {})
-        @bot = bot
-        @token = options['token']
-        token.nil? ? set_state(:inactive) : setup
-      end
-
-      def self.setup(bot, options = {})
-        new(bot, options)
-      end
-
-      def deliver(outbound_message, options = {})
-        BotMob.logger.info("  Sending to Slack: \"#{options.inspect}\"\n")
-        BotMob.logger.info("  Text: \"#{outbound_message.text.inspect}\"\n")
-        client.web_client.chat_postMessage(outbound_message.to_h)
-      end
-
-      def connect
-        return unless active?
-        set_state(:connecting)
-        establish
-      end
-
-      def reconnect
-        return unless active?
-        set_state(:reconnecting)
-        renew_client
-        setup
-        establish
-      end
-
-      def refresh
-        return unless active?
-
-        case true
-        when waiting?
-          connect
-        when disconnected?
-          reconnect
-        else
-          BotMob.logger.info "State[#{bot.class.to_s}##{bot.key}] - No Change"
-        end
-      end
-
-      def welcome_message
-        "Successfully connected, '#{client.team.name}' team at https://#{client.team.domain}.slack.com."
-      end
-
-      def client
-        @client ||= renew_client
-      end
-
-      private
-
-      def establish
-        client.start_async
-      rescue ::Slack::Web::Api::Error => e
-        BotMob.logger.info e.message
-        set_state(:waiting)
-      end
-
-      def setup
-        set_state(:waiting)
-        client.on(:hello) { set_state(:connected) }
-        client.on(:close) { set_state(:disconnecting) }
-        client.on(:closed) { set_state(:closed) }
-
-        client.on :message do |data|
-          message = BotMob::InboundMessage.parse({
-            network: :slack,
-            format: :websocket
-          }.merge(data))
-
-          bot.receive message
-        end
-      end
-
-      def renew_client
-        @client = ::Slack::RealTime::Client.new(token: @token)
-      end
-    end
-  end
-end

data/lib/bot_mob/slack/inbound_message.rb

@@ -1,52 +0,0 @@
-module BotMob
-  module Slack
-    class InboundMessage < BotMob::InboundMessage
-      attr_reader :token, :team_id, :team_domain, :params, :format,
-                  :channel_id, :channel_name, :external_id, :user_name,
-                  :command, :bot_id, :response_url, :ts
-
-      def initialize(params)
-        @format = params[:format] || :websocket
-        @network = params[:network]
-        @params = params
-        send("parse_#{format}".to_sym, @params)
-      end
-
-      def self.parse(params)
-        new(params)
-      end
-
-      def human?
-        bot_id.nil?
-      end
-
-      def command?
-        !command.nil?
-      end
-
-      private
-
-      def parse_websocket(data)
-        @text = data['text']
-        @channel_id = data['channel_id'] || data['channel']
-        @bot_id = data['bot_id']
-        @team = data['team']
-        @ts = data['ts']
-        @external_id = data['user_id']
-      end
-
-      def parse_webhook(data)
-        @token = data['token']
-        @team_id = data['team_id']
-        @team_domain = data['team_domain']
-        @channel_id = data['channel_id']
-        @channel_name = data['channel_name']
-        @external_id = data['user_id']
-        @user_name = data['user_name']
-        @command = data['command']
-        @text = data['text']
-        @response_url = data['response_url']
-      end
-    end
-  end
-end