slackbot_frd 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c5c6be64e04fc7a8be46b5dacab72fee1612e5b5
+  data.tar.gz: 9180a45cb3f7acbe6db6fb9cd74c4ca0f85c85e4
+SHA512:
+  metadata.gz: 395ab58d08a47f062b529998bd0fe4a515930d3013176b0e60a58ffba5d587fc18e51c5b4c5629cb2c03c027d464dd867637c4041b012d4c629a509221eaeffe
+  data.tar.gz: e767617e733d4c580d08fb04a82e944f46d0cfb388f5e4265e5fd7c933cbb4684d3476befc95210bff29c85d56c81d41fe6464e399d5abce550ab1abce169242

data/bin/slackbot-frd

@@ -0,0 +1,196 @@
+#!/usr/bin/env ruby
+
+require 'thor'
+require 'json'
+
+require 'slackbot_frd/initializer/bot_starter'
+require 'slackbot_frd/lib/slack_connection'
+require 'slackbot_frd/lib/bot'
+
+begin
+  require 'byebug'
+rescue LoadError
+end
+
+DEBUG = true
+
+PID_FILE_WATCHER = "/tmp/slackbot-frd-watcher.pid"
+PID_FILE_CONNECTION = "/tmp/slackbot-frd-connection.pid"
+BOT_LIST_FILE = "/tmp/slackbot-frd-bot-list.pid"
+ERROR_FILE = "/tmp/slackbot-frd-error-file.pid"
+DEFAULT_CONFIG_FILE = "slackbot-frd.conf"
+LOG_FILE = "slackbot-frd.log"
+
+class SlackbotFrdBin < Thor
+  desc "list", "List all bots"
+  long_desc <<-LONGDESC
+    list will print out all available bots
+
+    > $ slackbot-frd list -- List all installed bots
+  LONGDESC
+  def list
+    # TODO
+  end
+
+  desc "start [bot1] [bot2] [botx...]", "Start all specified bots, or all bots"
+  long_desc <<-LONGDESC
+    start [bot1] [bot2] [botx...] will start the specified bots.
+    If no bots are specified, all available bots will be run.
+
+    params set via explicit flags will overwrite conflicting environment variables,
+    and environment variables will overwrite conflicting config file params.
+
+    > $ slackbot-frd start -- Start all available bots
+  LONGDESC
+  option :daemonize, type: :boolean, aliases: 'd'
+  option :botdir, type: :string, aliases: 'b'
+  option 'config-file'.to_sym, type: :string, aliases: 'c'
+  option :token, type: :string, aliases: 't'
+  def start(*bots)
+    config_file = options['config-file'.to_sym]
+    config_file = "#{Dir.pwd}/#{DEFAULT_CONFIG_FILE}" unless config_file
+    json = config_file_json(config_file) if config_file
+    json ||= {}
+
+    daemonize = false
+    daemonize = json["daemonize"] if json["daemonize"]
+    daemonize = ENV["SLACKBOT_FRD_DAEMONIZE"] if ENV["SLACKBOT_FRD_DAEMONIZE"]
+    daemonize = options[:daemonize] if options[:daemonize]
+
+    botdir = Dir.pwd
+    botdir = json["botdir"] if json["botdir"]
+    botdir = ENV["SLACKBOT_FRD_BOTDIR"] if ENV["SLACKBOT_FRD_BOTDIR"]
+    botdir = options[:botdir] if options[:botdir]
+    botdir = File.expand_path(botdir)
+
+    SlackbotFrd::Log.logfile = "#{botdir}/#{LOG_FILE}"
+    SlackbotFrd::Log.info("Logging to file '#{SlackbotFrd::Log.logfile}'")
+
+    token = json["token"]
+    token = ENV["SLACKBOT_FRD_TOKEN"] if ENV["SLACKBOT_FRD_TOKEN"]
+    token = options[:token] if options[:token]
+    unless token
+      SlackbotFrd::Log.error("No token found.  Cannot authenticate to Slack")
+      return
+    end
+
+    if daemonize
+      set_watcher_pid(Process.fork{ watch_connection(bots, token, botdir, true) })
+    else
+      watch_connection(bots, token, botdir)
+    end
+  end
+
+  desc "stop", "Stop all bots"
+  long_desc <<-LONGDESC
+    stop will stop all bots
+
+    > $ slackbot-frd stop -- Stop all running bots
+  LONGDESC
+
+  def stop
+    # first kill the watcher, then kill the connection
+    kill_pid(watcher_pid)
+    kill_pid(connection_pid)
+  end
+
+  desc "restart", "Stop all bots and restart them"
+  long_desc <<-LONGDESC
+    restart will restart all bots
+
+    > $ slackbot-frd restart -- Restart all running bots
+  LONGDESC
+  def restart
+    stop
+    start(set_bots)
+  end
+
+  private
+  def config_file_json(config_file)
+    if File.exists?(config_file)
+      content = File.read(config_file)
+      return JSON.parse(content)
+    end
+    nil
+  end
+
+  private
+  def bots_from_file
+    File.read(BOT_LIST_FILE).split
+  end
+
+  private
+  def set_bots_in_file(bots)
+    File.write(BOT_LIST_FILE, "#{bots.join("\n")}")
+  end
+
+  private
+  def kill_pid(pid)
+    # try 3 times to SIGINT the pid, then SIGKILL it
+    3.times do
+      break unless running?(pid)
+      Process.kill('SIGINT', pid)
+    end
+    Process.kill('SIGKILL', pid) if running?(pid)
+    # TODO log if the process is still running
+  end
+
+  private
+  def watch_connection(bots, token, botdir, daemonize = false)
+    until errors
+      pid = Process.fork do
+        Process.daemon if daemonize
+        loop { BotStarter.start_bots(ERROR_FILE, token, botdir, bots) }
+      end
+      set_connection_pid(pid)
+      Process.wait(pid)
+    end
+    if errors
+      puts "Could not start connection: #{errors}"
+    end
+  end
+
+  private
+  def errors
+    return File.read(ERROR_FILE).split if File.exists?(ERROR_FILE)
+    nil
+  end
+
+  private
+  def running?(pid)
+    begin
+      Process.getpgid(pid.to_i)
+      return true
+    rescue Errno::ESRCH
+      return false
+    end
+  end
+
+  private
+  def watcher_pid
+    File.read(PID_FILE_WATCHER).to_i
+  end
+
+  private
+  def connection_pid
+    File.read(PID_FILE_CONNECTION).to_i
+  end
+
+  private
+  def set_watcher_pid(pid)
+    File.write(PID_FILE_WATCHER, pid)
+  end
+
+  private
+  def set_connection_pid(pid)
+    File.write(PID_FILE_CONNECTION, pid)
+  end
+
+  private
+  def delete_pid_files
+    File.delete(PID_FILE_WATCHER)
+    File.delete(PID_FILE_CONNECTION)
+  end
+end
+
+SlackbotFrdBin.start(ARGV)

