vox 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2849016a778799a4bf2b6b575410b2c8b1283676f017bbdccd6f4e8ae152e587
-  data.tar.gz: 38b16cc95ed5eb7a72bbc878db3f5c52a1db13f658562ba7a596f86dc4070a22
+  metadata.gz: ff24b453b9f1e77745b7cf69fc4e37b2c8b41ea878fd25bb4d90a1ddff53cb84
+  data.tar.gz: 7eb6a27c3b74b29659689cee45eec1b5754262893103b6e4e1feac27899128f2
 SHA512:
-  metadata.gz: 1197ad4ce07851d592a3a723798bf660965e0dfd8857ec90d90267e5f1d6e7702be543b2c37cdea240f9f3016d7869e4d02b38cb96b7c8ca9e71f6205170bb95
-  data.tar.gz: 83750ec950b0bcfca2e4ca91d74d12a8232230e53ec943c8fbab839fcd76c0525f684f1bd2e206d360c8e354c2bb04e5e180adadb5323992dad5a7c27adcbc4e
+  metadata.gz: 49c6cd9c4c7b512a9937b918facf227131ee5bf473bc8b69b5098314abd42796eaa16a2502d8e0255dfecc85c0a362e479d3c8642c1edac1910ab0a0bcf834b8
+  data.tar.gz: 2b1c08120d3599f5985d99c0efb0d35658ebd23ca163a07ad33e15e7a9165e9ab842bcd4f704c4a82823af97db0f28ad471c2a6ce77a038eaa58a4f61f0ec976

data/CHANGELOG.md

@@ -4,7 +4,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [0.2.2] - 2020-9-13
+### Added
+- Vox.setup_default_logger
+- Gateway component
+- Gateway routes (get_gateway, get_gateway_bot)
 
 ## [0.2.1] - 2020-8-29
 ### Added

data/Rakefile

@@ -3,6 +3,8 @@
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 require 'rubocop/rake_task'
+require 'yard'
+require 'yard/rake/yardoc_task'
 
 RSpec::Core::RakeTask.new(:spec) do |t|
   t.rspec_opts = '--format progress'
@@ -11,4 +13,9 @@ end
 
 RuboCop::RakeTask.new(:rubocop)
 
+YARD::Rake::YardocTask.new(:yard)
+
+# Run all tests
+task test: %i[rubocop yard spec]
+
 task default: :spec

data/examples/gateway_example.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'vox/http/client'
+require 'vox/gateway/client'
+
+Vox.setup_default_logger
+
+token = ENV['VOX_TOKEN']
+rest = Vox::HTTP::Client.new(token)
+gateway = Vox::Gateway::Client.new(url: rest.get_gateway[:url], token: token)
+
+gateway.on(:MESSAGE_CREATE) do |data|
+  rest.create_message(data[:channel_id], content: 'pong') if data[:content] == 'vox.ping'
+end
+
+Signal.trap('INT') { gateway.close('Disconnecting') }
+
+gateway.connect

data/lib/vox.rb

@@ -4,6 +4,33 @@ require 'vox/version'
 
 # Parent module containing all component pieces
 module Vox
+  # Setup default appenders, log level, and formatting scheme.
+  # @param root_level [Symbol] The default logging level for all `Vox` loggers.
+  # @param rules [Hash<Class, Symbol>] Custom levels for each desired class.
+  # @example
+  #   Vox.setup_default_logger(root_level: :warn, Vox::HTTP: :info, Vox::Gateway: :info)
+  def self.setup_default_logger(root_level: :info, **rules)
+    Logging.logger[Vox].level = root_level
+
+    rules.each do |log, level|
+      Logging.logger[log].level = level
+    end
+
+    Logging.color_scheme('vox_default',
+                         levels: {
+                           debug: :magenta,
+                           info: :green,
+                           warn: :yellow,
+                           error: :red,
+                           fatal: %i[white on_red]
+                         },
+                         date: :blue,
+                         logger: :cyan)
+
+    Logging.logger[Vox].add_appenders(
+      Logging.appenders.stdout(layout: Logging.layouts.pattern(color_scheme: 'vox_default'))
+    )
+  end
   # Catch all error for all Vox error subclasses
   class Error < StandardError; end
   # Your code goes here...

