discordrb 1.8.1 → 2.0.0

data/lib/discordrb/events/roles.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'discordrb/events/generic'
+require 'discordrb/data'
+
+module Discordrb::Events
+  # Raised when a role is created on a server
+  class ServerRoleCreateEvent < Event
+    # @return [Role] the role that got created
+    attr_reader :role
+
+    # @return [Server] the server on which a role got created
+    attr_reader :server
+
+    def initialize(data, bot)
+      @server = bot.server(data['guild_id'].to_i)
+      return unless @server
+
+      role_id = data['role']['id'].to_i
+      @role = @server.roles.find { |r| r.id == role_id }
+    end
+  end
+
+  # Event handler for ServerRoleCreateEvent
+  class ServerRoleCreateEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? ServerRoleCreateEvent
+
+      [
+        matches_all(@attributes[:name], event.name) do |a, e|
+          a == if a.is_a? String
+                 e.to_s
+               else
+                 e
+               end
+        end
+      ].reduce(true, &:&)
+    end
+  end
+
+  # Raised when a role is deleted from a server
+  class ServerRoleDeleteEvent < Event
+    # @return [Integer] the ID of the role that got deleted.
+    attr_reader :id
+
+    # @return [Server] the server on which a role got deleted.
+    attr_reader :server
+
+    def initialize(data, bot)
+      # The role should already be deleted from the server's list
+      # by the time we create this event, so we'll create a temporary
+      # role object for event consumers to use.
+      @id = data['role_id'].to_i
+      server_id = data['guild_id'].to_i
+      @server = bot.server(server_id)
+    end
+  end
+
+  # EventHandler for ServerRoleDeleteEvent
+  class ServerRoleDeleteEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type
+      return false unless event.is_a? ServerRoleDeleteEvent
+
+      [
+        matches_all(@attributes[:name], event.name) do |a, e|
+          a == if a.is_a? String
+                 e.to_s
+               else
+                 e
+               end
+        end
+      ].reduce(true, &:&)
+    end
+  end
+
+  # Event raised when a role updates on a server
+  class ServerRoleUpdateEvent < ServerRoleCreateEvent; end
+
+  # Event handler for ServerRoleUpdateEvent
+  class ServerRoleUpdateEventHandler < ServerRoleCreateEventHandler; end
+end

data/lib/discordrb/events/typing.rb

@@ -1,15 +1,28 @@
+# frozen_string_literal: true
+
 require 'discordrb/events/generic'
 
 module Discordrb::Events
   # Event raised when a user starts typing
   class TypingEvent < Event
-    attr_reader :channel, :user, :timestamp
+    # @return [Channel] the channel on which a user started typing.
+    attr_reader :channel
+
+    # @return [Member] the user that started typing.
+    attr_reader :user
+    alias_method :member, :user
+
+    # @return [Time] when the typing happened.
+    attr_reader :timestamp
 
     def initialize(data, bot)
       @user_id = data['user_id'].to_i
-      @user = bot.user(@user_id)
+
       @channel_id = data['channel_id'].to_i
       @channel = bot.channel(@channel_id)
+
+      @user = channel.private? ? channel.recipient : bot.member(@channel.server.id, @user_id)
+
       @timestamp = Time.at(data['timestamp'].to_i)
     end
   end

data/lib/discordrb/events/voice_state_update.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'discordrb/events/generic'
 require 'discordrb/data'
 

data/lib/discordrb/light.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'discordrb/light/light_bot'
+
+# This module contains classes to allow connections to bots without a connection to the gateway socket, i. e. bots
+# that only use the REST part of the API.
+module Discordrb::Light
+end

