slack-ruby-client-bhe 0.5.4

data/lib/slack/real_time/api/message.rb

@@ -0,0 +1,20 @@
+module Slack
+  module RealTime
+    module Api
+      module Message
+        #
+        # Sends a message to a channel.
+        #
+        # @option options [channel] :channel
+        #   Channel to send message to. Can be a public channel, private group or IM channel. Can be an encoded ID, or a name.
+        # @option options [Object] :text
+        #   Text of the message to send. See below for an explanation of formatting.
+        def message(options = {})
+          throw ArgumentError.new('Required arguments :channel missing') if options[:channel].nil?
+          throw ArgumentError.new('Required arguments :text missing') if options[:text].nil?
+          send_json({ type: 'message', id: next_id }.merge(options))
+        end
+      end
+    end
+  end
+end

data/lib/slack/real_time/api/message_id.rb

@@ -0,0 +1,14 @@
+module Slack
+  module RealTime
+    module Api
+      module MessageId
+        private
+
+        def next_id
+          @next_id ||= 0
+          @next_id += 1
+        end
+      end
+    end
+  end
+end

data/lib/slack/real_time/api/ping.rb

@@ -0,0 +1,16 @@
+module Slack
+  module RealTime
+    module Api
+      module Ping
+        #
+        # Clients should try to quickly detect disconnections, even in idle periods, so that users can easily tell the
+        # difference between being disconnected and everyone being quiet. Not all web browsers support the WebSocket
+        # ping spec, so the RTM protocol also supports ping/pong messages.
+        #
+        def ping(options = {})
+          send_json({ type: 'ping', id: next_id }.merge(options))
+        end
+      end
+    end
+  end
+end

data/lib/slack/real_time/api/typing.rb

@@ -0,0 +1,17 @@
+module Slack
+  module RealTime
+    module Api
+      module Typing
+        #
+        # Send a typing indicator to indicate that the user is currently writing a message.
+        #
+        # @option options [channel] :channel
+        #   Channel to send message to. Can be a public channel, private group or IM channel. Can be an encoded ID, or a name.
+        def typing(options = {})
+          throw ArgumentError.new('Required arguments :channel missing') if options[:channel].nil?
+          send_json({ type: 'typing', id: next_id }.merge(options))
+        end
+      end
+    end
+  end
+end

data/lib/slack/real_time/client.rb

