slacks 0.4.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4655b64b95738df424e627dd671d219ee46c55e3
-  data.tar.gz: d5f1d21638a975aeb802d17a2b00d814b14579f3
+SHA256:
+  metadata.gz: 3042bf152b61c2caa8a3b4fe792b49822d46915712a8573f6bcafc86132ae2b8
+  data.tar.gz: 116df1499c672f6d72c23894c4b9abe0133cbe855766175488384509845c5ec0
 SHA512:
-  metadata.gz: 5742d45eb577916616ddba1bbe6b2b231ddb501a0795320aa4de58049a037f2f3b16101f4199093c068c4deebcb970f732a752ed050a2213926b422b3eaf5804
-  data.tar.gz: a1df56de686279475cb65b2fb7b14afe49afe01b407f654eeafa48f3efb109c928d55289ce0e0aacab4e030590ea8241eab1d48d8bc950719704fe1a847ecdc2
+  metadata.gz: c1f5d964031547e6d9160d465a4b894f76aa7bbe3174c98dc7bb36964c52eddbb5a5d527c9bcfbd67f7aad93b5fe0869acc8ea0faa07fa97217f129bd537ad27
+  data.tar.gz: 03b84265b6fe59c1d2858fc12a8274fdb1301575b142f224ea6dd8d6f811c81b94dd9cab6918548e4c7249b57dd695b39bead9a5d0173af964edd334689b2a26

data/lib/slacks/channel.rb

@@ -12,17 +12,12 @@ module Slacks
     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)
-      slack.send_message(first_message, message_options.merge(channel: id))
-
-      messages.each do |message|
-        sleep message.length / slack.typing_speed
-        slack.send_message(message, channel: id)
+      if messages.first.is_a?(Array)
+        reply_many(messages[0])
+      else
+        reply_one(*messages)
       end
     end
     alias :say :reply
@@ -61,6 +56,19 @@ module Slacks
       "##{name}"
     end
 
+  protected
+
+    def reply_one(message, options={})
+      slack.send_message(message, options.merge(channel: id))
+    end
+
+    def reply_many(messages)
+      messages.each_with_index.map do |message, i|
+        sleep message.length / slack.typing_speed if i > 0
+        slack.send_message(message, channel: id)
+      end
+    end
+
   private
     attr_reader :slack
   end

data/lib/slacks/connection.rb

@@ -24,10 +24,8 @@ module Slacks
       @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 = {}
+      @conversations_by_id = {}
+      @conversation_ids_by_name = {}
     end
 
 
@@ -41,11 +39,8 @@ module Slacks
         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)
-    rescue Slacks::ResponseError
-      $!.response
+      params.merge!(options.select { |key, _| SEND_MESSAGE_PARAMS.member?(key) })
+      api("chat.postMessage", **params)
     end
     alias :say :send_message
 
@@ -53,9 +48,7 @@ module Slacks
       params = {
         channel: to_channel_id(channel),
         timestamp: ts }
-      api("reactions.get", params)
-    rescue Slacks::ResponseError
-      $!.response
+      api("reactions.get", **params)
     end
 
     def update_message(ts, message, options={})
@@ -70,34 +63,38 @@ module Slacks
       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.update", params)
-    rescue Slacks::ResponseError
-      $!.response
+      api("chat.update", **params)
     end
 
     def add_reaction(emojis, message)
       Array(emojis).each do |emoji|
-        api("reactions.add", {
+        api("reactions.add",
           name: emoji.gsub(/^:|:$/, ""),
           channel: message.channel.id,
-          timestamp: message.timestamp })
+          timestamp: message.timestamp)
       end
-    rescue Slacks::ResponseError
-      $!.response
     end
 
+
+
     def typing_on(channel)
+      raise NotListeningError unless listening?
       websocket.write MultiJson.dump(type: "typing", channel: to_channel_id(channel))
     end
 
+    def ping
+      raise NotListeningError unless listening?
+      websocket.ping
+    end
+
+    def listening?
+      !websocket.nil?
+    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)
 
       @websocket = Slacks::Driver.new
@@ -117,21 +114,16 @@ module Slacks
           # one, we'll skill it.
           next
 