data/lib/slackbot_frd.rb

@@ -0,0 +1,3 @@
+Gem.find_files("slackbot_frd/**/*.rb").each do |path|
+  require path.gsub(/\.rb$/, '') unless path =~ /bot.*cli/
+end

data/lib/slackbot_frd/initializer/bot_starter.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+
+require 'thor'
+
+require 'slackbot_frd/lib/slack_connection'
+require 'slackbot_frd/lib/bot'
+
+begin
+  require 'byebug'
+rescue LoadError
+end
+
+class BotStarter
+  def self.start_bots(errors_file, token, botdir, bots)
+    bot_enabled = ->(bot) { bots.empty? || bots.include?(bot) }
+
+    # Create a new Connection to pass to the bot classes
+    slack_connection = SlackbotFrd::SlackConnection.new(token)
+
+    load_bot_files(botdir)
+
+    bots = []
+    # instantiate them, and then call their add_callbacks method
+    ObjectSpace.each_object(Class).select do |klass|
+      if klass != SlackbotFrd::Bot && klass.ancestors.include?(SlackbotFrd::Bot) && bot_enabled.call(klass.name)
+        SlackbotFrd::Log.debug("Instantiating class '#{klass.to_s}'")
+        b = klass.new
+        SlackbotFrd::Log.debug("Adding callbacks to bot '#{klass}'")
+        b.add_callbacks(slack_connection)
+        bots.push(b)
+      end
+    end
+
+    if bots.count == 0
+      @error ||= []
+      @error.push("No bots loaded")
+      SlackbotFrd::Log.error("Not starting: no bots found")
+    else
+      SlackbotFrd::Log.debug("Starting SlackConnection")
+      slack_connection.start
+      SlackbotFrd::Log.debug("Connection closed")
+    end
+  end
+
+  private
+  def self.load_bot_files(top_level_dir)
+    Dir["#{File.expand_path(top_level_dir)}/**/*.rb"].each do |f|
+      SlackbotFrd::Log.debug("Loading bot file '#{f}'")
+      load(f)
+    end
+  end
+end