data/lib/discordrb/light/data.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'discordrb/data'
+
+module Discordrb::Light
+  # Represents the bot account used for the light bot, but without any methods to change anything.
+  class LightProfile
+    include Discordrb::IDObject
+    include Discordrb::UserAttributes
+
+    # @!visibility private
+    def initialize(data, bot)
+      @bot = bot
+
+      @username = data['username']
+      @id = data['id'].to_i
+      @discriminator = data['discriminator']
+      @avatar_id = data['avatar']
+
+      @bot_account = false
+      @bot_account = true if data['bot']
+
+      @verified = data['verified']
+
+      @email = data['email']
+    end
+  end
+
+  # A server that only has an icon, a name, and an ID associated with it, like for example an integration's server.
+  class UltraLightServer
+    include Discordrb::IDObject
+    include Discordrb::ServerAttributes
+
+    # @!visibility private
+    def initialize(data, bot)
+      @bot = bot
+
+      @id = data['id'].to_i
+
+      @name = data['name']
+      @icon_id = data['icon']
+    end
+  end
+
+  # Represents a light server which only has a fraction of the properties of any other server.
+  class LightServer < UltraLightServer
+    # @return [true, false] whether or not the LightBot this server belongs to is the owner of the server.
+    attr_reader :bot_is_owner
+    alias_method :bot_is_owner?, :bot_is_owner
+
+    # @return [Discordrb::Permissions] the permissions the LightBot has on this server
+    attr_reader :bot_permissions
+
+    # @!visibility private
+    def initialize(data, bot)
+      super(data, bot)
+
+      @bot_is_owner = data['owner']
+      @bot_permissions = Discordrb::Permissions.new(data['permissions'])
+    end
+  end
+end

data/lib/discordrb/light/integrations.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'discordrb/data'
+require 'discordrb/light/data'
+
+module Discordrb::Light
+  # A connection of your Discord account to a particular other service (currently, Twitch and YouTube)
+  class Connection
+    # @return [Symbol] what type of connection this is (either :twitch or :youtube currently)
+    attr_reader :type
+
+    # @return [true, false] whether this connection is revoked
+    attr_reader :revoked
+    alias_method :revoked?, :revoked
+
+    # @return [String] the name of the connected account
+    attr_reader :name
+
+    # @return [String] the ID of the connected account
+    attr_reader :id
+
+    # @return [Array<Integration>] the integrations associated with this connection
+    attr_reader :integrations
+
+    # @!visibility private
+    def initialize(data, bot)
+      @bot = bot
+
+      @revoked = data['revoked']
+      @type = data['type'].to_sym
+      @name = data['name']
+      @id = data['id']
+
+      @integrations = data['integrations'].map { |e| Integration.new(e, self, bot) }
+    end
+  end
+
+  # An integration of a connection into a particular server, for example being a member of a subscriber-only Twitch
+  # server.
+  class Integration
+    include Discordrb::IDObject
+
+    # @return [UltraLightServer] the server associated with this integration
+    attr_reader :server
+
+    # @note The connection returned by this method will have no integrations itself, as Discord doesn't provide that
+    #   data. Also, it will always be considered not revoked.
+    # @return [Connection] the server's underlying connection (for a Twitch subscriber-only server, it would be the
+    #   Twitch account connection of the server owner).
+    attr_reader :server_connection
+
+    # @return [Connection] the connection integrated with the server (i. e. your connection)
+    attr_reader :integrated_connection
+
+    # @!visibility private
+    def initialize(data, integrated, bot)
+      @bot = bot
+      @integrated_connection = integrated
+
+      @server = UltraLightServer.new(data['guild'], bot)
+
+      # Restructure the given data so we can reuse the Connection initializer
+      restructured = {}
+
+      restructured['type'] = data['type']
+      restructured['id'] = data['account']['id']
+      restructured['name'] = data['account']['name']
+      restructured['integrations'] = []
+
+      @server_connection = Connection.new(restructured, bot)
+    end
+  end
+end

