bot_mob 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3b057501d92431ac59d7c69c9460b60ee5480f17
-  data.tar.gz: 2e44458a59521d2b1da4b36f2e737f5448125ff2
+  metadata.gz: a6c06b15e2ece464e52b403fd36bd610487da2b8
+  data.tar.gz: 34dfe52f53892d31d918aae0611dcc347f571ab7
 SHA512:
-  metadata.gz: 61a2e9ff80ace5da65189c32943dbf1e7a5b634cb886c05c571159020b5809ae0d777270df0fb0bc6688226024608812dd12d08aadaa359a27a13156fbfe6d22
-  data.tar.gz: b821beaea5c9da7d69bbe316cb65a34975a5f6ea40a1f3f8301c2de5b975f4b3f1935eba32fd06ae87f0ae4d5f6bb0dc436254ee508b5dc7c087274882e28b81
+  metadata.gz: 34c4efc4364f76889ea9968669b3bcf7c3c5c8b85c6715dff07f138dbaa8bd3c1dd6a57416761251ccc7ba81244e9c054acb8cb6b084b69503ac6c9a8938fa58
+  data.tar.gz: 2c4d05434f48c330d51f426404e7170fd63b410e7e09f67d532d05aa2ab78ef92171d617d75958c584a339f978b6e9988d84655530fb46ad42383e7c103550b6

data/bin/console

@@ -8,4 +8,5 @@ require 'bot_mob'
 require File.join(BotMob.root, 'spec/script/active_record')
 require File.join(BotMob.root, 'spec/support/mock_bot')
 require 'irb'
+
 IRB.start

data/lib/bot_mob.rb

@@ -1,32 +1,45 @@
 $LOAD_PATH.unshift File.dirname(__FILE__)
-require 'bunny'
-require 'slack-ruby-client'
+require 'bot_mob/errors'
 require 'bot_mob/version'
 
 # ## BotMob
 #
 # BotMob provides all the tools you need to easily
-# connect to chat networks
+# connect multiple bots to chat networks
 module BotMob
-  autoload :Ambassador,     'bot_mob/ambassador'
-  autoload :Application,    'bot_mob/application'
-  autoload :Authority,      'bot_mob/authority'
-  autoload :Bot,            'bot_mob/bot'
-  autoload :Connection,     'bot_mob/connection'
-  autoload :InboundMessage, 'bot_mob/inbound_message'
-  autoload :Install,        'bot_mob/install'
-  autoload :Roster,         'bot_mob/roster'
-  autoload :Wire,           'bot_mob/wire'
-
-  module Slack
-    autoload :Ambassador,        'bot_mob/slack/ambassador'
+  autoload :Ambassador,       'bot_mob/ambassador'
+  autoload :Application,      'bot_mob/application'
+  autoload :Authority,        'bot_mob/authority'
+  autoload :Bot,              'bot_mob/bot'
+  autoload :Connection,       'bot_mob/connection'
+  autoload :InboundMessage,   'bot_mob/inbound_message'
+  autoload :Install,          'bot_mob/install'
+  autoload :NilConnection,    'bot_mob/nil_connection'
+  autoload :OutboundMessage,  'bot_mob/outbound_message'
+  autoload :Roster,           'bot_mob/roster'
+  autoload :Wire,             'bot_mob/wire'
+
+  module Development
+    autoload :Ambassador,     'bot_mob/development/ambassador'
+    autoload :Connection,     'bot_mob/development/connection'
+    autoload :InboundMessage, 'bot_mob/development/inbound_message'
+  end
+
+  @@networks = {
+    dev: BotMob::Development
+  }
+
+  def self.networks
+    @@networks
   end
 