data/lib/vox/gateway/client.rb

@@ -0,0 +1,376 @@
+# frozen_string_literal: true
+
+require 'vox/gateway/websocket'
+require 'logging'
+
+module Vox
+  module Gateway
+    # A client for receiving and writing data from the gateway.
+    # The client uses an emitter pattern for emitting and registering events.
+    # @example
+    #   client.on(:MESSAGE_CREATE) do |payload|
+    #     puts "Hello!" if payload[:content] == "hello"
+    #   end
+    class Client
+      include EventEmitter
+
+      # @!visibility private
+      # The default properties for the identify packet
+      DEFAULT_PROPERTIES = {
+        '$os': Gem::Platform.local.os,
+        '$browser': 'vox',
+        '$device': 'vox'
+      }.freeze
+
+      # @!visibility private
+      # A hash of opcodes => op_names, as well as op_names => opcodes.
+      OPCODES = {
+        0 => :DISPATCH,
+        1 => :HEARTBEAT,
+        2 => :IDENTIFY,
+        3 => :PRESENCE_UPDATE,
+        4 => :VOICE_STATE_UPDATE,
+        5 => :UNKNOWN,
+        6 => :RESUME,
+        7 => :RECONNECT,
+        8 => :REQUEST_GUILD_MEMBERS,
+        9 => :INVALID_SESSION,
+        10 => :HELLO,
+        11 => :HEARTBEAT_ACK
+      }.tap { |ops| ops.merge!(ops.invert) }.freeze
+
+      # The gateway version to request.
+      GATEWAY_VERSION = '8'
+
+      # Class that holds information about a session.
+      Session = Struct.new(:id, :seq)
+
+      # @return [Session] The connection's session information.
+      attr_reader :session
+
+      # @param url [String] The url to use when connecting to the websocket. This can be
+      #   retrieved from the API with {HTTP::Routes::Gateway#get_gateway_bot}.
+      # @param token [String] The token to use for authorization.
+      # @param port [Integer] The port to use when connecting. If `nil`, it will be inferred
+      #   from the URL scheme (80 for `ws`, and 443 for `wss`).
+      # @param encoding [:json] This only accepts `json` currently, but may support `:etf` in future versions.
+      # @param compress [true, false] Whether to use `zlib-stream` compression.
+      # @param shard [Array<Integer>] An array in the format `[ShardNumber, TotalShards]`.
+      # @param large_threshold [Integer]
+      # @param presence [Object]
+      # @param intents [Integer]
+      def initialize(url:, token:, port: nil, encoding: :json, compress: true, shard: [0, 1],
+                     properties: DEFAULT_PROPERTIES, large_threshold: nil, presence: nil, intents: nil)
+        uri = create_gateway_uri(url, port: port, encoding: encoding, compress: compress)
+
+        @encoding = encoding
+        raise ArgumentError, 'Invalid gateway encoding' unless %i[json etf].include? @encoding
+
+        if @encoding == :etf
+          begin
+            require 'vox/etf'
+          rescue LoadError
+            Logging.logger[self].error { 'ETF parsing lib not found. Please install vox-etf to use ETF encoding.' }
+            raise Vox::Error.new('ETF lib not found')
+          end
+        end
+
+        @websocket = WebSocket.new(uri.to_s, port: uri.port, compression: compress)
+        @identify_opts = {
+          token: token, properties: properties, shard: shard,
+          large_threshold: large_threshold, presence: presence, intents: intents
+        }.compact
+        @session = Session.new
+        @should_reconnect = Queue.new
+        setup_handlers
+      end
+
+      # @!method on(event, &block)
+      #   Register an event handler for a GATEWAY event, or DISPATCH event.
+      #   When registering an event corresponding to an opcode, the full payload
+      #   is yielded. When registering a DISPATCH type, only the data portion
+      #   of the payload is provided.
+
+      # Connect the websocket to the gateway.
+      def connect(async: false)
+        @ws_thread = Thread.new do
+          loop do
+            @websocket.connect
+            @websocket.thread.join
+            break unless @should_reconnect.shift
+          end
+        end
+        async ? @ws_thread : @ws_thread.join
+      end
+
+      # Close the websocket.
+      # @param code [Integer] The close code.
+      # @param reason [String] The reason for closing.
+      def close(reason = nil, code = 1000, reconnect: false)
+        @ws_thread.kill unless reconnect
+        @websocket.close(reason, code)
+        @websocket.thread.join unless reconnect
+      end
+
+      # Send a packet with the correct encoding. Only supports JSON currently.
+      # @param op_code [Integer]
+      # @param data [Hash]
+      def send_packet(op_code, data)
+        LOGGER.debug { "Sending #{op_code.is_a?(Symbol) ? op_code : OPCODES[op_code]} #{data || 'nil'}" }
+        if @encoding == :etf
+          send_etf_packet(op_code, data)
+        else
+          send_json_packet(op_code, data)
+        end
+      end
+
+      # Request a guild member chunk, used to build a member cache.
+      # @param guild_id [String, Integer]
+      # @param query
+      # @param limit [Integer]
+      # @param presences
+      # @param user_ids [Array<String, Integer>]
+      # @param nonce [String, Integer]
+      def request_guild_members(guild_id, query: nil, limit: 0, presences: nil,
+                                user_ids: nil, nonce: nil)
+        opts = {
+          guild_id: guild_id, query: query, limit: limit, presences: presences,
+          user_ids: user_ids, nonce: nonce
+        }.compact
+
+        send_packet(OPCODES[:REQUEST_GUILD_MEMBERS], opts)
+      end
+
+      # Send a voice state update, used for establishing voice connections.
+      # @param guild_id [String, Integer]
+      # @param channel_id [String, Integer]
+      # @param self_mute [true, false]
+      # @param self_deaf [true, false]
+      def voice_state_update(guild_id, channel_id, self_mute: false, self_deaf: false)
+        opts = {
+          guild_id: guild_id, channel_id: channel_id, self_mute: self_mute,
+          self_deaf: self_deaf
+        }.compact
+
+        send_packet(OPCODES[:VOICE_STATE_UPDATE], opts)
+      end
+
+      # Update the bot's status.
+      # @param status [String] The user's new status.
+      # @param afk [true, false] Whether or not the client is AFK.
+      # @param game [Hash<Symbol, Object>, nil] An [activity object](https://discord.com/developers/docs/topics/gateway#activity-object).
+      # @param since [Integer, nil] Unix time (in milliseconds) of when the client went idle.
+      def presence_update(status:, afk: false, game: nil, since: nil)
+        opts = { status: status, afk: afk, game: game, since: since }.compact
+        send_packet(OPCODES[:PRESENCE_UPDATE], opts)
+      end
+
+      private
+
+      # Add internal event handlers
+      def setup_handlers
+        # Discord will contact us with HELLO first, so we don't need to hook into READY
+        @websocket.on(:message, &method(:handle_message))
+        @websocket.on(:close, &method(:handle_close))
+
+        # Setup payload handlers
+        on(:DISPATCH, &method(:handle_dispatch))
+        on(:HEARTBEAT, &method(:handle_heartbeat))
+        on(:RECONNECT, &method(:handle_reconnect))
+        on(:INVALID_SESSION, &method(:handle_invalid_session))
+        on(:HELLO, &method(:handle_hello))
+        on(:HEARTBEAT_ACK, &method(:handle_heartbeat_ack))
+        on(:READY, &method(:handle_ready))
+      end
+
+      # Create a URI from a gateway url and options
+      # @param url [String]
+      # @param port [Integer]
+      # @param encoding [:json]
+      # @param compress [true, false]
+      # @return [URI::Generic]
+      def create_gateway_uri(url, port: nil, encoding: :json, compress: true)
+        compression = compress ? 'zlib-stream' : nil
+        query = URI.encode_www_form(
+          version: GATEWAY_VERSION, encoding: encoding, compress: compression
+        )
+        URI(url).tap do |u|
+          u.query = query
+          u.port = port
+        end
+      end
+
+      # Send a JSON packet.
+      # @param op_code [Integer]
+      # @param data [Hash]
+      def send_json_packet(op_code, data)
+        payload = { op: op_code, d: data }
+
+        @websocket.send_json(payload)
+      end
+
+      # Send an ETF packet.
+      # @param op_code [Integer]
+      # @param data [Hash]
+      def send_etf_packet(op_code, data)
+        payload = { op: op_code, d: data }
+        @websocket.send_binary(Vox::ETF.encode(payload))
+      end
+
+      # Send an identify payload to discord, beginning a new session.
+      def send_identify
+        send_packet(OPCODES[:IDENTIFY], @identify_opts)
+      end
+
+      # Send a resume payload to discord, attempting to resume an existing
+      # session.
+      def send_resume
+        send_packet(OPCODES[:RESUME],
+                    { token: @identify_opts[:token], session_id: @session.id, seq: @session.seq })
+      end
+
+      # Send a heartbeat.
+      def send_heartbeat
+        @heartbeat_acked = false
+        send_packet(OPCODES[:HEARTBEAT], @session.seq)
+      end
+
+      # A loop that handles sending and receiving heartbeats from the gateway.
+      def heartbeat_loop
+        loop do
+          send_heartbeat
+          sleep @heartbeat_interval
+          next if @heartbeat_acked
+
+          LOGGER.error { 'Heartbeat was not acked, reconnecting.' }
+          @websocket.close
+          break
+        end
+      end
+
+      ##################################
+      ##################################
+      ##################################
+      ##################################
+      ####                          ####
+      #### Internal event handlers  ####
+      ####                          ####
+      ##################################
+      ##################################
+      ##################################
+      ##################################
+
+      # Handle a message from the websocket.
+      # @param data [String] The message data.
+      def handle_message(data)
+        if @encoding == :etf
+          handle_etf_message(data)
+        else
+          handle_json_message(data)
+        end
+      end
+
+      # Handle an ETF message, decoding it and emitting an event.
+      # @param data [String] The ETF data.
+      def handle_etf_message(data)
+        data = Vox::ETF.decode(data)
+        LOGGER.debug { "Emitting #{OPCODES[data[:op]]}" } if OPCODES[data[:op]] != :DISPATCH
+
+        @session.seq = data[:s] if data[:s]
+        op = OPCODES[data[:op]]
+
+        emit(op, data)
+      end
+
+      # Handle a JSON message, decoding it and emitting an event.
+      # @param json [String] The JSON data.
+      def handle_json_message(json)
+        data = MultiJson.load(json, symbolize_keys: true)
+        # Don't announce DISPATCH events since we log it on the same level
+        # in the dispatch handler.
+        LOGGER.debug { "Emitting #{OPCODES[data[:op]]}" } if OPCODES[data[:op]] != :DISPATCH
+
+        @session.seq = data[:s] if data[:s]
+        op = OPCODES[data[:op]]
+
+        emit(op, data)
+      end
+
+      # Handle a dispatch event, extracting the event name and emitting an event.
+      # @param payload [Hash<Symbol, Object>] The decoded payload's `data` field.
+      def handle_dispatch(payload)
+        LOGGER.debug { "Emitting #{payload[:t]}" }
+        emit(payload[:t], payload[:d])
+      end
+
+      # Handle a hello event, beginning the heartbeat loop and identifying or
+      # resuming.
+      # @param payload [Hash<Symbol, Object>] The decoded payload.
+      def handle_hello(payload)
+        LOGGER.info { 'Connected' }
+        @heartbeat_interval = payload[:d][:heartbeat_interval] / 1000
+        @heartbeat_thread = Thread.new { heartbeat_loop }
+        if @session.seq
+          send_resume
+        else
+          send_identify
+        end
+      end
+
+      # Fired if the gateway requests that we send a heartbeat.
+      # @param _payload [Object] The received payload, not used in this method.
+      def handle_heartbeat(_payload)
+        send_packet(OPCODES[:HEARTBEAT], @session.seq)
+      end
+
+      # Set session information from the ready payload.
+      # @param payload [Object] The received ready payload.
+      def handle_ready(payload)
+        @session.id = payload[:session_id]
+      end
+
+      # @param _payload [Object] The received payload, not used in this method.
+      def handle_invalid_session(_payload)
+        @session.seq = nil
+        send_identify
+      end
+
+      # @param _payload [Object] The received payload, not used in this method.
+      def handle_reconnect(_payload)
+        @websocket.close('Received reconnect', 4000)
+      end
+
+      # Handle a heartbeat acknowledgement from the gateway.
+      # @param _payload [Object] The received payload, not used in this method.
+      def handle_heartbeat_ack(_payload)
+        @heartbeat_acked = true
+      end
+
+      # Handle a close event from the websocket.
+      # @param data [Hash{:code => Integer, :reason => String}]
+      def handle_close(data)
+        LOGGER.warn { "Websocket closed (#{data[:code]} #{data[:reason]})" }
+        @heartbeat_thread&.kill
+        reconnect = true
+
+        case data[:code]
+        # Invalid seq when resuming, or session timed out
+        when 4007, 4009
+          LOGGER.error { 'Invalid session, reconnecting.' }
+          @session = Session.new
+        when 4003, 4004, 4011
+          LOGGER.fatal { data[:reason] }
+          reconnect = false
+        else
+          LOGGER.error { data[:reason] } if data[:reason]
+        end
+
+        @should_reconnect << reconnect
+      end
+
+      # @!visibility private
+      # The logger for Vox::Gateway::Client
+      LOGGER = Logging.logger[self]
+    end
+  end
+end