data/lib/discordrb/light/light_bot.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'discordrb/api'
+require 'discordrb/light/data'
+require 'discordrb/light/integrations'
+
+# This module contains classes to allow connections to bots without a connection to the gateway socket, i. e. bots
+# that only use the REST part of the API.
+module Discordrb::Light
+  # A bot that only uses the REST part of the API. Hierarchically unrelated to the regular {Discordrb::Bot}. Useful to
+  # make applications integrated to Discord over OAuth, for example.
+  class LightBot
+    # Create a new LightBot. This does no networking yet, all networking is done by the methods on this class.
+    # @param token [String] The token that should be used to authenticate to Discord. Can be an OAuth token or a regular
+    #   user account token.
+    def initialize(token)
+      if token.respond_to? :token
+        # Parse AccessTokens from the OAuth2 gem
+        token = token.token
+      end
+
+      unless token.include? '.'
+        # Discord user/bot tokens always contain two dots, so if there's none we can assume it's an OAuth token.
+        token = "Bearer #{token}" # OAuth tokens have to be prefixed with 'Bearer' for Discord to be able to use them
+      end
+
+      @token = token
+    end
+
+    # @return [LightProfile] the details of the user this bot is connected to.
+    def profile
+      response = Discordrb::API.profile(@token)
+      LightProfile.new(JSON.parse(response), self)
+    end
+
+    # @return [Array<LightServer>] the servers this bot is connected to.
+    def servers
+      response = Discordrb::API.servers(@token)
+      JSON.parse(response).map { |e| LightServer.new(e, self) }
+    end
+
+    # Joins a server using an instant invite.
+    # @param code [String] The code part of the invite (for example 0cDvIgU2voWn4BaD if the invite URL is
+    #   https://discord.gg/0cDvIgU2voWn4BaD)
+    def join(code)
+      Discordrb::API.join_server(@token, code)
+    end
+
+    # Gets the connections associated with this account.
+    # @return [Array<Connection>] this account's connections.
+    def connections
+      response = Discordrb::API.connections(@token)
+      JSON.parse(response).map { |e| Connection.new(e, self) }
+    end
+  end
+end

data/lib/discordrb/logger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Discordrb
   # The format log timestamps should be in, in strftime format
   LOG_TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S.%L'.freeze
@@ -7,6 +9,8 @@ module Discordrb
     # @return [true, false] whether this logger is in extra-fancy mode!
     attr_writer :fancy
 
+    # Creates a new logger.
+    # @param fancy [true, false] Whether this logger uses fancy mode (ANSI escape codes to make the output colourful)
     def initialize(fancy = false)
       @fancy = fancy
       self.mode = :normal

data/lib/discordrb/permissions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Discordrb
   # List of permissions Discord uses
   class Permissions
@@ -8,7 +10,7 @@ module Discordrb
       0 => :create_instant_invite, # 1
       1 => :kick_members,          # 2
       2 => :ban_members,           # 4
-      3 => :manage_roles,          # 8
+      3 => :manage_roles,          # 8, also Manage Permissions
       4 => :manage_channels,       # 16
       5 => :manage_server,         # 32
       # 6                          # 64
@@ -36,17 +38,15 @@ module Discordrb
     Flags.each do |position, flag|
       attr_reader flag
       define_method "can_#{flag}=" do |value|
-        if @writer
-          new_bits = @bits
-          if value
-            new_bits |= (1 << position)
-          else
-            new_bits &= ~(1 << position)
-          end
-          @writer.write(new_bits)
-          @bits = new_bits
-          init_vars
+        new_bits = @bits
+        if value
+          new_bits |= (1 << position)
+        else
+          new_bits &= ~(1 << position)
         end
+        @writer.write(new_bits) if @writer
+        @bits = new_bits
+        init_vars
       end
     end
 
@@ -67,7 +67,11 @@ module Discordrb
       end
     end
 