-  class InvalidNetworkError < StandardError; end
-  class InvalidClientIdError < StandardError; end
-  class InvalidClientSecretError < StandardError; end
-  class InvalidCodeError < StandardError; end
-  class ConnectionNotEstablished < StandardError; end
+  def self.mount(network_map)
+    @@networks.merge!(network_map)
+  end
+
+  def self.valid_network?(network)
+    networks.include?(network.to_s.to_sym) && BotMob.networks[network]
+  end
 
   def self.root
     File.expand_path('../..', __FILE__)

data/lib/bot_mob/ambassador.rb

@@ -1,20 +1,34 @@
 module BotMob
   class Ambassador
-    NETWORKS = [:slack]
+    # ## 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)
 
-    def self.setup(network, code)
-      raise BotMob::InvalidNetworkError unless NETWORKS.include?(network.to_s.to_sym)
-      send("setup_#{network}", code)
+      ambassador = network_delegate(network)
+      invalid_delegate_error(network) unless ambassador.respond_to?(:setup)
+
+      ambassador.setup(args)
     end
 
-    def auth
-      { external_id: external_id, token: token }
+    def data
+      {}
     end
 
     private
 
-    def self.setup_slack(code)
-      BotMob::Slack::Ambassador.new(code)
+    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

@@ -3,7 +3,7 @@ require 'forwardable'
 module BotMob
   # ## BotMob::Application
   #
-  # This is the base class for BotMob.
+  # This is the base application class for BotMob.
   class Application
     extend Forwardable
 
@@ -13,9 +13,7 @@ module BotMob
       BotMob.logger.info("=> BotMob #{BotMob::VERSION} application starting")
 
       roster.load
-      wire.listen do |bot|
-        roster.connect(bot)
-      end
+      wire.listen { |auth| roster.connect(auth) }
 
       loop do
         sleep(10)
@@ -26,10 +24,18 @@ module BotMob
 
     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

data/lib/bot_mob/authority.rb

@@ -1,23 +1,39 @@
 module BotMob
   # ## BotMob::Authority
   #
-  # The Authority class will process an access code
-  # and retrieve an access token from Slack
+  # 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, :ambassador
+    attr_reader :network
 
-    def initialize(network, code)
-      @ambassador = BotMob::Ambassador.setup(network, code)
+    def initialize(network, args = {})
+      @network = network
+      @args = args
     end
 
     def process(bot_class)
       return unless ambassador.success?
 
-      wire.publish(ambassador.auth.merge(bot_class: bot_class.to_s))
+      # 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

data/lib/bot_mob/bot.rb

@@ -4,38 +4,50 @@ module BotMob
   # ## BotMob::Bot
   #
   # This is the base for all bots that will connect
-  # to Slack.
+  # to respond to messages received by your application.
   class Bot
-    attr_reader :external_id
+    attr_accessor :id, :network
+    attr_reader :options
 
     extend Forwardable
-    def_delegators :connection, :connect, :reconnect, :refresh, :client
+    def_delegators :connection, :connect, :reconnect, :refresh, :client, :deliver
 
-    def initialize(external_id, token)
-      @external_id = external_id
-      @token = token
+    def initialize(*args)
+      @network, @id, @options = *args
     end
 
-    def api_post(args = {})
-      BotMob.logger.info("  Sending \"#{args.inspect}\"\n")
-      client.web_client.chat_postMessage(args)
+    def key
+      "#{network}.#{id}"
     end
 
-    def realtime_post(args = {})
-      BotMob.logger.info("  Sending \"#{args[:text]}\"\n")
-      client.message(args)
+    def receive(message)
+      inbound_message = message.is_a?(String) ? BotMob::InboundMessage.new(message) : message
+      return unless respond?(inbound_message)
+
+      BotMob.logger.info("Received message at #{Time.now}")
+      BotMob.logger.info("  Parameters: #{inbound_message.params}")
+      respond(inbound_message)
     end
 
-    def respond(message)
-      # noop
+    def respond(inbound_message)
+      outbound = BotMob::OutboundMessage.new(text: "#{self.class} ACK! #{inbound_message.text}")
+      deliver(outbound)
     end
 