data/lib/slackbot_frd/initializer/bot_starter_cli.rb

@@ -0,0 +1,11 @@
+require 'slackbot_frd/initializer/bot_starter'
+
+class BotStarterCli < Thor
+  option :token, type: :string, required: true, aliases: 't'
+  option :botdir, type: :string, required: true, aliases: ['b', 'd']
+  def start(*bots)
+    BotStarter.start_bots(options[:token], options[:botdir], bots)
+  end
+end
+
+BotStarterCli.start(ARGV)

data/lib/slackbot_frd/lib/bot.rb

@@ -0,0 +1,18 @@
+# Subclass the bot class to have your bot loaded and run
+module SlackbotFrd
+  class Bot
+    def self.only(*bots)
+      @bots ||= []
+      @bots.push(bots).flatten!
+    end
+
+    class << self
+      attr_accessor :bots
+    end
+
+    # This is where the bot adds all of their callbacks to the bpbot
+    def add_callbacks(slack_connection)
+      raise StandardError.new("You must override the define() method for your bot to do anything")
+    end
+  end
+end

data/lib/slackbot_frd/lib/errors.rb

@@ -0,0 +1,21 @@
+
+module SlackbotFrd
+  class NoTokenError < StandardError
+    def initialize(message = nil)
+      if message
+        super(message)
+      else
+        super("An API token is required for authenticating to the Slack API")
+      end
+    end
+  end
+
+  class AuthenticationFailedError < StandardError
+  end
+
+  class InvalidUserError < StandardError
+  end
+
+  class InvalidChannelError < StandardError
+  end
+end

data/lib/slackbot_frd/lib/log.rb

@@ -0,0 +1,60 @@
+require 'colorize'
+
+module SlackbotFrd
+  class Log
+    @levels = {verbose: 1, debug: 2, info: 3, warn: 4, error: 5}
+    @default_level = :debug
+
+    class << self
+      attr_writer :level
+      attr_accessor :logfile
+    end
+
+    def self.level
+      return @default_level unless @level
+      @level
+    end
+
+    def self.level_on(level)
+      @levels[level] >= @levels[self.level]
+    end
+
+    def self.colors
+      [:green, :red, :yellow, :none, :blue]
+    end
+
+    def self.error(message)
+      log('Error', message, :red) if level_on(:error)
+    end
+
+    def self.warn(message)
+      log('Warn', message, :yellow) if level_on(:warn)
+    end
+
+    def self.debug(message)
+      log('Debug', message, :green) if level_on(:debug)
+    end
+
+    def self.info(message)
+      log('Info', message, :blue) if level_on(:info)
+    end
+
+    def self.verbose(message)
+      log('Verbose', message, :magenta) if level_on(:verbose)
+    end
+
+    def self.log(loglevel, message, color = :none)
+      om = "#{DateTime.now.strftime('%Y-%m-%e %H:%M:%S.%L %z')}: [#{loglevel}]: #{message}\n"
+      print om.send(color)
+      begin
+        raise StandardError.new("No log file specified. (Set with SlackbotFrd::Log.logfile=)") unless @logfile
+        File.open(@logfile, 'a') do |f|
+          f.write(om)
+        end
+      rescue StandardError => e
+        puts "OH NO!  ERROR WRITING TO LOG FILE!: #{e}"
+      end
+      om
+    end
+  end
+end

data/lib/slackbot_frd/lib/slack_connection.rb

