slacks 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 789c9ac13d517eb62b249b38f9bdd781295e14e4
+  data.tar.gz: d05efc4b0f64cdc399324b52257f3fd88884f19d
+SHA512:
+  metadata.gz: df416c6fdb36216f70a5d76537aef833ea11e1996f186aa9caaad4d0bf55e30ef7629a0e528fab52845e8b933e6ea500f2635dbc0ec6176f6fb8f710f5af409d
+  data.tar.gz: 02e5185cc2714d40259aedd3b4211d4b764ac5c6ca4d2bc7892f5cb20e3989fbe8c79b5d729ab01e5ceb88b390850083405ec5f49b7d7b4f2cf9944fb9d67f9d

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/.ruby-version
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.3
+before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in slacks.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Bob Lail
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,41 @@
+# Slacks
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/slacks`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'slacks'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install slacks
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/slacks.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "slacks"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/slacks/bot_user.rb

@@ -0,0 +1,15 @@
+module Slacks
+  class BotUser
+    attr_reader :id, :name
+
+    def initialize(data)
+      @id = data.fetch("id")
+      @name = data.fetch("name")
+    end
+
+    def to_s
+      "@#{name}"
+    end
+
+  end
+end

data/lib/slacks/channel.rb

@@ -0,0 +1,79 @@
+module Slacks
+  class Channel
+    attr_reader :id, :name, :type
+
+    def initialize(session, attributes={})
+      @session = session
+      @id = attributes["id"]
+      @name = attributes["name"]
+      @type = :channel
+      @type = :group if attributes["is_group"]
+      @type = :direct_message if attributes["is_im"]
+    end
+
+    def reply(*messages)
+      messages.flatten!
+      return unless messages.any?
+
+      first_message = messages.shift
+      message_options = {}
+      message_options = messages.shift if messages.length == 1 && messages[0].is_a?(Hash)
+      session.slack.send_message(first_message, message_options.merge(channel: id))
+
+      messages.each do |message|
+        sleep message.length / session.typing_speed
+        session.slack.send_message(message, channel: id)
+      end
+    end
+    alias :say :reply
+
+    def random_reply(replies)
+      if replies.is_a?(Hash)
+        weights = replies.values
+        unless weights.reduce(&:+) == 1.0
+          raise ArgumentError, "Reply weights don't add up to 1.0"
+        end
+
+        draw = rand
+        sum = 0
+        pick = nil
+        replies.each do |reply, weight|
+          pick = reply unless sum > draw
+          sum += weight
+        end
+        reply pick
+      else
+        reply replies.sample
+      end
+    end
+
+    def direct_message?
+      type == :direct_message
+    end
+    alias :dm? :direct_message?
+    alias :im? :direct_message?
+
+    def private_group?
+      type == :group
+    end
+    alias :group? :private_group?
+    alias :private? :private_group?
+
+    def guest?
+      false
+    end
+
+    def inspect
+      "<Slacks::Channel id=\"#{id}\" name=\"#{name}\">"
+    end
+
+    def to_s
+      return name if private?
+      return "@#{name}" if direct_message?
+      "##{name}"
+    end
+
+  private
+    attr_reader :session
+  end
+end

data/lib/slacks/connection.rb

@@ -0,0 +1,287 @@
+require "slacks/bot_user"
+require "slacks/team"
+require "slacks/channel"
+require "slacks/guest_channel"
+require "slacks/conversation"
+require "slacks/driver"
+require "slacks/rtm_event"
+require "slacks/listener"
+require "slacks/message"
+require "slacks/user"
+require "slacks/errors"
+require "faraday"
+require "faraday/raise_errors"
+
+module Slacks
+  class Connection
+    attr_reader :team, :bot, :token
+
+    EVENT_MESSAGE = "message".freeze
+    EVENT_GROUP_JOINED = "group_joined".freeze
+    EVENT_USER_JOINED = "team_join".freeze
+
+    def initialize(session, token)
+      @user_ids_dm_ids = {}
+      @users_by_id = {}
+      @user_id_by_name = {}
+      @groups_by_id = {}
+      @group_id_by_name = {}
+      @channels_by_id = {}
+      @channel_id_by_name = {}
+
+      @session = session
+      @token = token
+    end
+
+
+
+    def send_message(message, options={})
+      channel = options.fetch(:channel) { raise ArgumentError, "Missing parameter :channel" }
+      attachments = Array(options[:attachments])
+      params = {
+        channel: to_channel_id(channel),
+        text: message,
+        as_user: true, # post as the authenticated user (rather than as slackbot)
+        link_names: 1} # find and link channel names and user names
+      params.merge!(attachments: MultiJson.dump(attachments)) if attachments.any?
+      params.merge!(options.select { |key, _| [:username, :as_user, :parse, :link_names,
+        :unfurl_links, :unfurl_media, :icon_url, :icon_emoji].member?(key) })
+      api("chat.postMessage", params)
+    end
+
+    def add_reaction(emojis, message)
+      Array(emojis).each do |emoji|
+        api("reactions.add", {
+          name: emoji.gsub(/^:|:$/, ""),
+          channel: message.channel.id,
+          timestamp: message.timestamp })
+      end
+    end
+
+
+
+    def listen!
+      response = api("rtm.start")
+
+      unless response["ok"]
+        raise MigrationInProgress if response["error"] == "migration_in_progress"
+        raise ResponseError.new(response, response["error"])
+      end
+
+      store_context!(response)
+
+      client = Slacks::Driver.new
+      client.connect_to websocket_url
+
+      client.on(:error) do |event|
+        raise ConnectionError.new(event)
+      end
+
+      client.on(:message) do |data|
+        case data["type"]
+        when EVENT_GROUP_JOINED
+          group = data["channel"]
+          @groups_by_id[group["id"]] = group
+          @group_id_by_name[group["name"]] = group["id"]
+
+        when EVENT_USER_JOINED
+          user = data["user"]
+          @users_by_id[user["id"]] = user
+          @user_id_by_name[user["name"]] = user["id"]
+
+        when EVENT_MESSAGE
+          # Don't respond to things that this bot said
+          next if data["user"] == bot.id
+          # ...or to messages with no text
+          next if data["text"].nil? || data["text"].empty?
+          yield data
+        end
+      end
+
+      client.main_loop
+
+    rescue EOFError
+      # Slack hung up on us, we'll ask for a new WebSocket URL and reconnect.
+      session.error "Websocket Driver received EOF; reconnecting"
+      retry
+    end
+
+
+
+    def channels
+      user_id_by_name.keys + group_id_by_name.keys + channel_id_by_name.keys
+    end
+
+
+
+    def find_channel(id)
+      case id
+      when /^U/ then find_user(id)
+      when /^D/
+        user = find_user(get_user_id_for_dm(id))
+        Slacks::Channel.new session, {
+          "id" => id,
+          "is_im" => true,
+          "name" => user.username }
+      when /^G/
+        Slacks::Channel.new session, groups_by_id.fetch(id) do
+          raise ArgumentError, "Unable to find a group with the ID #{id.inspect}"
+        end
+      else
+        Slacks::Channel.new session, channels_by_id.fetch(id) do
+          raise ArgumentError, "Unable to find a channel with the ID #{id.inspect}"
+        end
+      end
+    end
+
+    def find_user(id)
+      Slacks::User.new session, users_by_id.fetch(id) do
+        raise ArgumentError, "Unable to find a user with the ID #{id.inspect}"
+      end
+    end
+
+
+
+    def user_exists?(username)
+      return false if username.nil?
+      to_user_id(username).present?
+    rescue ArgumentError
+      false
+    end
+
+    def users
+      fetch_users! if @users_by_id.empty?
+      @users_by_id.values
+    end
+
+
+
+  private
+    attr_reader :session,
+                :user_ids_dm_ids,
+                :users_by_id,
+                :user_id_by_name,
+                :groups_by_id,
+                :group_id_by_name,
+                :channels_by_id,
+                :channel_id_by_name,
+                :websocket_url
+
+
+
+    def store_context!(response)
+      @websocket_url = response.fetch("url")
+      @bot = BotUser.new(response.fetch("self"))
+      @team = Team.new(response.fetch("team"))
+
+      @channels_by_id = Hash[response.fetch("channels").map { |attrs| [attrs.fetch("id"), attrs] }]
+      @channel_id_by_name = Hash[response.fetch("channels").map { |attrs| ["##{attrs.fetch("name")}", attrs.fetch("id")] }]
+
+      @users_by_id = Hash[response.fetch("users").map { |attrs| [attrs.fetch("id"), attrs] }]
+      @user_id_by_name = Hash[response.fetch("users").map { |attrs| ["@#{attrs.fetch("name")}", attrs.fetch("id")] }]
+
+      @groups_by_id = Hash[response.fetch("groups").map { |attrs| [attrs.fetch("id"), attrs] }]
+      @group_id_by_name = Hash[response.fetch("groups").map { |attrs| [attrs.fetch("name"), attrs.fetch("id")] }]
+    rescue KeyError
+      raise ResponseError.new(response, $!.message)
+    end
+
+
+
+    def to_channel_id(name)
+      return name if name =~ /^[DGC]/ # this already looks like a channel id
+      return get_dm_for_username(name) if name.start_with?("@")
+      return to_group_id(name) unless name.start_with?("#")
+
+      channel_id_by_name[name] || fetch_channels![name] || missing_channel!(name)
+    end
+
+    def to_group_id(name)
+      group_id_by_name[name] || fetch_groups![name] || missing_group!(name)
+    end
+
+    def to_user_id(name)
+      user_id_by_name[name] || fetch_users![name] || missing_user!(name)
+    end
+
+    def get_dm_for_username(name)
+      get_dm_for_user_id to_user_id(name)
+    end
+
+    def get_dm_for_user_id(user_id)
+      channel_id = user_ids_dm_ids[user_id] ||= begin
+        response = api("im.open", user: user_id)
+        raise ArgumentError, "Unable to direct message the user #{user_id.inspect}: #{response["error"]}" unless response["ok"]
+        response["channel"]["id"]
+      end
+      raise ArgumentError, "Unable to direct message the user #{user_id.inspect}" unless channel_id
+      channel_id
+    end
+
+
+
+    def fetch_channels!
+      response = api("channels.list")
+      @channels_by_id = response["channels"].index_by { |attrs| attrs["id"] }
+      @channel_id_by_name = Hash[response["channels"].map { |attrs| ["##{attrs["name"]}", attrs["id"]] }]
+    end
+
+    def fetch_groups!
+      response = api("groups.list")
+      @groups_by_id = response["groups"].index_by { |attrs| attrs["id"] }
+      @group_id_by_name = Hash[response["groups"].map { |attrs| [attrs["name"], attrs["id"]] }]
+    end
+
+    def fetch_users!
+      response = api("users.list")
+      @users_by_id = response["members"].index_by { |attrs| attrs["id"] }
+      @user_id_by_name = Hash[response["members"].map { |attrs| ["@#{attrs["name"]}", attrs["id"]] }]
+    end
+
+
+
+    def missing_channel!(name)
+      raise ArgumentError, "Couldn't find a channel named #{name}"
+    end
+
+    def missing_group!(name)
+      raise ArgumentError, "Couldn't find a private group named #{name}"
+    end
+
+    def missing_user!(name)
+      raise ArgumentError, "Couldn't find a user named #{name}"
+    end
+
+
+
+    def get_user_id_for_dm(dm)
+      user_id = user_ids_dm_ids.key(dm)
+      unless user_id
+        response = api("im.list")
+        user_ids_dm_ids.merge! Hash[response["ims"].map { |attrs| attrs.values_at("user", "id") }]
+        user_id = user_ids_dm_ids.key(dm)
+      end
+      raise ArgumentError, "Unable to find a user for the direct message ID #{dm.inspect}" unless user_id
+      user_id
+    end
+
+
+
+    def api(command, options={})
+      response = http.post(command, options.merge(token: token))
+      MultiJson.load(response.body)
+
+    rescue MultiJson::ParseError
+      $!.additional_information[:response_body] = response.body
+      $!.additional_information[:response_status] = response.status
+      raise
+    end
+
+    def http
+      @http ||= Faraday.new(url: "https://slack.com/api").tap do |connection|
+        connection.use Faraday::RaiseErrors
+      end
+    end
+
+  end
+end

data/lib/slacks/conversation.rb

@@ -0,0 +1,48 @@
+require "thread_safe"
+
+module Slacks
+  class Conversation
+
+    def initialize(session, channel, sender)
+      @session = session
+      raise NotInChannelError, channel if channel.guest?
+
+      @channel = channel
+      @sender = sender
+      @listeners = ThreadSafe::Array.new
+    end
+
+    def listen_for(matcher, flags=[], &block)
+      session.listen_for(matcher, flags, &block).tap do |listener|
+        listener.conversation = self
+        listeners.push listener
+      end
+    end
+
+    def includes?(e)
+      e.channel.id == channel.id && e.sender.id == sender.id
+    end
+
+    def reply(*messages)
+      channel.reply(*messages)
+    end
+    alias :say :reply
+
+    def ask(question, expect: nil)
+      listen_for(expect) do |e|
+        e.stop_listening!
+        yield e
+      end
+
+      reply question
+    end
+
+    def end!
+      listeners.each(&:stop_listening!)
+    end
+
+  private
+    attr_reader :session, :channel, :sender, :listeners
+
+  end
+end

data/lib/slacks/core_ext/exception.rb

@@ -0,0 +1,7 @@
+# Allow exception handlers to add information
+# to an exception for upstream
+class Exception
+  def additional_information
+    @additional_information ||= {}
+  end
+end

data/lib/slacks/driver.rb

@@ -0,0 +1,91 @@
+require "multi_json"
+require "socket"
+require "websocket/driver"
+
+# Adapted from https://github.com/mackwic/slack-rtmapi
+
+module Slacks
+  class Driver
+    attr_accessor :stop
+
+    def initialize
+      @has_been_init = false
+      @stop = false
+      @callbacks = {}
+    end
+
+    VALID = [:open, :message, :error].freeze
+    def on(type, &block)
+      unless VALID.include? type
+        raise ArgumentError.new "Client#on accept one of #{VALID.inspect}"
+      end
+
+      callbacks[type] = block
+    end
+
+    # This init has been delayed because the SSL handshake is a blocking and
+    # expensive call
+    def connect_to(url)
+      raise "Already been init" if @has_been_init
+      url = URI(url)
+      raise ArgumentError.new ":url must be a valid websocket secure url!" unless url.scheme == "wss"
+
+      @socket = OpenSSL::SSL::SSLSocket.new(TCPSocket.new url.host, 443)
+      socket.connect # costly and blocking !
+
+      internalWrapper = (Struct.new :url, :socket do
+        def write(*args)
+          self.socket.write(*args)
+        end
+      end).new url.to_s, socket
+
+      # this, also, is costly and blocking
+      @driver = WebSocket::Driver.client internalWrapper
+      driver.on :open do
+        @connected = true
+        unless callbacks[:open].nil?
+          callbacks[:open].call
+        end
+      end
+
+      driver.on :error do |event|
+        @connected = false
+        unless callbacks[:error].nil?
+          callbacks[:error].call event
+        end
+      end
+
+      driver.on :message do |event|
+        data = MultiJson.load event.data
+        unless callbacks[:message].nil?
+          callbacks[:message].call data
+        end
+      end
+
+      driver.start
+      @has_been_init = true
+    end
+
+    def connected?
+      @connected || false
+    end
+
+    # All the polling work is done here
+    def inner_loop
+      return if @stop
+
+      data = @socket.readpartial 4096
+      driver.parse data unless data.nil? or data.empty?
+    end
+
+    def main_loop
+      loop do
+        inner_loop
+      end
+    end
+
+  private
+    attr_reader :url, :socket, :driver, :callbacks
+
+  end
+end

data/lib/slacks/errors.rb

@@ -0,0 +1,33 @@
+module Slacks
+  class MigrationInProgress < RuntimeError
+    def initialize
+      super "Team is being migrated between servers. Try the request again in a few seconds."
+    end
+  end
+
+  class ResponseError < RuntimeError
+    def initialize(response, message)
+      super message
+      additional_information[:response] = response
+    end
+  end
+
+  class ConnectionError < RuntimeError
+    def initialize(event)
+      super "There was a connection error in the WebSocket"
+      additional_information[:event] = event
+    end
+  end
+
+  class AlreadyRespondedError < RuntimeError
+    def initialize(message=nil)
+      super message || "You have already replied to this Slash Command; you can only reply once"
+    end
+  end
+
+  class NotInChannelError < RuntimeError
+    def initialize(channel)
+      super "The bot is not in the channel #{channel} and cannot reply"
+    end
+  end
+end