lita-slack 0.1.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 69ca07c3550da36b31e59b943598fe2393f0f07f
-  data.tar.gz: 3638c4841bd58cf6ae53b33626449d6f9122a4e1
+  metadata.gz: d8487603a85d7972122eb6826b21534e31484a63
+  data.tar.gz: ec5c0068bdf7b935299f099eff9b1cecefad4b2b
 SHA512:
-  metadata.gz: 31299e3c3e8501f540c323a7a4e8978fc0e1d8ec40519899519505d8e1bfc42a7cf5088cb8c542be5cc03351906fa79b651f84ec6e4fe79836167828f18820d2
-  data.tar.gz: 8580bd596871b84509bddb9c00ef0432b035eb0438dc597f7de8393e7d40b93ff98537a2c67460ef87e7e5d7f1dab7dd615c367236966308268ec1d10f32ffb4
+  metadata.gz: b1b9000c60ee73995c0cfce1f36499d3b6756a0e4558bf0c96eff7bc2ceaa24e11fbe57952232291c89439850b5039739d1f93960d796081009cbeb76471a714
+  data.tar.gz: 3c8b5d80b99919f23eb2f0fce811b8f8f551cfc316e8f2ed51c73c9834e33bb904d8a75f4e5a00540cd664e5d41c9e15ec91fb6e23a3eb4e83d9afbb9e9b4a44

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 2.0.0
+script: bundle exec rake
+before_install:
+  - gem update --system
+services:
+  - redis-server
+

data/README.md

@@ -1,50 +1,37 @@
 # lita-slack
 
