bot_mob 0.2.2 → 0.3.0

data/lib/bot_mob/command.rb

@@ -0,0 +1,38 @@
+require 'optparse'
+
+module BotMob
+  # # BotMob::Command
+  #
+  # This class handles all the `mob` command line interactions
+  class Command
+    def initialize
+      # parse_options!
+    end
+
+    def handle(argv)
+      case argv[0].to_s.to_sym
+      when :server then BotMob::Server.run!(@options || {})
+      when :console then system("#{__dir__}/../../bin/console")
+      else
+        puts 'Usage: mob server [options]'
+      end
+    end
+
+    # private
+
+    # def parse_options!
+    #   options = {}
+    #   OptionParser.new do |opts|
+    #     opts.on('-d', '--[no-]daemon', 'Run process as a daemon') do |opt|
+    #       options[:daemon] = opt
+    #     end
+
+    #     opts.on('-v', '--[no-]verbose', 'Run verbosely') do |opt|
+    #       options[:verbose] = opt
+    #     end
+    #   end.parse!
+
+    #   @options = options
+    # end
+  end
+end

data/lib/bot_mob/connection.rb

@@ -4,64 +4,32 @@ module BotMob
   # The Connection is the point of contact
   # between the Bot and the specified network
   class Connection
-    attr_reader :bot
+    attr_reader :bot, :options
 
-    def self.setup(network, bot, options = {})
-      invalid_network_error(network) unless BotMob.valid_network?(network)
-
-      connection = network_delegate(network)
-      invalid_delegate_error(network) unless connection.respond_to?(:setup)
-
-      connection.setup(bot, options)
+    def initialize(bot, **options)
+      @bot = bot
+      @options = options
     end
 
-    def deliver(outbound_message, options = {})
-      # connection.deliver(outbound_message, options)
-    end
-
-    private
-
-    def self.network_delegate(network)
-      BotMob.networks[network].const_get('Connection')
-    end
-
-    def welcome_message
-      "Connected!"
-    end
-
-    def active?
-      @state != :inactive
-    end
-
-    def waiting?
-      @state == :waiting
-    end
-
-    def disconnected?
-      @state != :connected
-    end
-
-    def connected?
-      @state == :connected
+    def self.setup(network, bot, options = {})
+      connection_delegate(network).new(bot, options)
     end
 
-    def closed?
-      @state == :closed
+    def deliver(outbound_message, _options = {})
+      # deliver(outbound_message, options)
+      # noop
+      outbound_message
     end
 
-    def set_state(state)
-      BotMob.logger.info welcome_message if state == :connected
-
-      BotMob.logger.info "State[#{bot.class.to_s}##{bot.key}] - #{state}"
-      @state = state
-    end
-
-    def self.invalid_network_error(network)
-      raise BotMob::InvalidNetworkError, "The #{network.inspect} network has not been mounted"
-    end
+    class << self
+      private
 
-    def self.invalid_delegate_error(network)
-      raise BotMob::InvalidConnectionError, "The #{network.inspect} connection must implement the `setup` method"
+      def connection_delegate(network)
+        delegate = BotMob::Networks.const_get(network.to_s.camelize)
+        delegate.const_get('Connection')
+      rescue NameError
+        raise BotMob::InvalidNetworkError
+      end
     end
   end
 end

data/lib/bot_mob/core_ext/hash.rb