-    def respond?(message)
-      false
+    def respond?(inbound_message)
+      true
     end
 
+    private
+
     def connection
-      @connection ||= BotMob::Connection.new(:slack, self, @token)
+      @connection ||= begin
+        if BotMob.valid_network?(network)
+          BotMob::Connection.setup(network, self, options)
+        else
+          BotMob::NilConnection.new(self)
+        end
+      end
     end
   end
 end

data/lib/bot_mob/connection.rb

@@ -6,50 +6,27 @@ module BotMob
   class Connection
     attr_reader :bot
 
-    def initialize(_network, bot, token)
-      @bot = bot
-      @token = token
-      token.nil? ? set_state(:inactive) : setup
-    end
-
-    def connect
-      return unless active?
-      set_state(:connecting)
-      establish
-    end
+    def self.setup(network, bot, options = {})
+      invalid_network_error(network) unless BotMob.valid_network?(network)
 
-    def reconnect
-      return unless active?
-      set_state(:reconnecting)
-      renew_client
-      setup
-      establish
-    end
+      connection = network_delegate(network)
+      invalid_delegate_error(network) unless connection.respond_to?(:setup)
 
-    def refresh
-      return unless active?
-
-      case true
-      when waiting?
-        connect
-      when disconnected?
-        reconnect
-      else
-        logger.info "State[#{bot.external_id}] - No Change"
-      end
+      connection.setup(bot, options)
     end
 
-    def client
-      @client ||= renew_client
+    def deliver(outbound_message, options = {})
+      # connection.deliver(outbound_message, options)
     end
 
     private
 
-    def establish
-      client.start_async
-    rescue ::Slack::Web::Api::Error => e
-      logger.info e.message
-      set_state(:inactive)
+    def self.network_delegate(network)
+      BotMob.networks[network].const_get('Connection')
+    end
+
+    def welcome_message
+      "Connected!"
     end
 
     def active?
@@ -73,37 +50,18 @@ module BotMob
     end
 
     def set_state(state)
-      if state == :connected
-        logger.info "Successfully connected, '#{client.team.name}' team at https://#{client.team.domain}.slack.com."
-      end
+      BotMob.logger.info welcome_message if state == :connected
 
-      logger.info "State[#{bot.class.to_s}##{bot.external_id}] - #{state}"
+      BotMob.logger.info "State[#{bot.class.to_s}##{bot.key}] - #{state}"
       @state = state
     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.new(:websocket, data)
-
-        if bot.respond?(message)
-          logger.info("Received message at #{Time.now}")
-          logger.info("  Parameters: #{message.data}")
-          bot.respond(message)
-        end
-      end
-    end
-
-    def renew_client
-      @client = ::Slack::RealTime::Client.new(token: @token)
+    def self.invalid_network_error(network)
+      raise BotMob::InvalidNetworkError, "The #{network.inspect} network has not been mounted"
     end
 
-    def logger
-      @logger ||= BotMob.logger
+    def self.invalid_delegate_error(network)
+      raise BotMob::InvalidConnectionError, "The #{network.inspect} connection must implement the `setup` method"
     end
   end
 end

data/lib/bot_mob/development/ambassador.rb

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,12 @@
+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/inbound_message.rb

@@ -1,52 +1,45 @@
 module BotMob
-  # ## BotMob::Inbound Message
+  # ## BotMob::InboundMessage
   #
   # The InboundMessage class provides easy access to
-  # messages received from Slack's Real Time API
+  # messages received by bots in your application
   class InboundMessage
-    attr_reader :source, :data, :token, :team_id, :team_domain,
-                :channel_id, :channel_name, :external_id, :user_name,
-                :command, :text, :bot_id, :response_url, :ts
+    attr_reader :network, :text, :params
 
-    def initialize(source, data)
-      @data = data
-      send("parse_#{source}".to_sym, data)
+    def initialize(text)
+      @text = text
     end
 
