bot_mob 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6463fee5649865aa2f59e0e19b7b3670ff5e20c8
-  data.tar.gz: e96b710afa365c7b9152a2fd6b5af76dec618a0f
+  metadata.gz: 1b85965cd3ed7759eb4a7d79ca601dc94536cf04
+  data.tar.gz: 22edb2f9215b9e1414dab19908b5d33001897e65
 SHA512:
-  metadata.gz: a7172822c373e804dfe65fb589ddf12bd78403f8416e2b91ce2bf9269268cce4f36039d452d1a9ee5c880ae30372eecb8d8caea8c953e40956fc6ac94ca8faa3
-  data.tar.gz: 2c70c6c01e9bb1d4c6a6537ce889e5774bf486c2feac444bc75c64a61eeb1375b20c74e056c9efa046b0aae87f6fa34b3c55550e61380132cbc2741e31954163
+  metadata.gz: 82652bacc7af4349f248d6674c480fc96ee0ab6c682a70c7147099808a40c01a0c2b24d31c725cf8725b20a6b2e8e651aee65c124978597f773b9eb503331164
+  data.tar.gz: 7dbfbfd3c16abb88e1230e7227138b1741d47256753d3ebff5cc31fe7632c72739e3bfe2740fc992cb189d7b054c18b5612d6ba32c9dee31312b54e9e342ddd2

data/examples/server.rb

@@ -1,7 +1,10 @@
+require 'dotenv'
 require_relative 'fizz_buzz_bot'
 require_relative 'hello_bot'
 
+Dotenv.load
+
 BotMob.start! do |app|
   app.register FizzBuzzBot
-  app.register HelloBot.new(network: :slack, token: ENV['SLACK_TOKEN'])
+  app.register HelloBot.new(slack: { token: ENV['SLACK_TOKEN'] })
 end

data/lib/bot_mob.rb

@@ -1,5 +1,4 @@
 require 'logger'
-require 'slack-ruby-client'
 require 'bot_mob/core_ext/hash'
 require 'bot_mob/core_ext/string'
 require 'bot_mob/version'
@@ -19,6 +18,7 @@ module BotMob
   autoload :Command,          'bot_mob/command'
   autoload :Connection,       'bot_mob/connection'
   autoload :InboundMessage,   'bot_mob/inbound_message'
+  autoload :Logger,           'bot_mob/logger'
   autoload :OutboundMessage,  'bot_mob/outbound_message'
   autoload :Roster,           'bot_mob/roster'
   autoload :Server,           'bot_mob/server'
@@ -61,7 +61,7 @@ module BotMob
   # Provide a logger for the BotMob gem, silences test env output by default
   def self.logger
     @logger ||= begin
-      buffer = Logger.new(ENV['MOB_ENV'] == 'test' ? '/dev/null' : STDOUT)
+      buffer = BotMob::Logger.new(ENV['MOB_ENV'] == 'test' ? '/dev/null' : STDOUT)
       if buffer
         buffer.level = ($PROGRAM_NAME == 'irb' ? Logger::DEBUG : Logger::INFO)
         buffer.formatter = proc { |_s, _d, _p, msg| "#{msg}\n" }

data/lib/bot_mob/bot.rb

@@ -56,13 +56,10 @@ module BotMob
     def receive(message, options = {})
       inbound_message = BotMob::InboundMessage.prepare(message, options)
 
-      warrant_response = respond?(inbound_message)
-      log_message(inbound_message) if warrant_response || log_responseless_activity?
-      unless warrant_response
-        if log_responseless_activity?
-          BotMob.logger.info('  > Does not warrant response')
-        end
-
+      BotMob.logger.log_request(self, :message, inbound_message.params)
+      BotMob.logger.info('-> Received message was from a bot') unless inbound_message.human?
+      unless respond?(inbound_message)
+        BotMob.logger.info('-> Does not warrant response')
         return
       end
 