@@ -0,0 +1,148 @@
+# Hash - Core Extensions
+class Hash
+  # Returns a new hash with all keys converted using the +block+ operation.
+  #
+  #  hash = { name: 'Rob', age: '28' }
+  #
+  #  hash.transform_keys { |key| key.to_s.upcase } # => {"NAME"=>"Rob", "AGE"=>"28"}
+  #
+  # If you do not provide a +block+, it will return an Enumerator
+  # for chaining with other methods:
+  #
+  #  hash.transform_keys.with_index { |k, i| [k, i].join } # => {"name0"=>"Rob", "age1"=>"28"}
+  def transform_keys
+    return enum_for(:transform_keys) { size } unless block_given?
+    result = self.class.new
+    each_key do |key|
+      result[yield(key)] = self[key]
+    end
+    result
+  end
+
+  # Destructively converts all keys using the +block+ operations.
+  # Same as +transform_keys+ but modifies +self+.
+  def transform_keys!
+    return enum_for(:transform_keys!) { size } unless block_given?
+    keys.each do |key|
+      self[yield(key)] = delete(key)
+    end
+    self
+  end
+
+  # Returns a new hash with all keys converted to strings.
+  #
+  #   hash = { name: 'Rob', age: '28' }
+  #
+  #   hash.stringify_keys
+  #   # => {"name"=>"Rob", "age"=>"28"}
+  def stringify_keys
+    transform_keys(&:to_s)
+  end
+
+  # Destructively converts all keys to strings. Same as
+  # +stringify_keys+, but modifies +self+.
+  def stringify_keys!
+    transform_keys!(&:to_s)
+  end
+
+  # Returns a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+.
+  #
+  #   hash = { 'name' => 'Rob', 'age' => '28' }
+  #
+  #   hash.symbolize_keys
+  #   # => {name: "Rob", age: "28"}
+  def symbolize_keys
+    transform_keys { |key| key.to_sym rescue key }
+  end
+  alias_method :to_options, :symbolize_keys
+
+  # Destructively converts all keys to symbols, as long as they respond
+  # to +to_sym+. Same as +symbolize_keys+, but modifies +self+.
+  def symbolize_keys!
+    transform_keys! { |key| key.to_sym rescue key }
+  end
+  alias_method :to_options!, :symbolize_keys!
+
+  # Returns a new hash with all keys converted by the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  #
+  #  hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #  hash.deep_transform_keys{ |key| key.to_s.upcase }
+  #  # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
+  def deep_transform_keys(&block)
+    _deep_transform_keys_in_object(self, &block)
+  end
+
+  # Destructively converts all keys by using the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_transform_keys!(&block)
+    _deep_transform_keys_in_object!(self, &block)
+  end
+
+  # Returns a new hash with all keys converted to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  #
+  #   hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #   hash.deep_stringify_keys
+  #   # => {"person"=>{"name"=>"Rob", "age"=>"28"}}
+  def deep_stringify_keys
+    deep_transform_keys(&:to_s)
+  end
+
+  # Destructively converts all keys to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_stringify_keys!
+    deep_transform_keys!(&:to_s)
+  end
+
+  # Returns a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+. This includes the keys from the root hash
+  # and from all nested hashes and arrays.
+  #
+  #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
+  #
+  #   hash.deep_symbolize_keys
+  #   # => {person: {name: "Rob", age: "28"}}
+  def deep_symbolize_keys
+    deep_transform_keys { |key| key.to_sym rescue key }
+  end
+
+  # Destructively converts all keys to symbols, as long as they respond
+  # to +to_sym+. This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_symbolize_keys!
+    deep_transform_keys! { |key| key.to_sym rescue key }
+  end
+
+  private
+
+  # support methods for deep transforming nested hashes and arrays
+  def _deep_transform_keys_in_object(object, &block)
+    case object
+    when Hash
+      object.each_with_object({}) do |(key, value), result|
+        result[yield(key)] = _deep_transform_keys_in_object(value, &block)
+      end
+    else
+      object
+    end
+  end
+
+  def _deep_transform_keys_in_object!(object, &block)
+    case object
+    when Hash
+      object.keys.each do |key|
+        value = object.delete(key)
+        object[yield(key)] = _deep_transform_keys_in_object!(value, &block)
+      end
+    end
+    object
+  end
+end

data/lib/bot_mob/core_ext/string.rb

@@ -0,0 +1,8 @@
+# String - Core Extensions
+class String
+  def camelize
+    string = self
+    string = string.sub(/^[a-z\d]*/) { $&.capitalize }
+    string.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.gsub('/', '::')
+  end
+end

data/lib/bot_mob/environment.rb

@@ -0,0 +1,25 @@
+module BotMob
+  # ## BotMob::Environment
+  #
+  # Provide convenience methods for tracking current
+  # BotMob runtime environment. Set using the environment
+  # variable: `ENV['MOB_ENV']`
+  class Environment
+    def initialize(env = nil)
+      @env = env || 'development'
+    end
+
+    def to_s
+      @env
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      method_name.to_s[/(.*)\?$/, 1] || super
+    end
+
+    def method_missing(method_name, *args)
+      environment = method_name.to_s[/(.*)\?$/, 1]
+      environment ? @env == environment : super
+    end
+  end
+end