-        when EVENT_GROUP_JOINED
-          group = data["channel"]
-          @groups_by_id[group["id"]] = group
-          @group_id_by_name[group["name"]] = group["id"]
+        when EVENT_GROUP_JOINED, EVENT_CHANNEL_CREATED
+          conversation = data["channel"]
+          @conversations_by_id[conversation["id"]] = conversation
+          @conversation_ids_by_name[conversation["name"]] = conversation["id"]
 
         when EVENT_USER_JOINED
           user = data["user"]
           @users_by_id[user["id"]] = user
           @user_id_by_name[user["name"]] = user["id"]
 
-        when EVENT_CHANNEL_CREATED
-          channel = data["channel"]
-          @channels_by_id[channel["id"]] = channel
-          @channel_id_by_name[channel["name"]] = channel["id"]
-
         when EVENT_MESSAGE
           # Don't respond to things that this bot said
           next if data["user"] == bot.id
@@ -158,7 +150,18 @@ module Slacks
 
 
     def channels
-      user_id_by_name.keys + group_id_by_name.keys + channel_id_by_name.keys
+      channels = user_id_by_name.keys + conversation_ids_by_name.keys
+      if channels.empty?
+        fetch_conversations!
+        fetch_users!
+      end
+      channels
+    end
+
+    def can_see?(channel)
+      to_channel_id(channel).present?
+    rescue ArgumentError
+      false
     end
 
 
@@ -172,13 +175,9 @@ module Slacks
           "id" => id,
           "is_im" => true,
           "name" => user.username }
-      when /^G/
-        Slacks::Channel.new(self, groups_by_id.fetch(id) do
-          raise ArgumentError, "Unable to find a group with the ID #{id.inspect}"
-        end)
       else
-        Slacks::Channel.new(self, channels_by_id.fetch(id) do
-          raise ArgumentError, "Unable to find a channel with the ID #{id.inspect}"
+        Slacks::Channel.new(self, conversations_by_id.fetch(id) do
+          raise ArgumentError, "Unable to find a conversation with the ID #{id.inspect}"
         end)
       end
     end
@@ -213,10 +212,8 @@ module Slacks
     attr_reader :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,
+                :conversations_by_id,
+                :conversation_ids_by_name,
                 :websocket_url,
                 :websocket
 
@@ -227,16 +224,8 @@ module Slacks
       @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)
+      @conversations_by_id = Hash[response.fetch("channels").map { |attrs| [ attrs.fetch("id"), attrs ] }]
+      @conversation_ids_by_name = Hash[response.fetch("channels").map { |attrs| [ attrs["name"], attrs["id"] ] }]
     end
 
 
@@ -245,13 +234,9 @@ module Slacks
       return name.id if name.is_a?(Slacks::Channel)
       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)
+      name = name.gsub(/^#/, "") # Leading hashes are no longer a thing in the conversations API
+      conversation_ids_by_name[name] || fetch_conversations![name] || missing_conversation!(name)
     end
 
     def to_user_id(name)
@@ -264,40 +249,29 @@ module Slacks
 
     def get_dm_for_user_id(user_id)
       user_ids_dm_ids[user_id] ||= begin
-        response = api("im.open", user: user_id)
-        raise UnableToDirectMessageError.new(response, user_id) unless response["ok"]
+        response = api("conversations.open", user: user_id)
         response["channel"]["id"]
       end
     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"]] }]
+    def fetch_conversations!
+      conversations, ims = api("conversations.list")["channels"].partition { |attrs| attrs["is_channel"] || attrs["is_group"] }
+      user_ids_dm_ids.merge! Hash[ims.map { |attrs| attrs.values_at("user", "id") }]
+      @conversations_by_id = Hash[conversations.map { |attrs| [ attrs.fetch("id"), attrs ] }]
+      @conversation_ids_by_name = Hash[conversations.map { |attrs| [ attrs["name"], attrs["id"] ] }]
     end
 
     def fetch_users!
       response = api("users.list")
-      @users_by_id = response["members"].index_by { |attrs| attrs["id"] }
+      @users_by_id = response["members"].each_with_object({}) { |attrs, hash| hash[attrs["id"]] = attrs }
       @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}"