-**lita-slack** is an adapter for [Lita](https://github.com/jimmycuadra/lita) that allows you to use the robot with [Slack](https://slack.com/). As **lita-slack** is one way, robot messages to Slack, it depends on [lita-slack-handler](https://github.com/kenjij/lita-slack-handler) gem to receive messages from Slack.
+**lita-slack** is an adapter for [Lita](https://www.lita.io/) that allows you to use the robot with [Slack](https://slack.com/). The current adapter is not compatible with pre-1.0.0 versions, as it now uses Slack's [Real Time Messaging API](https://api.slack.com/rtm).
 
 ## Installation
 
-Add **lita-slack** and **lita-slack-handler** to your Lita instance's Gemfile:
+Add **lita-slack** to your Lita instance's Gemfile:
 
 ``` ruby
 gem "lita-slack"
-gem "lita-slack-handler"
 ```
 
 ## Configuration
 
-**First, you need to make sure your Slack team has [Incoming WebHooks](https://my.slack.com/services/new/incoming-webhook) integration setup. For configuration regarding lita-slack-handler, see its [README](https://github.com/kenjij/lita-slack-handler).**
-
-Then, define the following attributes:
-
 ### Required attributes
 
-* `incoming_token` (String) – Slack integration token.
-* `team_domain` (String) – Slack team domain; subdomain of slack.com.
-
-### Optional attributes
+* `token` (String) – The bot's Slack API token. Create a bot and get its token at https://my.slack.com/services/new/bot.
 
-* `incoming_url` (String) – Default: https://<team_domain>.slack.com/services/hooks/incoming-webhook
-* `username` (String) – Display name of the robot; default: whatever is set in Slack integration
-* `add_mention` (Bool) – Always prefix message with mention of the user which it's directed to; this triggers a notification.
+**Note**: When using lita-slack, the adapter will overwrite the bot's name and mention name with the values set on the server, so `config.robot.name` and `config.robot.mention_name` will have no effect.
 
-### Example lita_config.rb
+### Example
 
 ``` ruby
 Lita.configure do |config|
-  config.robot.name = "Lita"
-  config.robot.mention_name = "@lita"
-  # Select the Slack adapter
   config.robot.adapter = :slack
-  # lita-slack adapter config
-  config.adapter.incoming_token = "aN1NvAlIdDuMmYt0k3n"
-  config.adapter.team_domain = "example"
-  config.adapter.username = "lita"
-  # Some more handlers and other config
-  # .....
+  config.adapters.slack.token = "abcd-1234567890-hWYd21AmMH2UHAkx29vb5c1Y"
 end
 ```
 
+## Events
+
+* `:connected` - When the robot has connected to Slack. No payload.
+* `:disconnected` - When the robot has disconnected from Slack. No payload.
+
 ## License
 
 [MIT](http://opensource.org/licenses/MIT)

data/lib/lita/adapters/slack/api.rb

@@ -0,0 +1,69 @@
+require 'faraday'
+
+require 'lita/adapters/slack/team_data'
+require 'lita/adapters/slack/slack_im'
+require 'lita/adapters/slack/slack_user'
+
+module Lita
+  module Adapters
+    class Slack < Adapter
+      class API
+        def initialize(token, stubs = nil)
+          @token = token
+          @stubs = stubs
+        end
+
+        def im_open(user_id)
+          response_data = call_api("im.open", user: user_id)
+
+          SlackIM.new(response_data["channel"]["id"], user_id)
+        end
+
+        def rtm_start
+          response_data = call_api("rtm.start")
+
+          TeamData.new(
+            SlackIM.from_data_array(response_data["ims"]),
+            SlackUser.from_data(response_data["self"]),
+            SlackUser.from_data_array(response_data["users"]),
+            response_data["url"]
+          )
+        end
+
+        private
+
+        attr_reader :stubs
+        attr_reader :token
+
+        def call_api(method, post_data = {})
+          response = connection.post(
+            "https://slack.com/api/#{method}",
+            { token: token }.merge(post_data)
+          )
+
+          data = parse_response(response, method)
+
+          raise "Slack API call to #{method} returned an error: #{data["error"]}." if data["error"]
+
+          data
+        end
+
+        def connection
+          if stubs
+            Faraday.new { |faraday| faraday.adapter(:test, stubs) }
+          else
+            Faraday.new
+          end
+        end
+
+        def parse_response(response, method)
+          unless response.success?
+            raise "Slack API call to #{method} failed with status code #{response.status}."
+          end
+
+          MultiJson.load(response.body)
+        end
+      end
+    end
+  end
+end

data/lib/lita/adapters/slack/im_mapping.rb

@@ -0,0 +1,34 @@
+module Lita
+  module Adapters
+    class Slack < Adapter
+      class IMMapping
+        def initialize(api, ims)
+          @api = api
+          @mapping = {}
+
+          add_mappings(ims)
+        end
+
+        def add_mapping(im)
+          mapping[im.user_id] = im.id
+        end
+
+        def add_mappings(ims)
+          ims.each { |im| add_mapping(im) }
+        end
+
+        def im_for(user_id)
+          mapping.fetch(user_id) do
+            im = api.im_open(user_id)
+            mapping[user_id] = im.id
+          end
+        end
+
+        private
+
+        attr_reader :api
+        attr_reader :mapping
+      end
+    end
+  end
+end

data/lib/lita/adapters/slack/message_handler.rb

@@ -0,0 +1,118 @@
+module Lita
+  module Adapters
+    class Slack < Adapter
+      class MessageHandler
+        def initialize(robot, robot_id, data)
+          @robot = robot
+          @robot_id = robot_id
+          @data = data
+          @type = data["type"]
+        end
+
+        def handle
+          case type
+          when "hello"
+            handle_hello
+          when "message"
+            handle_message
+          when "user_change", "team_join"
+            handle_user_change
+          when "bot_added", "bot_changed"
+            handle_bot_change
+          when "error"
+            handle_error
+          else
+            handle_unknown
+          end
+        end
+
+        private
+
+        attr_reader :data
+        attr_reader :robot
+        attr_reader :robot_id
+        attr_reader :type
+
+        def body
+          data["text"].sub(/^\s*<@#{robot_id}>/, "@#{robot.mention_name}")
+        end
+
+        def channel
+          data["channel"]
+        end
+
+        def dispatch_message(user)
+          source = Source.new(user: user, room: channel)
+          message = Message.new(robot, body, source)
+          log.debug("Dispatching message to Lita from #{user.id}.")
+          robot.receive(message)
+        end
+
+        def from_self?(user)
+          if data["subtype"] == "bot_message"
+            robot_user = User.find_by_name(robot.name)
+
+            robot_user && robot_user.id == user.id
+          end
+        end
+
+        def handle_bot_change
+          log.debug("Updating user data for bot.")
+          UserCreator.create_user(data["bot"], robot, robot_id)
+        end
+
+        def handle_error
+          error = data["error"]
+          code = error["code"]
+          message = error["msg"]
+          log.error("Error with code #{code} received from Slack: #{message}")
+        end
+
+        def handle_hello
+          log.info("Connected to Slack.")
+          robot.trigger(:connected)
+        end
+
+        def handle_message
+          return unless supported_subtype?
+
+          user = User.find_by_id(data["user"]) || User.create(data["user"])
+
+          return if from_self?(user)
+
+          dispatch_message(user)
+        end
+
+        def handle_unknown
+          unless data["reply_to"]
+            log.debug("#{type} event received from Slack and will be ignored.")
+          end
+        end
+
+        def handle_user_change
+          log.debug("Updating user data.")
+          UserCreator.create_user(data["user"], robot, robot_id)
+        end
+
+        def log
+          Lita.logger
+        end
+
+        # Types of messages Lita should dispatch to handlers.
+        def supported_message_subtypes
+          %w(bot_message me_message)
+        end
+
+        def supported_subtype?
+          subtype = data["subtype"]
+
+          if subtype
+            supported_message_subtypes.include?(subtype)
+          else
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lita/adapters/slack/rtm_connection.rb

@@ -0,0 +1,103 @@
+require 'eventmachine'
+require 'faye/websocket'
+require 'multi_json'
+
+require 'lita/adapters/slack/api'
+require 'lita/adapters/slack/im_mapping'
+require 'lita/adapters/slack/message_handler'
+require 'lita/adapters/slack/user_creator'
+
+module Lita
+  module Adapters
+    class Slack < Adapter
+      class RTMConnection
+        MAX_MESSAGE_BYTES = 16_000
+
+        class << self
+          def build(robot, token)
+            new(robot, token, API.new(token).rtm_start)
+          end
+        end
+
+        def initialize(robot, token, team_data)
+          @robot = robot
+          @im_mapping = IMMapping.new(token, team_data.ims)
+          @websocket_url = team_data.websocket_url
+          @robot_id = team_data.self.id
+
+          UserCreator.create_users(team_data.users, robot, robot_id)
+        end
+
+        def im_for(user_id)
+          im_mapping.im_for(user_id)
+        end
+
+        def run(queue = nil)
+          EM.run do
+            log.debug("Connecting to the Slack Real Time Messaging API.")
+            @websocket = Faye::WebSocket::Client.new(websocket_url, nil, ping: 10)
+
+            websocket.on(:open) { log.debug("Connected to the Slack Real Time Messaging API.") }
+            websocket.on(:message) { |event| receive_message(event) }
+            websocket.on(:close) { log.info("Disconnected from Slack.") }
+            websocket.on(:error) { |event| log.debug("WebSocket error: #{event.message}") }
+
+            queue << websocket if queue
+          end
+        end
+
+        def send_messages(channel, strings)
+          strings.each do |string|
+            websocket.send(safe_payload_for(channel, string))
+          end
+        end
+
+        def shut_down
+          if websocket
+            log.debug("Closing connection to the Slack Real Time Messaging API.")
+            websocket.close
+          end
+
+          EM.stop if EM.reactor_running?
+        end
+
+        private
+
+        attr_reader :im_mapping
+        attr_reader :robot
+        attr_reader :robot_id
+        attr_reader :websocket
+        attr_reader :websocket_url
+
+        def log
+          Lita.logger
+        end
+
+        def payload_for(channel, string)
+          MultiJson.dump({
+            id: 1,
+            type: 'message',
+            text: string,
+            channel: channel
+          })
+        end
+
+        def receive_message(event)
+          data = MultiJson.load(event.data)
+
+          MessageHandler.new(robot, robot_id, data).handle
+        end
+
+        def safe_payload_for(channel, string)
+          payload = payload_for(channel, string)
+
+          if payload.size > MAX_MESSAGE_BYTES
+            raise ArgumentError, "Cannot send payload greater than #{MAX_MESSAGE_BYTES} bytes."
+          end
+
+          payload
+        end
+      end
+    end
+  end
+end

data/lib/lita/adapters/slack/slack_im.rb

@@ -0,0 +1,26 @@
+module Lita
+  module Adapters
+    class Slack < Adapter
+      class SlackIM
+        class << self
+          def from_data_array(ims_data)
+            ims_data.map { |im_data| from_data(im_data) }
+          end
+
+          def from_data(im_data)
+            new(im_data['id'], im_data['user'])
+          end
+        end
+
+        attr_reader :id
+        attr_reader :user_id
+
+        def initialize(id, user_id)
+          @id = id
+          @user_id = user_id
+        end
+      end
+    end
+  end
+end
+

data/lib/lita/adapters/slack/slack_user.rb

@@ -0,0 +1,31 @@
+module Lita
+  module Adapters
+    class Slack < Adapter
+      class SlackUser
+        class << self
+          def from_data(user_data)
+            new(
+              user_data['id'],
+              user_data['name'],
+              user_data['real_name']
+            )
+          end
+
+          def from_data_array(users_data)
+            users_data.map { |user_data| from_data(user_data) }
+          end
+        end
+
+        attr_reader :id
+        attr_reader :name
+        attr_reader :real_name
+
+        def initialize(id, name, real_name)
+          @id = id
+          @name = name
+          @real_name = real_name
+        end
+      end
+    end
+  end
+end

data/lib/lita/adapters/slack/team_data.rb

@@ -0,0 +1,7 @@
+module Lita
+  module Adapters
+    class Slack < Adapter
+      TeamData = Struct.new(:ims, :self, :users, :websocket_url)
+    end
+  end
+end

data/lib/lita/adapters/slack/user_creator.rb

@@ -0,0 +1,34 @@
+module Lita
+  module Adapters
+    class Slack < Adapter
+      class UserCreator
+        class << self
+          def create_user(slack_user, robot, robot_id)
+            User.create(
+              slack_user.id,
+              name: real_name(slack_user),
+              mention_name: slack_user.name
+            )
+
+            update_robot(robot, slack_user) if slack_user.id == robot_id
+          end
+
+          def create_users(slack_users, robot, robot_id)
+            slack_users.each { |slack_user| create_user(slack_user, robot, robot_id) }
+          end
+
+          private
+
+          def real_name(slack_user)
+            slack_user.real_name.size > 0 ? slack_user.real_name : slack_user.name
+          end
+
+          def update_robot(robot, slack_user)
+            robot.name = slack_user.real_name
+            robot.mention_name = slack_user.name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lita/adapters/slack.rb

@@ -1,91 +1,46 @@
-require 'lita'
-require 'faraday'
-require 'json'
+require 'lita/adapters/slack/rtm_connection'
 
 module Lita
-	module Adapters
-		class Slack < Adapter
-			# Required Lita config keys (via lita_config.rb)
-			require_configs :incoming_token, :team_domain
+  module Adapters
+    class Slack < Adapter
+      # Required configuration attributes.
+      config :token, type: String, required: true
 
-			# Adapter main run loop
-			def run
-				log.debug 'Slack::run started'
-				sleep
-				rescue Interrupt
-				shut_down
-			end
+      # Starts the connection.
+      def run
+        return if rtm_connection
 
-			def send_messages(target, strings)
-				log.debug 'Slack::send_messages started'
-				status = http_post prepare_payload(target, strings)
-				log.error "Slack::send_messages failed to send (#{status})" if status != 200
-				log.debug 'Slack::send_messages ending'
-			end
-
-			def set_topic(target, topic)
-				# Slack currently provides no method
-				log.info 'Slack::set_topic no implementation'
-			end
-
-			def shut_down
-			end
-
-      private
-
-			def prepare_payload(target, strings)
-				if not defined?(target.room)
-					channel_id = nil
-					log.warn "Slack::prepare_payload proceeding without channel designation"
-				else
-					channel_id = target.room
-				end
-				payload = {'channel' => channel_id, 'username' => username}
-				payload['text'] = strings.join('\n')
-				if add_mention? and defined?(target.user.id)
-					payload['text'] = payload['text'].prepend("<@#{target.user.id}> ")
-				end
-				return payload
-			end
+        @rtm_connection = RTMConnection.build(robot, config.token)
+        rtm_connection.run
+      end
 
-			def http_post(payload)
-				res = Faraday.post do |req|
-					log.debug "Slack::http_post sending payload to #{incoming_url}; length: #{payload.to_json.size}"
-					req.url incoming_url, :token => config.incoming_token
-					req.headers['Content-Type'] = 'application/json'
-					req.body = payload.to_json
-				end
-				log.info "Slack::http_post sent payload with response status #{res.status}"
-				log.debug "Slack::http_post response body: #{res.body}"
-				return res.status
-			end
+      def send_messages(target, strings)
+        return unless rtm_connection
 
-			#
-			# Accessor shortcuts
-			#
-			def config
-				Lita.config.adapter
-			end
+        rtm_connection.send_messages(channel_for(target), strings)
+      end
 
-			def log
-				Lita.logger
-			end
+      def shut_down
+        return unless rtm_connection
 
-      def incoming_url
-        config.incoming_url ||
-          "https://#{config.team_domain}.slack.com/services/hooks/incoming-webhook"
+        rtm_connection.shut_down
+        robot.trigger(:disconnected)
       end
 
-      def username
-        config.username
-      end
+      private
+
+      attr_reader :rtm_connection
 
-      def add_mention?
-        config.add_mention
+      def channel_for(target)
+        if target.room
+          target.room
+        else
+          rtm_connection.im_for(target.user.id)
+        end
       end
-		end
+    end
 
-		# Register Slack adapter to Lita
-		Lita.register_adapter(:slack, Slack)
-	end
+    # Register Slack adapter to Lita
+    Lita.register_adapter(:slack, Slack)
+  end
 end

data/lib/lita-slack.rb

@@ -1 +1,7 @@
+require "lita"
+
+Lita.load_locales Dir[File.expand_path(
+  File.join("..", "..", "locales", "*.yml"), __FILE__
+)]
+
 require "lita/adapters/slack"

data/lita-slack.gemspec

@@ -1,8 +1,8 @@
 Gem::Specification.new do |spec|
   spec.name          = "lita-slack"
-  spec.version       = "0.1.2"
-  spec.authors       = ["Ken J."]
-  spec.email         = ["kenjij@gmail.com"]
+  spec.version       = "1.0.0"
+  spec.authors       = ["Ken J.", "Jimmy Cuadra"]
+  spec.email         = ["kenjij@gmail.com", "jimmy@jimmycuadra.com"]
   spec.description   = %q{Lita adapter for Slack.}
   spec.summary       = %q{Lita adapter for Slack.}
   spec.homepage      = "https://github.com/kenjij/lita-slack"
@@ -14,10 +14,16 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "lita", ">= 2.7"
-  spec.add_runtime_dependency "lita-slack-handler", ">= 0.2.1"
+  spec.add_runtime_dependency "eventmachine"
+  spec.add_runtime_dependency "faraday"
+  spec.add_runtime_dependency "faye-websocket", ">= 0.8.0"
+  spec.add_runtime_dependency "lita", ">= 4.0.4"
+  spec.add_runtime_dependency "multi_json"
 
   spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rack-test"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", ">= 3.0.0"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "coveralls"
 end

data/locales/en.yml

@@ -0,0 +1,5 @@
+en:
+  lita:
+    adapters:
+      slack:
+