data/lib/vox/gateway/websocket.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require 'event_emitter'
+require 'logging'
+require 'multi_json'
+require 'websocket/driver'
+require 'socket'
+require 'openssl'
+require 'uri'
+require 'zlib'
+
+module Vox
+  # Module containing the gateway component.
+  module Gateway
+    # Websocket that handles data interchange for {Vox::Gateway::Client}.
+    class WebSocket
+      include EventEmitter
+
+      # Zlib boundary used for separating messages split into multiple frames.
+      ZLIB_SUFFIX = "\x00\x00\xFF\xFF".b.freeze
+
+      attr_reader :url, :thread, :driver
+
+      def initialize(url, port: nil, compression: true)
+        @url = url
+        @uri = URI.parse(url)
+        @port = port || @uri.scheme == 'wss' ? 443 : 80
+        @inflate = Zlib::Inflate.new if compression
+      end
+
+      # @!method on(key, data)
+      #   @overload on('open', &block)
+      #     Emitted when the websocket finishes its connecting process.
+      #   @overload on('message', &block)
+      #     Emitted when a message is parsed from the websocket.
+      #     @yieldparam [String] data The received message.
+      #   @overload on('close', &block)
+      #     Emitted when the websocket connection closes.
+      #     @yieldparam [Integer] code The given close code.
+      #     @yieldparam [String, nil] reason The reason the websocket was closed.
+
+      # Connect to the websocket server.
+      # @return [Thread] The thread handling the read loop.
+      def connect
+        # Flush the zlib buffer
+        @inflate&.reset
+
+        # Create a socket connection to the URL
+        @socket = create_socket
+
+        # Initialize the websocket driver
+        setup_driver
+
+        # Read until our websocket closes.
+        @thread = Thread.new do
+          read_loop
+        end
+      end
+
+      # Send a `text` message.
+      # @param message [String] The `text` message to write to the websocket.
+      # @return [true, false] Whether the message was sent successfully.
+      def send(message)
+        LOGGER.debug { "[OUT] #{message} " }
+        @driver.text(message)
+      end
+
+      # Serialize a hash to send as a `text` message.
+      # @param hash [Hash] The hash to serialize and send as a `text` message.
+      # @return [true, false] Whether the message was sent successfully.
+      def send_json(hash)
+        data = MultiJson.dump(hash)
+        send(data)
+      end
+
+      # Send a `binary` frame.
+      # @param data [String] The binary data to write to the websocket.
+      # @return [true, false] Whether the data was send successfully.
+      def send_binary(data)
+        @driver.binary(data)
+      end
+
+      # @!visibility private
+      # @param data [String] The data to write to the socket.
+      def write(data)
+        @socket.write(data)
+      end
+
+      # @!visibility private
+      # @return [nil]
+      def read
+        @driver.parse(@socket.readpartial(4096))
+      end
+
+      # Close the websocket connection.
+      # @param reason [String] The reason for closing the websocket.
+      # @param code [Integer] The code to close the websocket with.
+      # @return [true, false] Whether the websocket closed successfully.
+      def close(reason = nil, code = 1000)
+        @driver.close(reason, code)
+      end
+
+      private
+
+      # Read from the socket until the websocket driver
+      # reports as closed.
+      def read_loop
+        read until @driver.state == :closed
+      rescue SystemCallError => e
+        LOGGER.error { "(#{e.class.name.split('::').last}) #{e.message}" }
+      rescue EOFError => e
+        LOGGER.error { 'EOF in websocket loop' }
+      end
+
+      def setup_driver
+        @driver = ::WebSocket::Driver.client(self)
+        register_handlers
+        @driver.start
+      end
+
+      # Create a socket, create an SSL socket instead for
+      # wss.
+      # @return [TCPSocket, SSLSocket]
+      def create_socket
+        if @uri.scheme == 'wss'
+          create_ssl_socket.tap(&:connect)
+        else
+          TCPSocket.new(@uri.host, @port)
+        end
+      end
+
+      # Create an SSL socket for WSS.
+      def create_ssl_socket
+        ctx = OpenSSL::SSL::SSLContext.new
+        ctx.set_params ssl_version: :TLSv1_2
+
+        socket = TCPSocket.new(@uri.host, @port)
+        OpenSSL::SSL::SSLSocket.new(socket, ctx)
+      end
+
+      # Register the base handlers.
+      def register_handlers
+        @driver.on(:open, &method(:on_open))
+        @driver.on(:message, &method(:on_message))
+        @driver.on(:close, &method(:on_close))
+      end
+
+      # Handle open events.
+      def on_open(_event)
+        LOGGER.debug { 'Connection open' }
+        emit(:open)
+      end
+
+      # Handle parsed message events.
+      def on_message(event)
+        data = if @inflate
+                 packed = event.data.pack('c*')
+                 @inflate << packed
+                 return unless packed.end_with?(ZLIB_SUFFIX)
+
+                 @inflate.inflate('')
+               else
+                 event.data
+               end
+
+        LOGGER.debug { "[IN] #{data[0].ord == 131 ? data.inspect : data}" }
+        emit(:message, data)
+      end
+
+      # Handle close events.
+      def on_close(event)
+        LOGGER.debug { "WebSocket is closing (#{event.code}) #{event.reason}" }
+        emit(:close, { code: event.code, reason: event.reason })
+      end
+
+      # The logger used for output.
+      LOGGER = Logging.logger[self]
+    end
+  end
+end