@@ -0,0 +1,271 @@
+require 'faye/websocket'
+require 'eventmachine'
+require 'json'
+
+require 'slackbot_frd/lib/errors'
+require 'slackbot_frd/lib/user_channel_callbacks'
+require 'slackbot_frd/lib/log'
+
+require 'slackbot_frd/slack_methods/rtm_start'
+require 'slackbot_frd/slack_methods/chat_post_message'
+require 'slackbot_frd/slack_methods/im_channels_list'
+require 'slackbot_frd/slack_methods/channels_list'
+require 'slackbot_frd/slack_methods/users_list'
+
+module SlackbotFrd
+  class SlackConnection
+    FILE_PATH = File.expand_path(__FILE__)
+    APP_ROOT = File.expand_path(File.dirname(File.dirname(FILE_PATH)))
+    FILE_DIR = File.dirname(FILE_PATH)
+    LOG_FILE = "#{APP_ROOT}/bp-slackbot.log"
+    PID_FILE_NAME = "#{APP_ROOT}/bp-slackbot.pid"
+
+    attr_accessor :token
+
+    def initialize(token)
+      unless token
+        SlackbotFrd::Log::error("No token passed to #{self.class}")
+        raise NoTokenError.new
+      end
+
+      @token = token
+      @event_id = 0
+      @on_connected_callbacks = []
+      @on_disconnected_callbacks = []
+      @on_message_callbacks = UserChannelCallbacks.new
+      @on_channel_left_callbacks = UserChannelCallbacks.new
+      @on_channel_joined_callbacks = UserChannelCallbacks.new
+
+      # These hashes are used to map ids to names efficiently
+      @user_id_to_name = {}
+      @user_name_to_id = {}
+      @channel_id_to_name = {}
+      @channel_name_to_id = {}
+
+      restrict_actions_to_channels_joined
+      SlackbotFrd::Log::debug("Done initializing #{self.class}")
+    end
+
+    def start
+      # Write pid file
+      File.write(PID_FILE_NAME, "#{Process.pid}")
+
+      SlackbotFrd::Log::info("#{self.class}: starting event machine")
+
+      EM.run do
+        wss_url = SlackbotFrd::SlackMethods::RtmStart.wss_url(@token)
+        unless wss_url
+          str = "No Real Time stream opened by slack.  Check for correct authentication token"
+          SlackbotFrd::Log.error(str)
+          File.append(@errors_file, str)
+          return
+        end
+        @ws = Faye::WebSocket::Client.new(wss_url)
+
+        @on_connected_callbacks.each    { |callback| @ws.on(:open,  &callback) }
+        @on_disconnected_callbacks.each { |callback| @ws.on(:close, &callback) }
+        @ws.on(:message) { |event| process_message_received(event) }
+
+        # Clean up our pid file
+        @ws.on(:close) { |event| File.delete(PID_FILE_NAME) }
+      end
+
+      SlackbotFrd::Log::debug("#{self.class}: event machine started")
+    end
+
+    def event_id
+      @event_id += 1
+      @event_id
+    end
+
+    def on_connected(&block)
+      @on_connected_callbacks.push(block)
+    end
+
+    def on_close(&block)
+      @on_disconnected_callbacks.push(block)
+    end
+
+    def on_message(user = :any, channel = :any, &block)
+      @on_message_callbacks.add(user_name_to_id(user), channel_name_to_id(channel), block)
+    end
+
+    def on_channel_left(user = :any, channel = :any, &block)
+      @on_channel_left_callbacks.add(user_name_to_id(user), channel_name_to_id(channel), block)
+    end
+
+    def on_channel_joined(user = :any, channel = :any, &block)
+      u = user_name_to_id(user)
+      c = channel_name_to_id(channel)
+      @on_channel_joined_callbacks.add(u, c, block)
+    end
+
+    def send_message_as_user(channel, message)
+      unless @ws
+        SlackbotFrd::Log::error("Cannot send message '#{message}' as user to channel '#{channel}' because not connected to wss stream")
+        raise NotConnectedError.new("Not connected to wss stream")
+      end
+
+      resp = @ws.send({
+        id: event_id,
+        type: "message",
+        channel: channel_name_to_id(channel),
+        text: message
+      }.to_json)
+
+      SlackbotFrd::Log::debug("#{self.class}: sending message '#{message}' as user to channel '#{channel}'.  Response: #{resp}")
+    end
+
+    def send_message(channel, message, username, avatar, avatar_is_emoji)
+      resp = SlackbotFrd::SlackMethods::ChatPostMessage.postMessage(
+        @token,
+        channel_name_to_id(channel),
+        message,
+        username,
+        avatar,
+        avatar_is_emoji
+      )
+      SlackbotFrd::Log::debug("#{self.class}: sending message '#{message}' as user '#{username}' to channel '#{channel}'.  Response: #{resp}")
+    end
+
+    def restrict_actions_to_channels_joined(value = true)
+      @restrict_actions_to_channels_joined = value
+    end
+
+    def user_id_to_name(user_id)
+      return user_id if user_id == :any || user_id == :bot
+      unless @user_id_to_name && @user_id_to_name.has_key?(user_id)
+        refresh_user_info
+      end
+      SlackbotFrd::Log::warn("#{self.class}: User id '#{user_id}' not found") unless @user_id_to_name.include?(user_id)
+      @user_id_to_name[user_id]
+    end
+
+    def user_name_to_id(user_name)
+      return user_name if user_name == :any || user_name == :bot
+      unless @user_name_to_id && @user_name_to_id.has_key?(user_name)
+        refresh_user_info
+      end
+      SlackbotFrd::Log::warn("#{self.class}: User name '#{user_name}' not found") unless @user_name_to_id.include?(user_name)
+      @user_name_to_id[user_name]
+    end
+
+    def channel_id_to_name(channel_id)
+      unless @channel_id_to_name && @channel_id_to_name.has_key?(channel_id)
+        refresh_channel_info
+      end
+      SlackbotFrd::Log::warn("#{self.class}: Channel id '#{channel_id}' not found") unless @channel_id_to_name.include?(channel_id)
+      @channel_id_to_name[channel_id]
+    end
+
+    def channel_name_to_id(channel_name)
+      return channel_name if channel_name == :any
+      nc = normalize_channel_name(channel_name)
+      unless @channel_name_to_id && @channel_name_to_id.has_key?(nc)
+        refresh_channel_info
+      end
+      SlackbotFrd::Log::warn("#{self.class}: Channel name '#{nc}' not found") unless @channel_name_to_id.include?(nc)
+      @channel_name_to_id[nc]
+    end
+
+    private
+    def normalize_channel_name(channel_name)
+      return channel_name[1..-1] if channel_name.start_with?('#')
+      channel_name
+    end
+
+    private
+    def process_message_received(event)
+      message = JSON.parse(event.data)
+      SlackbotFrd::Log::verbose("#{self.class}: Message received: #{message}")
+      if message["type"] == "message"
+        if message["subtype"] == "channel_join"
+          process_join_message(message)
+        elsif message["subtype"] == "channel_leave"
+          process_leave_message(message)
+        elsif message["subtype"] == "file_share"
+          process_file_share(message)
+        else
+          process_chat_message(message)
+        end
+      end
+    end
+
+    private
+    def process_file_share(message)
+      SlackbotFrd::Log::verbose("#{self.class}: Processing file share: #{message}")
+      SlackbotFrd::Log::debug("#{self.class}: Not processing file share because it is not implemented:")
+    end
+
+    private
+    def process_chat_message(message)
+      SlackbotFrd::Log::verbose("#{self.class}: Processing chat message: #{message}")
+
+      user = message["user"]
+      user = :bot if message["subtype"] == "bot_message"
+      channel = message["channel"]
+      text = message["text"]
+
+      unless user
+        SlackbotFrd::Log::warn("#{self.class}: Chat message doesn't include user! message: #{message}")
+        return
+      end
+
+      unless channel
+        SlackbotFrd::Log::warn("#{self.class}: Chat message doesn't include channel! message: #{message}")
+        return
+      end
+
+      @on_message_callbacks.where_include_all(user, channel).each do |callback|
+        # instance_exec allows the user to call send_message and send_message_as_user
+        # without prefixing like this: slack_connection.send_message()
+        #  
+        # However, it makes calling functions defined in the class not work, so
+        # for now we aren't going to do it
+        #
+        #instance_exec(user_id_to_name(user), channel_id_to_name(channel), text, &callback)
+        callback.call(user_id_to_name(user), channel_id_to_name(channel), text)
+      end
+    end
+
+    private
+    def process_join_message(message)
+      SlackbotFrd::Log::verbose("#{self.class}: Processing join message: #{message}")
+      user = message["user"]
+      user = :bot if message["subtype"] == "bot_message"
+      channel = message["channel"]
+      @on_channel_joined_callbacks.where_include_all(user, channel).each do |callback|
+        callback.call(user_id_to_name(user), channel_id_to_name(channel))
+      end
+    end
+
+    private
+    def process_leave_message(message)
+      SlackbotFrd::Log::verbose("#{self.class}: Processing leave message: #{message}")
+      user = message["user"]
+      user = :bot if message["subtype"] == "bot_message"
+      channel = message["channel"]
+      @on_channel_left_callbacks.where_include_all(user, channel).each do |callback|
+        callback.call(user_id_to_name(user), channel_id_to_name(channel))
+      end
+    end
+
+    private
+    def refresh_user_info
+      users_list = SlackbotFrd::SlackMethods::UsersList.new(@token).connect
+      @user_id_to_name = users_list.ids_to_names
+      @user_name_to_id = users_list.names_to_ids
+    end
+
+    private
+    def refresh_channel_info
+      channels_list = SlackbotFrd::SlackMethods::ChannelsList.new(@token).connect
+      @channel_id_to_name = channels_list.ids_to_names
+      @channel_name_to_id = channels_list.names_to_ids
+
+      im_channels_list = SlackbotFrd::SlackMethods::ImChannelsList.new(@token).connect
+      @channel_id_to_name.merge!(im_channels_list.ids_to_names)
+      @channel_name_to_id.merge!(im_channels_list.names_to_ids)
+    end
+  end
+end