+    def missing_conversation!(name)
+      raise ArgumentError, "Couldn't find a conversation named #{name}"
     end
 
     def missing_user!(name)
@@ -309,8 +283,7 @@ module Slacks
     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") }]
+        fetch_conversations!
         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
@@ -319,9 +292,36 @@ module Slacks
 
 
 
-    def api(command, options={})
-      response = http.post(command, options.merge(token: token))
-      MultiJson.load(response.body)
+    def api(command, page_limit: MAX_PAGES, **params)
+      params_with_token = params.merge(token: token)
+      response = api_post command, params_with_token
+      fetched_pages = 1
+      cursor = response.dig("response_metadata", "next_cursor")
+      while cursor && !cursor.empty? && fetched_pages < page_limit do
+        api_post(command, params_with_token.merge(cursor: cursor)).each do |key, value|
+          if value.is_a?(Array)
+            response[key].concat value
+          elsif value.is_a?(Hash)
+            response[key].merge! value
+          else
+            response[key] = value
+          end
+        end
+        fetched_pages += 1
+        cursor = response.dig("response_metadata", "next_cursor")
+      end
+      response
+    end
+
+    def api_post(command, params)
+      response = http.post(command, params)
+      response = MultiJson.load(response.body)
+      unless response["ok"]
+        response["error"].split(/,\s*/).each do |error_code|
+          raise ::Slacks::Response.fetch(error_code).new(command, params, response)
+        end
+      end
+      response
 
     rescue MultiJson::ParseError
       $!.additional_information[:response_body] = response.body
@@ -335,5 +335,22 @@ module Slacks
       end
     end
 
+
+
+    SEND_MESSAGE_PARAMS = %i{
+      username
+      as_user
+      parse
+      link_names
+      unfurl_links
+      unfurl_media
+      icon_url
+      icon_emoji
+      thread_ts
+      reply_broadcast
+    }.freeze
+
+    MAX_PAGES = 9001
+
   end
 end

data/lib/slacks/driver.rb

@@ -70,6 +70,10 @@ module Slacks
       @driver.text(message)
     end
 
+    def ping
+      @driver.ping
+    end
+
     def connected?
       @connected || false
     end

data/lib/slacks/errors.rb

@@ -1,19 +1,79 @@
 require "slacks/core_ext/exception"
 
 module Slacks
-  class MigrationInProgress < RuntimeError
-    def initialize
-      super "Team is being migrated between servers. Try the request again in a few seconds."
+  module Response
+    class Error < RuntimeError
+      attr_reader :command, :params, :response
+
+      def initialize(command, params, response, message)
+        super message
+        @command = command
+        @params = params
+        @response = response
+        additional_information[:command] = command
+        additional_information[:params] = params
+        additional_information[:response] = response
+      end
     end
-  end
 