data/lib/vox/http/client.rb

@@ -3,14 +3,7 @@
 require 'faraday'
 require 'logging'
 require 'securerandom'
-# require 'vox/http/routes/audit_log'
-# require 'vox/http/routes/channel'
-# require 'vox/http/routes/emoji'
-# require 'vox/http/routes/guild'
-# require 'vox/http/routes/invite'
-# require 'vox/http/routes/user'
-# require 'vox/http/routes/voice'
-# require 'vox/http/routes/webhook'
+require 'vox'
 require 'vox/http/route'
 require 'vox/http/routes'
 require 'vox/http/error'

data/lib/vox/http/routes.rb

@@ -4,6 +4,7 @@ require 'vox/http/routes/audit_log'
 require 'vox/http/routes/channel'
 require 'vox/http/routes/emoji'
 require 'vox/http/routes/guild'
+require 'vox/http/routes/gateway'
 require 'vox/http/routes/invite'
 require 'vox/http/routes/user'
 require 'vox/http/routes/voice'
@@ -15,7 +16,7 @@ module Vox
     module Routes
       # Include all route containers if this module is included
       def self.included(klass)
-        [AuditLog, Channel, Emoji, Guild, Invite, User, Voice, Webhook].each { |m| klass.include m }
+        constants.each { |m| klass.include const_get(m) }
       end
     end
   end