data/lib/slackbot_frd/lib/user_channel_callbacks.rb

@@ -0,0 +1,53 @@
+require 'slackbot_frd/lib/log'
+
+module SlackbotFrd
+  class UserChannelCallbacks
+    def initialize
+      @conditions = {}
+      @conditions[:any] = {}
+      @conditions[:any][:any] = []
+    end
+
+    def init(user, channel)
+      unless user
+        Log::error("#{self.class}: Invalid user '#{user}'")
+        raise InvalidUserError.new
+      end
+      unless channel
+        Log::error("#{self.class}: Invalid channel '#{channel}'")
+        raise InvalidChannelError.new
+      end
+      @conditions[user] ||= {}
+      @conditions[user][:any] ||= []
+      @conditions[:any][channel] ||= []
+      @conditions[user][channel] ||= []
+    end
+
+    def add(user, channel, callback)
+      init(user, channel)
+      @conditions[user][channel].push(callback)
+    end
+
+    def where(user, channel)
+      init(user, channel)
+      @conditions[user][channel] || []
+    end
+
+    def where_all
+      @conditions[:any][:any] || []
+    end
+
+    def where_include_all(user, channel)
+      init(user, channel)
+      retval = @conditions[:any][:any].dup || []
+      retval.concat(@conditions[user][:any] || [])
+      retval.concat(@conditions[:any][channel] || [])
+      retval.concat(@conditions[user][channel] || [])
+      retval
+    end
+
+    def to_s
+      "#{@conditions}"
+    end
+  end
+end