-    def arguments
-      @arguments ||= text[%r{\/[\w'_-]+\s*[\w'_-]+\s*(.*)}, 1]
+    def self.parse(params)
+      network = params[:network]
+      invalid_network_error(network) unless BotMob.valid_network?(network)
+
+      parser = network_delegate(network)
+      invalid_delegate_error(network) unless parser.respond_to?(:parse)
+
+      parser.parse(params)
     end
 
-    def command?
-      !command.nil?
+    def arguments
+      @arguments ||= text.to_s[%r{\/[\w'_-]+\s*[\w'_-]+\s*(.*)}, 1]
     end
 
-    def human?
-      bot_id.nil?
+    def params
+      @params || { network: network, text: text }
     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]
+    def self.network_delegate(network)
+      BotMob.networks[network].const_get('InboundMessage')
+    end
+
+    def self.invalid_network_error(network)
+      raise BotMob::InvalidNetworkError, "The #{network.inspect} network has not been mounted"
     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']
+    def self.invalid_delegate_error(network)
+      raise BotMob::InvalidInboundMessageError, "The #{network.inspect} inbound message parser must implement the `parse` method"
     end
   end
 end

data/lib/bot_mob/install.rb

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

data/lib/bot_mob/nil_connection.rb

@@ -0,0 +1,29 @@
+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/outbound_message.rb

@@ -0,0 +1,19 @@
+module BotMob
+  # ## BotMob::Outbound Message
+  #
+  # The OutboundMessage class provides a convenient
+  # way to consistently allow your bot to respond
+  # to a given network
+  class OutboundMessage
+    attr_reader :text, :channel_id
+
+    def initialize(data)
+      @text = data[:text]
+      @channel_id = data[:channel_id]
+    end
+
+    def to_h
+      { channel: channel_id, text: text }
+    end
+  end
+end

data/lib/bot_mob/roster.rb

@@ -7,23 +7,42 @@ module BotMob
       @bots = {}
     end
 
+    # `connect`
+    #
+    # `connect` receives an auth hash that contains a bot_class
+    # along with any accompanying metadata that the bot will need
+    # to connect to the specified network. Provided by BotMob::Authority
+    # delivered over the wire.
+    #
+    # Example `auth` param:
+    #
+    # {
+    #   bot_class: 'FooBot',
+    #   network: 'slack',
+    #   external_id: 'USER1',
+    #   data: {
+    #     token: 'abc123'
+    #   }
+    # }
+    #
     def connect(auth)
+      # { network: :dev, external_id: 'foo', bot_class: 'FooBot', data: {} }
       class_name = auth['bot_class'].to_s
       bot_class = registry[class_name]
-      external_id, token = auth['external_id'], auth['token']
-      BotMob.logger.info "Initializing #{bot_class}: #{external_id}"
+      raise BotMob::UnregisteredBotError, 'You must explicitly register your bot class with the roster before connecting that bot type' if bot_class.nil?
+      BotMob.logger.info "Selecting #{class_name.inspect} from registry: #{bot_class.inspect}"
 
-      puts "Registry: #{registry.inspect}"
-      puts "Using registered bot: #{bot_class.inspect}"
       unless auth.is_a?(BotMob::Install)
-        BotMob.logger.info "Updating #{bot_class} bot record..."
-        BotMob::Install.create_with_auth(auth)
+        begin
+          BotMob.logger.info "Updating #{class_name} database record for #{auth['external_id']}..."
+          BotMob::Install.create_with_auth(auth)
+        rescue ActiveRecord::StatementInvalid => e
+          BotMob.logger.info "Unable to save record: #{e.message}"
+        end
       end
 
-      puts "Setting up a new bot with:\n  #{auth.inspect}\n  #{external_id}\n  #{token}"
-      bot = bot_class.new(external_id, token)
-      @bots["#{bot_class}##{external_id}"] ||= bot
-      @bots["#{bot_class}##{external_id}"].refresh
+      network = auth['network']
+      allocate(bot_class, network, auth)
     end
 
     def load