data/lib/vox/http/routes/gateway.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'vox/http/route'
+
+module Vox
+  module HTTP
+    module Routes
+      # Mixin for gateway routes, used for retriving information
+      # about connecting to the gateway.
+      module Gateway
+        # rubocop:disable Naming/AccessorMethodName
+
+        # Fetch the URL to use for a gateway connection.
+        # @return [Hash<:url, String>] An object with one key `url` that maps to the URL
+        #   for connecting to the gateway.
+        # @vox.api_docs https://discord.com/developers/docs/topics/gateway#get-gateway
+        def get_gateway
+          request(Route.new(:GET, '/gateway'))
+        end
+
+        # Fetch the URL to use for a gateway connection, with additional sharding information.
+        # @return [Hash{ :url => String, :shards => Integer, :session_start_limit => Hash<Symbol, Integer>}]
+        #   An object that includes the URL to connect to the gateway with, the recommended number of shards,
+        #   as well as a [session start limit](https://discord.com/developers/docs/topics/gateway#session-start-limit-object-session-start-limit-structure)
+        #   object.
+        # @vox.api_docs https://discord.com/developers/docs/topics/gateway#get-gateway-bot
+        def get_gateway_bot
+          request(Route.new(:GET, '/gateway/bot'))
+        end
+
+        # rubocop:enable Naming/AccessorMethodName
+      end
+    end
+  end
+end

