slack-ruby-client 2.6.0 → 3.0.0

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

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-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 = {})
-          raise ArgumentError, '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

@@ -1,271 +0,0 @@
-# frozen_string_literal: true
-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, :store, :url, *Config::ATTRIBUTES
-
-      protected :store_class, :store_class=, :store_options, :store_options=
-
-      def initialize(options = {})
-        @callbacks = Hash.new { |h, k| h[k] = [] }
-        Slack::RealTime::Config::ATTRIBUTES.each do |key|
-          send("#{key}=", options.key?(key) ? options[key] : Slack::RealTime.config.send(key))
-        end
-        @token ||= Slack.config.token
-        @logger ||= (Slack::Config.logger || Slack::Logger.default)
-        @web_client = Slack::Web::Client.new(token: token, logger: logger)
-      end
-
-      [:self, :team, *Stores::Base::CACHES].each do |store_method|
-        define_method store_method do
-          store&.send(store_method)
-        end
-      end
-
-      def on(type, &block)
-        type = type.to_s
-        callbacks[type] << block
-      end
-
-      # Start RealTime client and block until it disconnects.
-      def start!(&block)
-        @callback = block if block
-        build_socket
-        @socket.start_sync(self)
-      end
-
-      # Start RealTime client and return immediately.
-      # The RealTime::Client will run in the background.
-      def start_async(&block)
-        @callback = block if block
-        build_socket
-        @socket.start_async(self)
-      end
-
-      def stop!
-        raise ClientNotStartedError unless started?
-
-        @socket&.disconnect!
-      end
-
-      def started?
-        @socket&.connected?
-      end
-
-      class << self
-        def configure
-          block_given? ? yield(config) : config
-        end
-
-        def config
-          Config
-        end
-      end
-
-      def run_loop
-        @socket.connect! do |driver|
-          driver.on :open do |event|
-            logger.debug("#{self}##{__method__}") { event.class.name }
-            open_event(event)
-            callback(event, :open)
-          end
-
-          driver.on :message do |event|
-            logger.debug("#{self}##{__method__}") { "#{event.class}, #{event.data}" }
-            dispatch(event)
-          end
-
-          driver.on :close do |event|
-            logger.debug("#{self}##{__method__}") { event.class.name }
-            callback(event, :close)
-            close(event)
-            callback(event, :closed)
-          end
-
-          # This must be called last to ensure any events are registered before invoking user code.
-          @callback&.call(driver)
-        end
-      end
-
-      # Ensure the server is running, and ping the remote server if no other messages were sent.
-      def keep_alive?
-        # We can't ping the remote server if we aren't connected.
-        return false if @socket.nil? || !@socket.connected?
-
-        time_since_last_message = @socket.time_since_last_message
-
-        # If the server responded within the specified time, we are okay:
-        return true if time_since_last_message < websocket_ping
-
-        # If the server has not responded for a while:
-        return false if time_since_last_message > (websocket_ping * 2)
-
-        # Kick off the next ping message:
-        ping
-
-        true
-      end
-
-      # Check if the remote server is responsive, and if not, restart the connection.
-      def run_ping!
-        return if keep_alive?
-
-        logger.warn(to_s) { 'is offline' }
-
-        restart_async
-      rescue Slack::Web::Api::Errors::SlackError => e
-        # stop pinging if bot was uninstalled
-        case e.message
-        when 'account_inactive', 'invalid_auth'
-          logger.warn(to_s) { e.message }
-          raise e
-        end
-        logger.debug("#{self}##{__method__}") { e }
-      rescue StandardError => e
-        # disregard all ping worker failures, keep pinging
-        logger.debug("#{self}##{__method__}") { e }
-      end
-
-      def run_ping?
-        !websocket_ping.nil? && websocket_ping.positive?
-      end
-
-      def websocket_ping_timer
-        websocket_ping / 2
-      end
-
-      def to_s
-        if store&.team
-          "id=#{store.team.id}, name=#{store.team.name}, domain=#{store.team.domain}"
-        else
-          super
-        end
-      end
-
-      protected
-
-      def restart_async
-        logger.debug("#{self}##{__method__}")
-        @socket.close
-        start = web_client.rtm_connect(start_options)
-        data = Slack::Messages::Message.new(start)
-        @url = data.url
-        @store = store_class.new(data, store_options.to_h) if store_class
-        @socket.restart_async(self, @url)
-      end
-
-      # @return [Slack::RealTime::Socket]
-      def build_socket
-        raise ClientAlreadyStartedError if started?
-
-        start = web_client.rtm_connect(start_options)
-        data = Slack::Messages::Message.new(start)
-        @url = data.url
-        @store = store_class.new(data, store_options.to_h) if store_class
-        @socket = socket_class.new(@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[:logger] = logger
-        socket_options
-      end
-
-      attr_reader :callbacks
-
-      def socket_class
-        concurrency::Socket
-      end
-
-      def send_json(data)
-        raise ClientNotStartedError unless started?
-
-        logger.debug("#{self}##{__method__}") { data }
-        @socket.send_data(data.to_json)
-      end
-
-      def open_event(_event); end
-
-      def close(_event)
-        [@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
-        true
-      rescue StandardError => e
-        logger.error("#{self}##{__method__}") { e }
-        false
-      end
-
-      def dispatch(event)
-        return false unless event.data
-
-        data = Slack::Messages::Message.new(JSON.parse(event.data))
-        type = data.type
-        return false unless type
-
-        type = type.to_s
-        logger.debug("#{self}##{__method__}") { data.to_s }
-        run_handlers(type, data) if @store
-        run_callbacks(type, data)
-      rescue StandardError => e
-        logger.error("#{self}##{__method__}") { e }
-        false
-      end
-
-      def run_handlers(type, data)
-        handlers = store.class.events[type.to_s]
-        case async_handlers
-        when :all
-          @socket.run_async { handlers_loop(handlers, data) }
-        when :none
-          handlers_loop(handlers, data)
-        else
-          raise Config::InvalidAsyncHandlersError,
-                "Invalid value '#{async_handlers.inspect}' for config#async_handlers, must be :all or :none."
-        end
-      rescue StandardError => e
-        logger.error("#{self}##{__method__}") { e }
-        false
-      end
-
-      def handlers_loop(handlers, data)
-        handlers.each do |handler|
-          store.instance_exec(data, self, &handler)
-        end
-      end
-
-      def run_callbacks(type, data)
-        callbacks = self.callbacks[type]
-        return false unless callbacks
-
-        callbacks.each do |c|
-          c.call(data)
-        end
-        true
-      rescue StandardError => e
-        logger.error("#{self}##{__method__}") { e }
-        false
-      end
-    end
-  end
-end

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

@@ -1,142 +0,0 @@
-# frozen_string_literal: true
-require 'async/websocket'
-require 'async/notification'
-require 'async/clock'
-
-module Slack
-  module RealTime
-    module Concurrency
-      module Async
-        class Client < ::Async::WebSocket::Client
-          extend ::Forwardable
-          def_delegators :@driver, :on, :text, :binary, :emit
-        end
-
-        class Socket < Slack::RealTime::Socket
-          attr_reader :client
-
-          def start_sync(client)
-            start_reactor(client).wait
-          end
-
-          def start_async(client)
-            Thread.new do
-              start_reactor(client)
-            end
-          end
-
-          def start_reactor(client)
-            Async do |task|
-              @restart = ::Async::Notification.new
-
-              if client.run_ping?
-                @ping_task = task.async do |subtask|
-                  subtask.annotate "#{client} keep-alive"
-
-                  # The timer task will naturally exit after the driver is set to nil.
-                  while @restart
-                    subtask.sleep client.websocket_ping_timer
-                    client.run_ping! if @restart
-                  end
-                end
-              end
-
-              while @restart
-                @client_task&.stop
-
-                @client_task = task.async do |subtask|
-                  subtask.annotate "#{client} run-loop"
-                  client.run_loop
-                rescue ::Async::Wrapper::Cancelled => e
-                # Will get restarted by ping worker.
-                rescue StandardError => e
-                  client.logger.error(subtask.to_s) { e.message }
-                end
-
-                @restart.wait
-              end
-
-              @ping_task&.stop
-            end
-          end
-
-          def restart_async(_client, new_url)
-            @url = new_url
-            @last_message_at = current_time
-
-            @restart&.signal
-          end
-
-          def run_async(&block)
-            ::Async.run(&block)
-          end
-
-          def current_time
-            ::Async::Clock.now
-          end
-
-          def connect!
-            super
-            run_loop
-          end
-
-          # Kill the restart/ping loop.
-          def disconnect!
-            super
-          ensure
-            if (restart = @restart)
-              @restart = nil
-              restart.signal
-            end
-          end
-
-          # Close the socket.
-          def close
-            super
-          ensure
-            if @socket
-              @socket.close
-              @socket = nil
-            end
-          end
-
-          def run_loop
-            while @driver&.next_event
-              # $stderr.puts event.inspect
-            end
-          end
-
-          protected
-
-          def build_ssl_context
-            OpenSSL::SSL::SSLContext.new(:TLSv1_2_client).tap do |ctx|
-              ctx.set_params(verify_mode: OpenSSL::SSL::VERIFY_PEER)
-            end
-          end
-
-          def build_endpoint
-            endpoint = ::Async::IO::Endpoint.tcp(addr, port)
-            endpoint = ::Async::IO::SSLEndpoint.new(endpoint, ssl_context: build_ssl_context) if secure?
-            endpoint
-          end
-
-          def connect_socket
-            build_endpoint.connect
-          end
-
-          def connect
-            @socket = connect_socket
-            @driver = Client.new(@socket, url)
-          end
-        end
-      end
-    end
-  end
-end
-
-if Gem::Version.new(Async::WebSocket::VERSION) >= Gem::Version.new('0.9.0')
-  raise(
-    "Incompatible version of async-websocket, #{Async::WebSocket::VERSION}, " \
-    "use \"gem 'async-websocket', '~> 0.8.0'\"."
-  )
-end

data/lib/slack/real_time/concurrency.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-module Slack
-  module RealTime
-    module Concurrency
-      autoload :Async, 'slack/real_time/concurrency/async'
-    end
-  end
-end

data/lib/slack/real_time/config.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-module Slack
-  module RealTime
-    module Config
-      class NoConcurrencyError < StandardError; end
-      class InvalidAsyncHandlersError < StandardError; end
-
-      extend self
-
-      ATTRIBUTES = %i[
-        token
-        websocket_ping
-        websocket_proxy
-        concurrency
-        start_options
-        store_class
-        store_options
-        logger
-        async_handlers
-      ].freeze
-
-      attr_accessor(*Config::ATTRIBUTES - [:concurrency])
-      attr_writer :concurrency
-
-      def reset
-        self.websocket_ping = 30
-        self.websocket_proxy = nil
-        self.token = nil
-        self.concurrency = method(:detect_concurrency)
-        self.start_options = { request: { timeout: 180 } }
-        self.store_class = Slack::RealTime::Stores::Starter
-        self.store_options = {}
-        self.logger = nil
-        self.async_handlers = :none
-      end
-
-      def concurrency
-        (val = @concurrency).respond_to?(:call) ? val.call : val
-      end
-
-      private
-
-      def detect_concurrency
-        Slack::RealTime::Concurrency.const_get(:Async)
-      rescue LoadError, NameError
-        raise NoConcurrencyError, 'Missing concurrency. Add async-websocket 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/models/base.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-module Slack
-  module RealTime
-    module Models
-      class Base < Hashie::Mash
-        # see https://github.com/intridea/hashie/issues/394
-        def log_built_in_message(*); end
-      end
-    end
-  end
-end

data/lib/slack/real_time/models/bot.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-module Slack
-  module RealTime
-    module Models
-      class Bot < Base
-      end
-    end
-  end
-end

data/lib/slack/real_time/models/channel.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Slack
-  module RealTime
-    module Models
-      class Channel < Base
-        def is_public? # rubocop:disable Naming/PredicateName
-          !is_private?
-        end
-      end
-    end
-  end
-end

data/lib/slack/real_time/models/im.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-module Slack
-  module RealTime
-    module Models
-      class Im < Base
-      end
-    end
-  end
-end

data/lib/slack/real_time/models/mpim.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-module Slack
-  module RealTime
-    module Models
-      class Mpim < Base
-      end
-    end
-  end
-end

data/lib/slack/real_time/models/team.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-module Slack
-  module RealTime
-    module Models
-      class Team < Base
-      end
-    end
-  end
-end

data/lib/slack/real_time/models/user.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-module Slack
-  module RealTime
-    module Models
-      class User < Base
-      end
-    end
-  end
-end

data/lib/slack/real_time/models.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'models/base'
-require_relative 'models/user'
-require_relative 'models/bot'
-require_relative 'models/channel'
-require_relative 'models/team'
-require_relative 'models/im'
-require_relative 'models/mpim'