data/lib/slackbot_frd/slack_methods/channels_list.rb

@@ -0,0 +1,38 @@
+require 'httparty'
+require 'json'
+
+module SlackbotFrd
+  module SlackMethods
+    class ChannelsList
+      include HTTParty
+      base_uri 'https://slack.com/api/channels.list'
+
+      attr_reader :response
+
+      def initialize(token)
+        @token = token
+      end
+
+      def connect
+        @response = JSON.parse(self.class.post('', :body => { token: @token } ).body)
+        self
+      end
+
+      def ids_to_names
+        retval = {}
+        @response["channels"].each do |channel|
+          retval[channel["id"]] = channel["name"]
+        end
+        retval
+      end
+
+      def names_to_ids
+        retval = {}
+        @response["channels"].each do |channel|
+          retval[channel["name"]] = channel["id"]
+        end
+        retval
+      end
+    end
+  end
+end

data/lib/slackbot_frd/slack_methods/chat_post_message.rb

@@ -0,0 +1,48 @@
+require 'httparty'
+require 'json'
+
+module SlackbotFrd
+  module SlackMethods
+    class ChatPostMessage
+      include HTTParty
+      base_uri 'https://slack.com/api/chat.postMessage'
+
+      def self.postMessage(token, channel, message, username = nil, avatar = nil, avatar_is_emoji = nil)
+        r = ChatPostMessage.new(token, channel, message, username, avatar, avatar_is_emoji)
+        r.postMessage
+      end
+
+      def initialize(token, channel, message, username = nil, avatar = nil, avatar_is_emoji = nil)
+        @token = token
+        @channel = channel
+        @message = message
+        @username = username
+        @avatar = avatar
+        @avatar_is_emoji = avatar_is_emoji
+      end
+
+      def postMessage
+        body = {
+          token: @token,
+          channel: @channel,
+          text: @message,
+        }
+
+        if @username
+          body.merge!({ username: @username })
+
+          if @avatar_is_emoji
+            body.merge!({ icon_emoji: @avatar })
+          else
+            body.merge!({ icon_url: @avatar })
+          end
+        else
+          body.merge!({ as_user: true })
+        end
+
+        @response = self.class.post('', :body => body)
+        @response
+      end
+    end
+  end
+end