data/lib/vox/http/util.rb

@@ -8,11 +8,9 @@ module Vox
     module Util
       # Remove members from a hash that have `:undef` as values
       # @example
-      #   ```ruby
       #   hash = { foo: 1, bar: :undef, baz: 2 }
       #   filter_hash(hash)
       #   # => { foo: 1, baz: 2 }
-      #   ```
       # @param hash [Hash] The hash to filter `:undef` members from.
       # @return [Hash] The given hash with all members with an `:undef` value removed.
       # @!visibility private

data/lib/vox/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Vox
-  # Overall gem version, each component also contains its own version
-  VERSION = '0.2.2'
+  # Gem version
+  VERSION = '0.2.3'
 end

data/vox.gemspec

@@ -28,15 +28,18 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.add_runtime_dependency 'event_emitter', '~> 0.2.6'
   spec.add_runtime_dependency 'faraday', '~> 1.0.1'
   spec.add_runtime_dependency 'logging', '~> 2.3.0'
   spec.add_runtime_dependency 'mime-types', '~> 3.3.1'
   spec.add_runtime_dependency 'multi_json', '~> 1.15.0'
+  spec.add_runtime_dependency 'websocket-driver', '~> 0.7.3'
   spec.add_development_dependency 'rake', '~> 12.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rubocop', '~> 0.89.1'
   spec.add_development_dependency 'rubocop-performance', '~> 1.7.1'
   spec.add_development_dependency 'rubocop-rspec', '~> 1.42.0'
   spec.add_development_dependency 'simplecov', '~> 0.17.1'