@@ -77,11 +74,18 @@ module BotMob
     #    bot.receive('foo')
     #
     # Specify *message* as the received data
-    def receive_command(command)
-      BotMob.logger.info("#{name} received command at #{Time.now}")
-      BotMob.logger.info("  Parameters: {:text => \"#{command}\"}")
+    def receive_command(command, params = {})
+      BotMob.logger.log_request(self, :command, command: command)
+
+      return unless valid_command?(command)
 
-      send(command) if valid_command?(command)
+      begin
+        send(command, params)
+      rescue ArgumentError => e
+        BotMob.logger.warn("#{name}##{command} is not accepting parameters")
+        BotMob.logger.warn("ArgumentError - #{e.message}")
+        send(command)
+      end
     end
 
     # ## `valid_command?`
@@ -106,9 +110,9 @@ module BotMob
     # contents of the inbound message. Commonly used for checking language
     # used or regex matching of the inbound messages' contents.
     #
-    # Defaults to true
-    def respond?(_inbound_message)
-      true
+    # Defaults to true for human messages
+    def respond?(inbound_message)
+      inbound_message.human?
     end
 
     # ## `respond`
@@ -161,10 +165,5 @@ module BotMob
     def log_responseless_activity?
       BotMob.env.development?
     end
-
-    def log_message(message)
-      BotMob.logger.info("#{name} received message at #{Time.now}")
-      BotMob.logger.info("  Parameters: #{message.params}")
-    end
   end
 end

data/lib/bot_mob/inbound_message.rb

@@ -3,24 +3,102 @@ module BotMob
   #
   # Structured data provided to a bot
   class InboundMessage
-    attr_reader :body, :network
+    attr_reader :user_name, :body, :network
 
     def initialize(**options)
-      @network = options[:network]
-      @body = options[:body]
+      @body    ||= options[:body]
+      @network ||= options[:network]
+
+      provided_message_attributes(options).each do |attr|
+        instance_variable_set("@#{attr}".to_sym, options[attr.to_sym])
+      end
     end
 
+    # ## `prepare`
+    #
+    # Prepare accepts three different data types and attempts to coerce
+    # it into a contextual inbound message. In the case of an inbound
+    # message, it simply assumes the provided message is already correct.
+    # In the case of a hash, it passes the hash along as the `initialize`
+    # attrs. In the case of a string, it overrides the `body` key of the
+    # provided options, then passes the options provided to `prepare` as
+    # the `initialize` params
     def self.prepare(message, options = {})
       return message if message.is_a?(BotMob::InboundMessage)
+      options.symbolize_keys!
+
+      approach = "prepare_#{message.class.to_s.downcase}_attrs".to_sym
+      attrs = send(approach, message, options)
+      message_delegate(attrs[:network]).new(attrs)
+    end
 
-      BotMob::InboundMessage.new(
-        network: options[:network] || :roaming,
-        body: message
-      )
+    # ## `human?`
+    #
+    # This should be overrode in the inheriting bot class. Use this
+    # to determine if the inbound message was written by a human
+    def human?
+      ENV['MOB_NAME'] != user_name
     end
 
+    # ## `params`
+    #
+    # A representation of the relevant data attached to a bot
     def params