@@ -0,0 +1,152 @@
+module Slack
+  module RealTime
+    class Client
+      class ClientNotStartedError < StandardError; end
+      class ClientAlreadyStartedError < StandardError; end
+
+      include Api::MessageId
+      include Api::Ping
+      include Api::Message
+      include Api::Typing
+
+      attr_accessor :web_client
+      attr_accessor(*Config::ATTRIBUTES)
+
+      def initialize(options = {})
+        @callbacks = Hash.new { |h, k| h[k] = [] }
+        Slack::RealTime::Config::ATTRIBUTES.each do |key|
+          send("#{key}=", options[key] || Slack::RealTime.config.send(key))
+        end
+        @token ||= Slack.config.token
+        @web_client = Slack::Web::Client.new(token: token)
+      end
+
+      [:url, :team, :self, :users, :channels, :groups, :ims, :bots].each do |attr|
+        define_method attr do
+          @options[attr.to_s] if @options
+        end
+      end
+
+      def on(type, &block)
+        type = type.to_s
+        callbacks[type] << block
+      end
+
+      # Start RealTime client and block until it disconnects.
+      # @yieldparam [Websocket::Driver] driver
+      def start!(&block)
+        socket = build_socket
+        socket.start_sync { run_loop(socket, &block) }
+      end
+
+      # Start RealTime client and return immediately.
+      # The RealTime::Client will run in the background.
+      # @yieldparam [Websocket::Driver] driver
+      def start_async(&block)
+        socket = build_socket
+        socket.start_async { run_loop(socket, &block) }
+      end
+
+      def stop!
+        fail ClientNotStartedError unless started?
+        @socket.disconnect! if @socket
+      end
+
+      def started?
+        @socket && @socket.connected?
+      end
+
+      class << self
+        def configure
+          block_given? ? yield(config) : config
+        end
+
+        def config
+          Config
+        end
+      end
+
+      protected
+
+      # @return [Slack::RealTime::Socket]
+      def build_socket
+        fail ClientAlreadyStartedError if started?
+        @options = web_client.rtm_start
+
+        socket_class.new(@options.fetch('url'), socket_options)
+      end
+
+      def socket_options
+        socket_options = {}
+        socket_options[:ping] = websocket_ping if websocket_ping
+        socket_options[:proxy] = websocket_proxy if websocket_proxy
+        socket_options
+      end
+
+      def run_loop(socket)
+        @socket = socket
+
+        @socket.connect! do |driver|
+          yield driver if block_given?
+
+          driver.on :open do |event|
+            open(event)
+            callback(event, :open)
+          end
+
+          driver.on :message do |event|
+            dispatch(event)
+          end
+
+          driver.on :close do |event|
+            callback(event, :close)
+            close(event)
+          end
+        end
+      end
+
+      attr_reader :callbacks
+      def socket_class
+        concurrency::Socket
+      end
+
+      def send_json(data)
+        fail ClientNotStartedError unless started?
+        @socket.send_data(data.to_json)
+      end
+
+      def open(_event)
+      end
+
+      def close(_event)
+        socket = @socket
+        @socket = nil
+
+        [socket, socket_class].each do |s|
+          s.close if s.respond_to?(:close)
+        end
+      end
+
+      def callback(event, type)
+        callbacks = self.callbacks[type.to_s]
+        return false unless callbacks
+        callbacks.each do |c|
+          c.call(event)
+        end
+      end
+
+      def dispatch(event)
+        return false unless event.data
+        data = JSON.parse(event.data)
+        type = data['type']
+        return false unless type
+        callbacks = self.callbacks[type.to_s]
+        return false unless callbacks
+        callbacks.each do |c|
+          c.call(data)
+        end
+        true
+      end
+    end
+  end
+end

data/lib/slack/real_time/concurrency.rb

@@ -0,0 +1,8 @@
+module Slack
+  module RealTime
+    module Concurrency
+      autoload :Eventmachine, 'slack/real_time/concurrency/eventmachine'
+      autoload :Celluloid, 'slack/real_time/concurrency/celluloid'
+    end
+  end
+end

data/lib/slack/real_time/concurrency/celluloid.rb

@@ -0,0 +1,93 @@
+require 'websocket/driver'
+require 'socket'
+require 'forwardable'
+require 'celluloid/current'
+require 'celluloid/io'
+
+module Slack
+  module RealTime
+    module Concurrency
+      module Celluloid
+        class Socket < Slack::RealTime::Socket
+          include ::Celluloid::IO
+          include ::Celluloid::Internals::Logger
+
+          BLOCK_SIZE = 4096
+
+          extend ::Forwardable
+          def_delegator :socket, :write
+          def_delegators :driver, :text, :binary, :close
+
+          attr_reader :socket
+
+          def initialize(*args)
+            super
+            @driver = build_driver
+          end
+
+          # @yieldparam [WebSocket::Driver] driver
+          def connect!
+            super
+
+            driver.start
+            future.run_loop
+          end
+
+          def run_loop
+            loop { read } if socket
+          rescue EOFError
+            # connection closed
+          end
+
+          def read
+            buffer = socket.readpartial(BLOCK_SIZE)
+            driver.parse buffer
+          end
+
+          def start_async
+            future = yield self if block_given?
+
+            Actor.new(future)
+          end
+
+          def connected?
+            !@connected.nil?
+          end
+
+          protected
+
+          class Actor
+            attr_reader :future
+
+            def initialize(future)
+              @future = future
+            end
+
+            def join
+              @future.value
+            end
+          end
+
+          def build_socket
+            socket = TCPSocket.new(addr, port)
+            socket = SSLSocket.new(socket, build_ssl_context) if secure?
+            socket
+          end
+
+          def build_ssl_context
+            OpenSSL::SSL::SSLContext.new(:TLSv1_2_client)
+          end
+
+          def build_driver
+            ::WebSocket::Driver.client(self)
+          end
+
+          def connect
+            @socket = build_socket
+            @connected = @socket.connect
+          end
+        end
+      end
+    end
+  end
+end