data/lib/bot_mob/inbound_message.rb

@@ -1,45 +1,26 @@
 module BotMob
-  # ## BotMob::InboundMessage
+  # # BotMob::InboundMessage
   #
-  # The InboundMessage class provides easy access to
-  # messages received by bots in your application
+  # Structured data provided to a bot
   class InboundMessage
-    attr_reader :network, :text, :params
+    attr_reader :body, :network
 
-    def initialize(text)
-      @text = text
+    def initialize(**options)
+      @network = options[:network]
+      @body = options[:body]
     end
 
-    def self.parse(params)
-      network = params[:network]
-      invalid_network_error(network) unless BotMob.valid_network?(network)
+    def self.prepare(message, options = {})
+      return message if message.is_a?(BotMob::InboundMessage)
 
-      parser = network_delegate(network)
-      invalid_delegate_error(network) unless parser.respond_to?(:parse)
-
-      parser.parse(params)
-    end
-
-    def arguments
-      @arguments ||= text.to_s[%r{\/[\w'_-]+\s*[\w'_-]+\s*(.*)}, 1]
+      BotMob::InboundMessage.new(
+        network: options[:network] || :roaming,
+        body: message
+      )
     end
 
     def params
-      @params || { network: network, text: text }
-    end
-
-    private
-
-    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 self.invalid_delegate_error(network)
-      raise BotMob::InvalidInboundMessageError, "The #{network.inspect} inbound message parser must implement the `parse` method"
+      @params || { body: body }
     end
   end
 end

data/lib/bot_mob/networks/roaming.rb

@@ -0,0 +1,12 @@
+module BotMob
+  module Networks
+    # ## BotMob::Networks::Roaming
+    #
+    # 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 :OutboundMessage, 'bot_mob/networks/roaming/outbound_message'
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module BotMob
+  module Networks
+    module Roaming
+      # ## BotMob::Networks::Roaming::Connection
+      #
+      # The Connection is the point of contact
+      # between the Bot and the specified network
+      class Connection < BotMob::Connection
+        attr_reader :bot
+
+        def deliver(outbound_message, _options = {})
+          BotMob.logger.info "  Roaming Connection Sent: #{outbound_message.inspect}"
+          outbound_message
+        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
+end

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

@@ -0,0 +1,15 @@
+module BotMob
+  module Networks
+    module Roaming
+      # # BotMob::Networks::Roaming::OutboundMessage
+      #
+      # Formatted message for default :roaming delivery
+      class OutboundMessage < BotMob::OutboundMessage
+        def initialize(**options)
+          @network = :roaming
+          super
+        end
+      end
+    end
+  end
+end

data/lib/bot_mob/networks/slack.rb

@@ -0,0 +1,11 @@
+module BotMob
+  module Networks
+    # ## BotMob::Networks::Slack
+    #
+    # Network connection adapters to work with Slack
+    module Slack
+      autoload :Connection, 'bot_mob/networks/slack/connection'
+      autoload :OutboundMessage, 'bot_mob/networks/slack/outbound_message'
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module BotMob
+  module Networks
+    module Slack
+      # # BotMob::Networks::Slack::Connection
+      #
+      # Handles all the connection details between a bot and Slack
+      class Connection < BotMob::Connection
+        attr_reader :bot, :token
+
+        def initialize(bot, options = {})
+          @bot = bot
+          @token = options[:token]
+          raise BotMob::NetworkConnectionError, 'Slack connection requires a :token parameter' if @token.nil?
+        end
+
+        def deliver(outbound_message, options = {})
+          BotMob.logger.info("  Sending to Slack: \"#{options.inspect}\"\n")
+          BotMob.logger.info("  Text: \"#{outbound_message.body.inspect}\"\n")
+
+          client.chat_postMessage(
+            channel: outbound_message.channel,
+            text: outbound_message.body,
+            as_user: true
+          )
+        end
+
+        def client
+          @client ||= begin
+            client = ::Slack::Web::Client.new(token: token)
+            client.auth_test
+            client
+          end
+        end
+      end
+    end
+  end
+end