-      @params || { body: body }
+      @params ||= {
+        body: body,
+        network: network,
+        user_name: user_name
+      }
+    end
+
+    class << self
+      def message_attrs(*attrs)
+        @message_attrs = attrs
+        attr_reader(*@message_attrs)
+      end
+
+      def message_attributes
+        @message_attrs || []
+      end
+
+      def default_user_name
+        ENV['MOB_NAME'] || 'nomad'
+      end
+
+      def default_network
+        :roaming
+      end
+
+      private
+
+      def prepare_hash_attrs(message, options)
+        attrs = message.symbolize_keys.merge(options)
+        attrs.merge(
+          network: attrs[:network] || default_network,
+          user_name: attrs[:user_name] || default_user_name
+        )
+      end
+
+      def prepare_string_attrs(message, options)
+        options.merge(
+          network: options[:network] || default_network,
+          user_name: options[:user_name] || default_user_name,
+          body: message
+        )
+      end
+
+      def message_delegate(network)
+        delegate = BotMob::Networks.const_get(network.to_s.camelize)
+        delegate.const_get('InboundMessage')
+      rescue NameError
+        raise BotMob::InvalidNetworkError
+      end
+    end
+
+    private
+
+    def provided_message_attributes(options)
+      self.class.message_attributes.select { |attr| options[attr.to_sym] }
     end
   end
 end

data/lib/bot_mob/logger.rb

@@ -0,0 +1,22 @@
+module BotMob
+  # # BotMob::Logger
+  #
+  # Wrapper for the logger implemented by BotMob
+  class Logger < ::Logger
+    OMITTED_PARAMS = %w(splat captures).freeze
+
+    def log_request(source, action = :request, params = {})
+      source_network = params[:network] || 'roaming'
+      ts = Time.now.strftime('%Y-%m-%d %H:%M:%S%Z')
+
+      info "\n#{source.name} received #{action} from :#{source_network} at #{ts}"
+      info "Parameters: #{logged_params(params).inspect}"
+    end
+
+    private
+
+    def logged_params(params)
+      params.reject { |k, _| OMITTED_PARAMS.include?(k) }
+    end
+  end
+end

data/lib/bot_mob/networks/roaming.rb

@@ -5,7 +5,8 @@ module BotMob
     # The default network for a bot that has not yet connected to
     # an external network
     module Roaming
-      autoload :Connection, 'bot_mob/networks/roaming/connection'
+      autoload :Connection,      'bot_mob/networks/roaming/connection'
+      autoload :InboundMessage,  'bot_mob/networks/roaming/inbound_message'
       autoload :OutboundMessage, 'bot_mob/networks/roaming/outbound_message'
     end
   end

data/lib/bot_mob/networks/roaming/inbound_message.rb

@@ -0,0 +1,15 @@
+module BotMob
+  module Networks
+    module Roaming
+      # # BotMob::InboundMessage
+      #
+      # Structured data provided to a bot without a connected network
+      class InboundMessage < BotMob::InboundMessage
+        def initialize(**options)
+          @network = :roaming
+          super
+        end
+      end
+    end
+  end
+end

data/lib/bot_mob/networks/slack.rb

@@ -1,10 +1,13 @@
+require 'slack-ruby-client'
+
 module BotMob
   module Networks
     # ## BotMob::Networks::Slack
     #
     # Network connection adapters to work with Slack
     module Slack
-      autoload :Connection, 'bot_mob/networks/slack/connection'
+      autoload :Connection,      'bot_mob/networks/slack/connection'
+      autoload :InboundMessage,  'bot_mob/networks/slack/inbound_message'
       autoload :OutboundMessage, 'bot_mob/networks/slack/outbound_message'
     end
   end

data/lib/bot_mob/networks/slack/inbound_message.rb

@@ -0,0 +1,36 @@
+module BotMob
+  module Networks
+    module Slack
+      # # BotMob::InboundMessage
+      #
+      # Structured data provided to a bot by Slack via sinatra params
+      # {
+      #   "token": "NiI3K5i7SORx0MAf8U9QRfCX",
+      #   "team_id": "T09K1L491",
+      #   "team_domain": "foobar",
+      #   "service_id": "16319829032",
+      #   "channel_id": "C29R5RZLN",
+      #   "channel_name": "general",
+      #   "timestamp": "1482729119.000014",
+      #   "user_id": "U07R1RUJA",
+      #   "user_name": "matthew",
+      #   "text": "Hi Everyone!",
+      #   "splat": [],
+      #   "captures": [
+      #     "slack"
+      #   ],
+      #   "network": "slack"
+      # }
+      class InboundMessage < BotMob::InboundMessage
+        message_attrs :domain, :channel_name, :user_name, :timestamp,
+                      :token, :team_id, :service_id, :channel_id, :user_id
+
+        def initialize(**options)
+          @network = :slack
+          @body = options[:text]
+          super
+        end
+      end
+    end
+  end
+end