-  class ResponseError < RuntimeError
-    attr_reader :response
+    class UnspecifiedError < ::Slacks::Response::Error
+      def initialize(command, params, response)
+        super command, params, response, "Request failed with #{response["error"].inspect}"
+      end
+    end
+
+    @_errors = {}
+
+    def self.fetch(error_code)
+      @_errors.fetch(error_code, ::Slacks::Response::UnspecifiedError)
+    end
+
+    {
+      "account_inactive"       => "Authentication token is for a deleted user or team.",
+      "already_reacted"        => "The specified item already has the user/reaction combination.",
+      "bad_timestamp"          => "Value passed for timestamp was invalid.",
+      "cant_update_message"    => "Authenticated user does not have permission to update this message.",
+      "channel_not_found"      => "Value passed for channel was invalid.",
+      "edit_window_closed"     => "The message cannot be edited due to the team message edit settings",
+      "fatal_error"            => "",
+      "file_comment_not_found" => "File comment specified by file_comment does not exist.",
+      "file_not_found"         => "File specified by file does not exist.",
+      "invalid_arg_name"       => "The method was passed an argument whose name falls outside the bounds of common decency. This includes very long names and names with non-alphanumeric characters other than _. If you get this error, it is typically an indication that you have made a very malformed API call.",
+      "invalid_array_arg"      => "The method was passed a PHP-style array argument (e.g. with a name like foo[7]). These are never valid with the Slack API.",
+      "invalid_auth"           => "Invalid authentication token.",
+      "invalid_charset"        => "The method was called via a POST request, but the charset specified in the Content-Type header was invalid. Valid charset names are: utf-8 iso-8859-1.",
+      "invalid_form_data"      => "The method was called via a POST request with Content-Type application/x-www-form-urlencoded or multipart/form-data, but the form data was either missing or syntactically invalid.",
+      "invalid_name"           => "Value passed for name was invalid.",
+      "invalid_post_type"      => "The method was called via a POST request, but the specified Content-Type was invalid. Valid types are: application/json application/x-www-form-urlencoded multipart/form-data text/plain.",
+      "is_archived"            => "Channel has been archived.",
+      "message_not_found"      => "Message specified by channel and timestamp does not exist.",
+      "migration_in_progress"  => "Team is being migrated between servers. See the team_migration_started event documentation for details.",
+      "missing_post_type"      => "The method was called via a POST request and included a data payload, but the request did not include a Content-Type header.",
+      "msg_too_long"           => "Message text is too long",
+      "no_item_specified"      => "file, file_comment, or combination of channel and timestamp was not specified.",
+      "no_text"                => "No message text provided",
+      "not_authed"             => "No authentication token provided.",
+      "not_in_channel"         => "Cannot post user messages to a channel they are not in.",
+      "rate_limited"           => "Application has posted too many messages, read the Rate Limit documentation for more information",
+      "request_timeout"        => "The method was called via a POST request, but the POST data was either missing or truncated.",
+      "too_many_attachments"   => "Too many attachments were provided with this message. A maximum of 100 attachments are allowed on a message.",
+      "too_many_emoji"         => "The limit for distinct reactions (i.e emoji) on the item has been reached.",
+      "too_many_reactions"     => "The limit for reactions a person may add to the item has been reached."
+    }.each do |error_code, message|
+      class_name = error_code.gsub(/(?:^|_)([a-z]+)/) { $1.capitalize }
+      class_name = {
+        "MsgTooLong" => "MessageTooLong"
+      }.fetch(class_name, class_name)
+
+      module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        class #{class_name} < ::Slacks::Response::Error
+          def initialize(command, params, response)
+            super command, params, response, "#{message}"
+          end
+        end
 
-    def initialize(response, message)
-      super message
-      @response = response
-      additional_information[:response] = response
+        @_errors["#{error_code}"] = ::Slacks::Response::#{class_name}
+      RUBY
     end
   end
 
@@ -24,21 +84,21 @@ module Slacks
     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
 
-  class UnableToDirectMessageError < ResponseError
-    def initialize(response, user_id)
-      super response, "Unable to direct message the user #{user_id.inspect}: #{response["error"]}"
+  class MissingTokenError < ArgumentError
+    def initialize
+      super "Unable to connect to Slack; a token has no"
+    end
+  end
+
+  class NotListeningError < ArgumentError
+    def initialize
+      super "Not connected to the RTM API; call `listen!` first"
     end
   end
 end

data/lib/slacks/version.rb

@@ -1,3 +1,3 @@
 module Slacks
-  VERSION = "0.4.2"
+  VERSION = "0.6.0"
 end

data/slacks.gemspec

@@ -25,8 +25,8 @@ Gem::Specification.new do |spec|
   spec.add_dependency "faraday-raise-errors"
   spec.add_dependency "concurrent-ruby"
 
-  spec.add_development_dependency "bundler", "~> 1.10"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
   spec.add_development_dependency "minitest", "~> 5.0"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "minitest-reporters"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slacks
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.6.0
 platform: ruby
 authors:
 - Bob Lail
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2016-09-02 00:00:00.000000000 Z
+date: 2021-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: websocket-driver
@@ -84,30 +84,30 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -164,7 +164,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - bob.lailfamily@gmail.com
 executables: []
@@ -196,7 +196,7 @@ homepage: https://github.com/houston/slacks
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -211,9 +211,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: A library for communicating via Slack
 test_files: []