data/lib/slackbot_frd/slack_methods/im_channels_list.rb

@@ -0,0 +1,38 @@
+require 'httparty'
+require 'json'
+
+module SlackbotFrd
+  module SlackMethods
+    class ImChannelsList
+      include HTTParty
+      base_uri 'https://slack.com/api/im.list'
+
+      attr_reader :response
+
+      def initialize(token)
+        @token = token
+      end
+
+      def connect
+        @response = JSON.parse(self.class.post('', :body => { token: @token } ).body)
+        self
+      end
+
+      def ids_to_names
+        retval = {}
+        @response["ims"].each do |im|
+          retval[im["id"]] = im["user"]
+        end
+        retval
+      end
+
+      def names_to_ids
+        retval = {}
+        @response["ims"].each do |im|
+          retval[im["user"]] = im["id"]
+        end
+        retval
+      end
+    end
+  end
+end

data/lib/slackbot_frd/slack_methods/rtm_start.rb

@@ -0,0 +1,31 @@
+require 'httparty'
+require 'json'
+
+module SlackbotFrd
+  module SlackMethods
+    class RtmStart
+      include HTTParty
+      base_uri 'https://slack.com/api/rtm.start'
+
+      def self.wss_url(token)
+        r = RtmStart.new(token)
+        r.connect
+        r.wss_url
+      end
+
+      def initialize(token)
+        @token = token
+      end
+
+      def connect
+        @response = JSON.parse(self.class.post('', :body => { token: @token } ).body)
+        @response
+      end
+
+      def wss_url
+        #return "ERR" unless @response.has_key?("url")
+        @response["url"]
+      end
+    end
+  end
+end

data/lib/slackbot_frd/slack_methods/users_list.rb

@@ -0,0 +1,38 @@
+require 'httparty'
+require 'json'
+
+module SlackbotFrd
+  module SlackMethods
+    class UsersList
+      include HTTParty
+      base_uri 'https://slack.com/api/users.list'
+
+      attr_reader :response
+
+      def initialize(token)
+        @token = token
+      end
+
+      def connect
+        @response = JSON.parse(self.class.post('', :body => { token: @token } ).body)
+        self
+      end
+
+      def ids_to_names
+        retval = {}
+        @response["members"].each do |user|
+          retval[user["id"]] = user["name"]
+        end
+        retval
+      end
+
+      def names_to_ids
+        retval = {}
+        @response["members"].each do |user|
+          retval[user["name"]] = user["id"]
+        end
+        retval
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification
+name: slackbot_frd
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ben Porter
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+- !ruby/object:Gem::Dependency
+  name: faye-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+- !ruby/object:Gem::Dependency
+  name: daemons
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: The slack web api is good, but very raw.  What you need is a great ruby
+  framework to abstract away all that.  This is it!  This framework allows you to
+  write bots easily by providing methods that are easy to call.  Behind the scenes,
+  the framework is negotiating your real time stream, converting channel names and
+  user names to and from IDs so you can use the names instead, and parsing/classifying
+  the real time messages into useful types that you can hook into.  Don't write your
+  bot without this.
+email: BenjaminPorter86@gmail.com
+executables:
+- slackbot-frd
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/slackbot-frd
+- lib/slackbot_frd.rb
+- lib/slackbot_frd/initializer/bot_starter.rb
+- lib/slackbot_frd/initializer/bot_starter_cli.rb
+- lib/slackbot_frd/lib/bot.rb
+- lib/slackbot_frd/lib/errors.rb
+- lib/slackbot_frd/lib/log.rb
+- lib/slackbot_frd/lib/slack_connection.rb
+- lib/slackbot_frd/lib/user_channel_callbacks.rb
+- lib/slackbot_frd/slack_methods/channels_list.rb
+- lib/slackbot_frd/slack_methods/chat_post_message.rb
+- lib/slackbot_frd/slack_methods/im_channels_list.rb
+- lib/slackbot_frd/slack_methods/rtm_start.rb
+- lib/slackbot_frd/slack_methods/users_list.rb
+homepage: http://rubygems.org/gems/slackbot_frd
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: slackbot_frd provides a dirt-simple framework for implementing one or more
+  slack bots
+test_files: []