data/lib/slack/real_time/concurrency/eventmachine.rb

@@ -0,0 +1,39 @@
+require 'faye/websocket'
+require 'eventmachine'
+
+module Slack
+  module RealTime
+    module Concurrency
+      module Eventmachine
+        class Socket < Slack::RealTime::Socket
+          def start_async
+            thread = ensure_reactor_running
+
+            yield self if block_given?
+
+            thread
+          end
+
+          def send_data(message)
+            driver.send(message)
+          end
+
+          protected
+
+          # @return [Thread]
+          def ensure_reactor_running
+            return if EventMachine.reactor_running?
+
+            reactor = Thread.new { EventMachine.run }
+            Thread.pass until EventMachine.reactor_running?
+            reactor
+          end
+
+          def connect
+            @driver = ::Faye::WebSocket::Client.new(url, nil, options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/slack/real_time/config.rb

@@ -0,0 +1,55 @@
+module Slack
+  module RealTime
+    module Config
+      class NoConcurrencyError < StandardError; end
+
+      extend self
+
+      ATTRIBUTES = [
+        :token,
+        :websocket_ping,
+        :websocket_proxy,
+        :concurrency
+      ]
+
+      attr_accessor(*Config::ATTRIBUTES)
+
+      def reset
+        self.websocket_ping = 30
+        self.websocket_proxy = nil
+        self.token = nil
+        self.concurrency = method(:detect_concurrency)
+      end
+
+      def concurrency
+        (val = @concurrency).respond_to?(:call) ? val.call : val
+      end
+
+      private
+
+      def detect_concurrency
+        [:Eventmachine, :Celluloid].each do |concurrency|
+          begin
+            return Slack::RealTime::Concurrency.const_get(concurrency)
+          rescue LoadError, NameError
+            false # could not be loaded, missing dependencies
+          end
+        end
+
+        fail NoConcurrencyError, 'Missing concurrency. Add faye-websocket or celluloid-io to your Gemfile.'
+      end
+    end
+
+    class << self
+      def configure
+        block_given? ? yield(Config) : Config
+      end
+
+      def config
+        Config
+      end
+    end
+  end
+end
+
+Slack::RealTime::Config.reset

data/lib/slack/real_time/socket.rb

@@ -0,0 +1,81 @@
+module Slack
+  module RealTime
+    class Socket
+      attr_accessor :url
+      attr_accessor :options
+      attr_reader :driver
+
+      def initialize(url, options = {})
+        @url = url
+        @options = options
+        @driver = nil
+      end
+
+      def send_data(message)
+        case message
+        when Numeric then driver.text(message.to_s)
+        when String  then driver.text(message)
+        when Array   then driver.binary(message)
+        else false
+        end
+      end
+
+      def connect!
+        return if connected?
+
+        connect
+
+        yield driver if block_given?
+      end
+
+      def disconnect!
+        driver.close
+      end
+
+      def connected?
+        !driver.nil?
+      end
+
+      def start_sync(&block)
+        thread = start_async(&block)
+        thread.join if thread
+      rescue Interrupt
+        thread.exit if thread
+      end
+
+      # @return [#join]
+      def start_async
+        fail NotImplementedError, "Expected #{self.class} to implement #{__method__}."
+      end
+
+      def close(_event)
+        @driver = nil
+      end
+
+      protected
+
+      def addr
+        URI(url).host
+      end
+
+      def secure?
+        port == URI::HTTPS::DEFAULT_PORT
+      end
+
+      def port
+        case (uri = URI(url)).scheme
+        when 'wss'.freeze, 'https'.freeze
+          URI::HTTPS::DEFAULT_PORT
+        when 'ws', 'http'.freeze
+          URI::HTTP::DEFAULT_PORT
+        else
+          uri.port
+        end
+      end
+
+      def connect
+        fail NotImplementedError, "Expected #{self.class} to implement #{__method__}."
+      end
+    end
+  end
+end