+  spec.add_development_dependency 'vox-etf', '~> 0.1.6'
   spec.add_development_dependency 'yard', '~> 0.9.25'
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: vox
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Matthew Carey
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-08-29 00:00:00.000000000 Z
+date: 2020-09-14 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: event_emitter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.6
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.15.0
+- !ruby/object:Gem::Dependency
+  name: websocket-driver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.3
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -150,6 +178,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.17.1
+- !ruby/object:Gem::Dependency
+  name: vox-etf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.6
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -185,7 +227,10 @@ files:
 - LICENSE.md
 - README.md
 - Rakefile
+- examples/gateway_example.rb
 - lib/vox.rb
+- lib/vox/gateway/client.rb
+- lib/vox/gateway/websocket.rb
 - lib/vox/http/client.rb
 - lib/vox/http/error.rb
 - lib/vox/http/middleware.rb
@@ -196,6 +241,7 @@ files:
 - lib/vox/http/routes/audit_log.rb
 - lib/vox/http/routes/channel.rb
 - lib/vox/http/routes/emoji.rb
+- lib/vox/http/routes/gateway.rb
 - lib/vox/http/routes/guild.rb
 - lib/vox/http/routes/invite.rb
 - lib/vox/http/routes/user.rb
@@ -227,7 +273,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Discord library