data/lib/bot_mob/roster.rb

@@ -10,8 +10,31 @@ module BotMob
       @bots = []
     end
 
-    def register(bot, **_options)
-      @bots << (bot.is_a?(Class) ? bot.new : bot)
+    def register(bot, **options)
+      @bots << (bot.is_a?(Class) ? bot.new(options) : bot)
+    end
+
+    # ## `disseminate`
+    #
+    # This method will distribute a message or command to all bots
+    # on the roster. It collects and returns a compacted array
+    # of the bots' responses
+    def disseminate(action, params = {})
+      bots.map do |bot|
+        approach = "handle_#{action}".to_sym
+        respond_to?(approach, true) ? send(approach, bot, params) : nil
+      end.compact
+    end
+
+    private
+
+    def handle_message(bot, params)
+      bot.receive(params)
+    end
+
+    def handle_command(bot, params)
+      method_name = params[:method].to_sym
+      bot.receive_command(method_name, params)
     end
   end
 end

data/lib/bot_mob/server.rb

@@ -11,6 +11,10 @@ module BotMob
       super
     end
 
+    def name
+      'Server'
+    end
+
     get '/' do
       erb :index
     end
@@ -19,29 +23,27 @@ module BotMob
       erb :console
     end
 
-    get '/authorize' do
-      erb :authorize
-    end
+    get '/:network/callback' do
+      BotMob.logger.log_request(self, :callback, params)
 
-    get '/message' do
-      results = []
-      settings.roster.bots.map do |bot|
-        result = bot.receive(params[:text], network: params[:network])
-        results << result.body unless result.nil?
+      case params[:network].to_sym
+      when :facebook
+        params['hub.challenge']
+      else
+        erb :authorize
       end
+    end
+
+    post '/:network/message' do
+      BotMob.logger.log_request(self, :message, params)
 
-      results.join(', ')
+      settings.roster.disseminate(:message, params).join(', ')
     end
 
-    get '/command/:method' do
-      results = []
-      settings.roster.bots.map do |bot|
-        method_name = params[:method].to_sym
-        result = bot.receive_command(method_name)
-        results << result unless result.nil?
-      end
+    post '/:network/command/:method' do
+      BotMob.logger.log_request(self, :command, params)
 
-      results.join(', ')
+      settings.roster.disseminate(:command, params).join(', ')
     end
   end
 end

data/lib/bot_mob/version.rb

@@ -1,3 +1,3 @@
 module BotMob
-  VERSION = '0.3.0'.freeze
+  VERSION = '0.3.2'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bot_mob
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Matthew Werner
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-12-26 00:00:00.000000000 Z
+date: 2016-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
@@ -168,11 +168,14 @@ files:
 - lib/bot_mob/core_ext/string.rb
 - lib/bot_mob/environment.rb
 - lib/bot_mob/inbound_message.rb
+- lib/bot_mob/logger.rb
 - lib/bot_mob/networks/roaming.rb
 - lib/bot_mob/networks/roaming/connection.rb
+- lib/bot_mob/networks/roaming/inbound_message.rb
 - lib/bot_mob/networks/roaming/outbound_message.rb
 - lib/bot_mob/networks/slack.rb
 - lib/bot_mob/networks/slack/connection.rb
+- lib/bot_mob/networks/slack/inbound_message.rb
 - lib/bot_mob/networks/slack/outbound_message.rb
 - lib/bot_mob/outbound_message.rb
 - lib/bot_mob/public/console.js