-    def initialize(bits, writer = nil)
+    # Create a new Permissions object either as a blank slate to add permissions to (for example for
+    #   {Channel#define_overwrite}) or from existing bit data to read out.
+    # @param bits [Integer] The permission bits that should be set from the beginning.
+    # @param writer [RoleWriter] The writer that should be used to update data when a permission is set.
+    def initialize(bits = 0, writer = nil)
       @writer = writer
       @bits = bits
       init_vars

data/lib/discordrb/token_cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'base64'
 require 'json'
 require 'openssl'
@@ -10,6 +12,7 @@ module Discordrb
 
   # Represents a cached token with encryption data
   class CachedToken
+    # Parse the cached token from the JSON data read from the file.
     def initialize(data = nil)
       if data
         @verify_salt = Base64.decode64(data['verify_salt'])

data/lib/discordrb/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 # Discordrb and all its functionality, in this case only the version.
 module Discordrb
   # The current version of discordrb.
-  VERSION = '1.8.1'.freeze
+  VERSION = '2.0.0'.freeze
 end

data/lib/discordrb/voice/encoder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This makes opus an optional dependency
 begin
   require 'opus-ruby'

data/lib/discordrb/voice/network.rb

@@ -1,15 +1,21 @@
+# frozen_string_literal: true
+
 require 'websocket-client-simple'
 require 'resolv'
 require 'socket'
 require 'json'
 
+require 'discordrb/websocket'
+
 begin
-  require 'rbnacl'
-  RBNACL_AVAILABLE = true
+  RBNACL_AVAILABLE = false
+  unless ENV.key?('DISCORDRB_NONACL')
+    require 'rbnacl'
+    RBNACL_AVAILABLE = true
+  end
 rescue LoadError
   puts "libsodium not available! You can continue to use discordrb as normal but voice support won't work.
         Read https://github.com/meew0/discordrb/wiki/Installing-libsodium for more details."
-  RBNACL_AVAILABLE = false
 end
 
 module Discordrb::Voice
@@ -42,7 +48,7 @@ module Discordrb::Voice
     def connect(endpoint, port, ssrc)
       @endpoint = endpoint
       @endpoint = @endpoint[6..-1] if @endpoint.start_with? 'wss://'
-      @endpoint.gsub!(':80', '') # The endpoint may contain a port, we don't want that
+      @endpoint = @endpoint.gsub(':80', '') # The endpoint may contain a port, we don't want that
       @endpoint = Resolv.getaddress @endpoint
 
       @port = port
@@ -126,8 +132,7 @@ module Discordrb::Voice
       @token = token
       @session = session
 
-      @endpoint = endpoint
-      @endpoint.gsub!(':80', '')
+      @endpoint = endpoint.gsub(':80', '')
 
       @udp = VoiceUDP.new
     end
@@ -198,7 +203,7 @@ module Discordrb::Voice
       Thread.current[:discordrb_name] = 'vws-i'
 
       # Send the init packet
-      send_init(@channel.server.id, @bot.bot_user.id, @session, @token)
+      send_init(@channel.server.id, @bot.profile.id, @session, @token)
     end
 
     # @!visibility private
@@ -285,15 +290,17 @@ module Discordrb::Voice
     def init_ws
       host = "wss://#{@endpoint}:443"
       @bot.debug("Connecting VWS to host: #{host}")
-      @client = WebSocket::Client::Simple.connect(host)
 
-      # Change some instance to local variables for the blocks
-      instance = self
+      # Connect the WS
+      @client = Discordrb::WebSocket.new(
+        host,
+        method(:websocket_open),
+        method(:websocket_message),
+        proc { |e| puts "VWS error: #{e}" },
+        proc { |e| puts "VWS close: #{e}" }
+      )
 
-      @client.on(:open) { instance.websocket_open }
-      @client.on(:message) { |msg| instance.websocket_message(msg.data) }
-      @client.on(:error) { |e| puts "VWS error: #{e}" }
-      @client.on(:close) { |e| puts "VWS close: #{e}" }
+      @bot.debug('VWS connected')
 
       # Block any further execution
       heartbeat_loop