@@ -48,8 +67,23 @@ module BotMob
       @registry[bot_class.to_s] = bot_class
     end
 
+    private
+
     def available?
       @available.nil? || @available
     end
+
+    def allocate(bot_class, network, auth)
+      key = "#{bot_class}##{auth['network']}.#{auth['external_id']}"
+
+      if @bots[key]
+        BotMob.logger.info "Using existing #{key} bot"
+      else
+        BotMob.logger.info "Setting up a new #{bot_class} bot: #{key}"
+        @bots[key] = bot_class.new(auth['network'].to_sym, auth['external_id'], auth['data'] || {})
+      end
+
+      @bots[key].refresh
+    end
   end
 end

data/lib/bot_mob/slack.rb

@@ -0,0 +1,10 @@
+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

@@ -5,6 +5,10 @@ module BotMob
         @code = code
       end
 
+      def self.setup(args)
+        new(args[:code])
+      end
+
       def token
         oauth_response.bot_access_token
       end
@@ -13,6 +17,10 @@ module BotMob
         oauth_response.bot_user_id
       end
 
+      def data
+        { token: token }
+      end
+
       def success?
         !!(external_id && token)
       end

data/lib/bot_mob/slack/connection.rb

@@ -0,0 +1,87 @@
+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

@@ -0,0 +1,52 @@
+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

data/lib/bot_mob/version.rb

@@ -1,3 +1,3 @@
 module BotMob
-  VERSION = '0.2.1'.freeze
+  VERSION = '0.2.2'.freeze
 end

data/lib/bot_mob/wire.rb

@@ -1,3 +1,5 @@
+require 'bunny'
+
 module BotMob
   # ## BotMob::Wire
   #
@@ -5,11 +7,26 @@ module BotMob
   # receives notifications from authenticated installs
   # over RabbitMQ
   class Wire
+    def initialize
+      @available = nil
+    end
+
+    # ## wire.publish
+    #
+    # The `publish` method takes a given message, converts it to JSON
+    # and pushes the json over the wire on the `wire.notifications` channel.
+    # This is primarily used for passing successful authentication to the
+    # running BotMob Application.
     def publish(message = {})
       BotMob.logger.info "Publishing #{message} to wire.notifications"
       queue.publish(message.to_json, routing_key: queue.name)
     end
 
+    # ## wire.listen
+    #
+    # The `listen` method takes a block to perform when a
+    # message is received over the wire. The message published
+    # to the wire is parsed JSON provided to the calling block.
     def listen
       return if !block_given? || queue.nil?
 
@@ -20,8 +37,9 @@ module BotMob
       BotMob.logger.info "#{e.channel_close.reply_code}, message: #{e.channel_close.reply_text}"
     end
 
+
     def available?
-      @available
+      !!@available
     end
 
     private

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bot_mob
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Matthew Werner
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-19 00:00:00.000000000 Z
+date: 2016-08-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -229,10 +229,19 @@ files:
 - lib/bot_mob/authority.rb
 - lib/bot_mob/bot.rb
 - lib/bot_mob/connection.rb
+- lib/bot_mob/development/ambassador.rb
+- lib/bot_mob/development/connection.rb
+- lib/bot_mob/development/inbound_message.rb
+- lib/bot_mob/errors.rb
 - lib/bot_mob/inbound_message.rb
 - lib/bot_mob/install.rb
+- lib/bot_mob/nil_connection.rb
+- lib/bot_mob/outbound_message.rb
 - lib/bot_mob/roster.rb
+- lib/bot_mob/slack.rb
 - lib/bot_mob/slack/ambassador.rb
+- lib/bot_mob/slack/connection.rb
+- lib/bot_mob/slack/inbound_message.rb
 - lib/bot_mob/version.rb
 - lib/bot_mob/wire.rb
 homepage: https://github.com/mwerner/bot_mob