discordrb 2.1.3 → 3.0.0

data/lib/discordrb/light/light_bot.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'discordrb/api'
+require 'discordrb/api/invite'
+require 'discordrb/api/user'
 require 'discordrb/light/data'
 require 'discordrb/light/integrations'
 
@@ -29,13 +31,13 @@ module Discordrb::Light
 
     # @return [LightProfile] the details of the user this bot is connected to.
     def profile
-      response = Discordrb::API.profile(@token)
+      response = Discordrb::API::User.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)
+      response = Discordrb::API::User.servers(@token)
       JSON.parse(response).map { |e| LightServer.new(e, self) }
     end
 
@@ -43,13 +45,13 @@ module Discordrb::Light
     # @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)
+      Discordrb::API::Invite.accept(@token, code)
     end
 
     # Gets the connections associated with this account.
     # @return [Array<Connection>] this account's connections.
     def connections
-      response = Discordrb::API.connections(@token)
+      response = Discordrb::API::User.connections(@token)
       JSON.parse(response).map { |e| Connection.new(e, self) }
     end
   end

data/lib/discordrb/logger.rb

@@ -9,11 +9,20 @@ module Discordrb
     # @return [true, false] whether this logger is in extra-fancy mode!
     attr_writer :fancy
 
+    # @return [String, nil] The bot token to be redacted or nil if it shouldn't.
+    attr_writer :token
+
+    # @return [Array<IO>, Array<#puts & #flush>] the streams the logger should write to.
+    attr_accessor :streams
+
     # 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)
+    # @param streams [Array<IO>, Array<#puts & #flush>] the streams the logger should write to.
+    def initialize(fancy = false, streams = [STDOUT])
       @fancy = fancy
       self.mode = :normal
+
+      @streams = streams
     end
 
     # The modes this logger can have. This is probably useless unless you want to write your own Logger
@@ -80,19 +89,27 @@ module Discordrb
     def write(message, mode)
       thread_name = Thread.current[:discordrb_name]
       timestamp = Time.now.strftime(LOG_TIMESTAMP_FORMAT)
-      if @fancy
-        fancy_write(message, mode, thread_name, timestamp)
-      else
-        simple_write(message, mode, thread_name, timestamp)
+
+      # Redact token if set
+      message.gsub!(@token, 'REDACTED_TOKEN') if @token
+
+      @streams.each do |stream|
+        if @fancy && !stream.is_a?(File)
+          fancy_write(stream, message, mode, thread_name, timestamp)
+        else
+          simple_write(stream, message, mode, thread_name, timestamp)
+        end
       end
     end
 
-    def fancy_write(message, mode, thread_name, timestamp)
-      puts "#{timestamp} #{FORMAT_BOLD}#{thread_name.ljust(16)}#{FORMAT_RESET} #{mode[:format_code]}#{mode[:short]}#{FORMAT_RESET} #{message}"
+    def fancy_write(stream, message, mode, thread_name, timestamp)
+      stream.puts "#{timestamp} #{FORMAT_BOLD}#{thread_name.ljust(16)}#{FORMAT_RESET} #{mode[:format_code]}#{mode[:short]}#{FORMAT_RESET} #{message}"
+      stream.flush
     end
 
-    def simple_write(message, mode, thread_name, timestamp)
-      puts "[#{mode[:long]} : #{thread_name} @ #{timestamp}] #{message}"
+    def simple_write(stream, message, mode, thread_name, timestamp)
+      stream.puts "[#{mode[:long]} : #{thread_name} @ #{timestamp}] #{message}"
+      stream.flush
     end
   end
 end

data/lib/discordrb/permissions.rb

@@ -10,7 +10,7 @@ module Discordrb
       0 => :create_instant_invite, # 1
       1 => :kick_members,          # 2
       2 => :ban_members,           # 4
-      3 => :manage_roles,          # 8, also Manage Permissions
+      3 => :administrator,         # 8
       4 => :manage_channels,       # 16
       5 => :manage_server,         # 32
       # 6                          # 64
@@ -25,7 +25,7 @@ module Discordrb
       15 => :attach_files,         # 32768
       16 => :read_message_history, # 65536
       17 => :mention_everyone,     # 131072
-      # 18                         # 262144
+      18 => :use_external_emoji,   # 262144
       # 19                         # 524288
       20 => :connect,              # 1048576
       21 => :speak,                # 2097152
@@ -34,7 +34,8 @@ module Discordrb
       24 => :move_members,         # 16777216
       25 => :use_voice_activity,   # 33554432
       26 => :change_nickname,      # 67108864
-      27 => :manage_nicknames      # 134217728
+      27 => :manage_nicknames,     # 134217728
+      28 => :manage_roles          # 268435456, also Manage Permissions
     }.freeze
 
     Flags.each do |position, flag|
@@ -52,6 +53,8 @@ module Discordrb
       end
     end
 
+    alias_method :can_administrate=, :can_administrator=
+
     attr_reader :bits
 
     # Set the raw bitset of this permission object

data/lib/discordrb/version.rb

@@ -3,5 +3,5 @@
 # Discordrb and all its functionality, in this case only the version.
 module Discordrb
   # The current version of discordrb.
-  VERSION = '2.1.3'.freeze
+  VERSION = '3.0.0'.freeze
 end

data/lib/discordrb/voice/voice_bot.rb

@@ -21,6 +21,9 @@ module Discordrb::Voice
   # should check the parameters and adjust them to your connection: {VoiceBot#adjust_interval},
   # {VoiceBot#adjust_offset}, and {VoiceBot#adjust_average}.
   class VoiceBot
+    # @return [Channel] the current voice channel
+    attr_reader :channel
+
     # @return [Integer, nil] the amount of time the stream has been playing, or `nil` if nothing has been played yet.
     attr_reader :stream_time
 
@@ -88,6 +91,7 @@ module Discordrb::Voice
       @adjust_debug = true
 
       @volume = 1.0
+      @playing = false
 
       @encoder = Encoder.new
       @ws.connect
@@ -120,6 +124,14 @@ module Discordrb::Voice
       @paused = true
     end
 
+    # @see #play
+    # @return [true, false] Whether it is playing sound or not.
+    def playing?
+      @playing
+    end
+
+    alias_method :isplaying?, :playing?
+
     # Continue playback. This change may take up to 100 ms to take effect, which is usually negligible.
     def continue
       @paused = false
@@ -140,11 +152,19 @@ module Discordrb::Voice
     end
 
     # Stops the current playback entirely.
-    def stop_playing
+    # @param wait_for_confirmation [true, false] Whether the method should wait for confirmation from the playback
+    #   method that the playback has actually stopped.
+    def stop_playing(wait_for_confirmation = false)
       @was_playing_before = @playing
       @speaking = false
       @playing = false
       sleep IDEAL_LENGTH / 1000.0 if @was_playing_before
+
+      if wait_for_confirmation
+        @has_stopped_playing = false
+        sleep IDEAL_LENGTH / 1000.0 until @has_stopped_playing
+        @has_stopped_playing = false
+      end
     end
 
     # Permanently disconnects from the voice channel; to reconnect you will have to call {Bot#voice_connect} again.
@@ -160,7 +180,7 @@ module Discordrb::Voice
     # methods in separate threads.
     # @param encoded_io [IO] A stream of raw PCM data (s16le)
     def play(encoded_io)
-      stop_playing if @playing
+      stop_playing(true) if @playing
       @retry_attempts = 3
       @first_packet = true
 
@@ -180,7 +200,7 @@ module Discordrb::Voice
         # Check whether the buffer has enough data
         if !buf || buf.length != DATA_LENGTH
           @bot.debug("No data is available! Retrying #{@retry_attempts} more times")
-          break if @retry_attempts == 0
+          break if @retry_attempts.zero?
 
           @retry_attempts -= 1
           next
@@ -233,7 +253,7 @@ module Discordrb::Voice
     # @see https://github.com/bwmarrin/dca
     # @see #play
     def play_dca(file)
-      stop_playing if @playing
+      stop_playing(true) if @playing
 
       @bot.debug "Reading DCA file #{file}"
       input_stream = open(file)
@@ -362,12 +382,15 @@ module Discordrb::Voice
 
       # Final cleanup
       stop_playing
+
+      # Notify any stop_playing methods running right now that we have actually stopped
+      @has_stopped_playing = true
     end
 
     # Increment sequence and time
     def increment_packet_headers
-      (@sequence + 10 < 65_535) ? @sequence += 1 : @sequence = 0
-      (@time + 9600 < 4_294_967_295) ? @time += 960 : @time = 0
+      @sequence + 10 < 65_535 ? @sequence += 1 : @sequence = 0
+      @time + 9600 < 4_294_967_295 ? @time += 960 : @time = 0
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: discordrb
 version: !ruby/object:Gem::Version
-  version: 2.1.3
+  version: 3.0.0
 platform: ruby
 authors:
 - meew0
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-06-11 00:00:00.000000000 Z
+date: 2016-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -142,14 +142,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.39.0
+        version: 0.42.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.39.0
+        version: 0.42.0
 description: A Ruby implementation of the Discord (https://discordapp.com) API.
 email:
 - ''
@@ -172,13 +172,20 @@ files:
 - bin/setup
 - discordrb.gemspec
 - examples/commands.rb
+- examples/data/music.dca
+- examples/data/music.mp3
 - examples/eval.rb
 - examples/ping.rb
 - examples/ping_with_respond_time.rb
 - examples/pm_send.rb
 - examples/shutdown.rb
+- examples/voice_send.rb
 - lib/discordrb.rb
 - lib/discordrb/api.rb
+- lib/discordrb/api/channel.rb
+- lib/discordrb/api/invite.rb
+- lib/discordrb/api/server.rb
+- lib/discordrb/api/user.rb
 - lib/discordrb/await.rb
 - lib/discordrb/bot.rb
 - lib/discordrb/cache.rb
@@ -202,13 +209,13 @@ files:
 - lib/discordrb/events/roles.rb
 - lib/discordrb/events/typing.rb
 - lib/discordrb/events/voice_state_update.rb
+- lib/discordrb/gateway.rb
 - lib/discordrb/light.rb
 - lib/discordrb/light/data.rb
 - lib/discordrb/light/integrations.rb
 - lib/discordrb/light/light_bot.rb
 - lib/discordrb/logger.rb
 - lib/discordrb/permissions.rb
-- lib/discordrb/token_cache.rb
 - lib/discordrb/version.rb
 - lib/discordrb/voice/encoder.rb
 - lib/discordrb/voice/network.rb

data/lib/discordrb/token_cache.rb

@@ -1,181 +0,0 @@
-# frozen_string_literal: true
-
-require 'base64'
-require 'json'
-require 'openssl'
-require 'discordrb/api'
-
-# Discordrb
-module Discordrb
-  # Amount of bytes the token encryption key should be long (32 bytes = 256 bits -> AES256)
-  KEYLEN = 32
-
-  # 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'])
-        @password_hash = Base64.decode64(data['password_hash'])
-        @encrypt_salt = Base64.decode64(data['encrypt_salt'])
-        @iv = Base64.decode64(data['iv'])
-        @encrypted_token = Base64.decode64(data['encrypted_token'])
-      else
-        generate_salts
-      end
-    end
-
-    # @return [Hash<Symbol => String>] the data representing the token and encryption data, all encrypted and base64-encoded
-    def data
-      {
-        verify_salt: Base64.encode64(@verify_salt),
-        password_hash: Base64.encode64(@password_hash),
-        encrypt_salt: Base64.encode64(@encrypt_salt),
-        iv: Base64.encode64(@iv),
-        encrypted_token: Base64.encode64(@encrypted_token)
-      }
-    end
-
-    # Verifies this encrypted token with a given password
-    # @param password [String] A plaintext password to verify
-    # @see #hash_password
-    # @return [true, false] whether or not the verification succeeded
-    def verify_password(password)
-      hash_password(password) == @password_hash
-    end
-
-    # Sets the given password as the verification password
-    # @param password [String] A plaintext password to set
-    # @see #hash_password
-    def generate_verify_hash(password)
-      @password_hash = hash_password(password)
-    end
-
-    # Generates a key from a given password using PBKDF2 with a SHA1 HMAC, 300k iterations and 32 bytes long
-    # @param password [String] A password to use as the base for the key
-    # @return [String] The generated key
-    def obtain_key(password)
-      @key = OpenSSL::PKCS5.pbkdf2_hmac_sha1(password, @encrypt_salt, 300_000, KEYLEN)
-    end
-
-    # Generates cryptographically random salts for this token
-    def generate_salts
-      @verify_salt = OpenSSL::Random.random_bytes(KEYLEN)
-      @encrypt_salt = OpenSSL::Random.random_bytes(KEYLEN)
-    end
-
-    # Decrypts a token using a given password
-    # @param password [String] The plaintext password to decrypt the token with
-    # @return [String] the plaintext token
-    def decrypt_token(password)
-      key = obtain_key(password)
-      decipher = OpenSSL::Cipher::AES256.new(:CBC)
-      decipher.decrypt
-      decipher.key = key
-      decipher.iv = @iv
-      decipher.update(@encrypted_token) + decipher.final
-    end
-
-    # Encrypts a given token with the given password, using AES256 CBC
-    # @param password [String] The plaintext password to encrypt the token with
-    # @param token [String] The plaintext token to encrypt
-    # @return [String] the encrypted token
-    def encrypt_token(password, token)
-      key = obtain_key(password)
-      cipher = OpenSSL::Cipher::AES256.new(:CBC)
-      cipher.encrypt
-      cipher.key = key
-      @iv = cipher.random_iv
-      @encrypted_token = cipher.update(token) + cipher.final
-    end
-
-    # Tests a token by making an API request, throws an error if not successful
-    # @param token [String] A plaintext token to test
-    def test_token(token)
-      Discordrb::API.validate_token(token)
-    end
-
-    # Hashes a password using PBKDF2 with a SHA256 digest
-    # @param password [String] The password to hash
-    # @return [String] The hashed password
-    def hash_password(password)
-      digest = OpenSSL::Digest::SHA256.new
-      OpenSSL::PKCS5.pbkdf2_hmac(password, @verify_salt, 300_000, digest.digest_length, digest)
-    end
-  end
-
-  # Path where the token cache file will be stored
-  CACHE_PATH = Dir.home + '/.discordrb_token_cache.json'
-
-  # Represents a token file
-  class TokenCache
-    def initialize
-      if File.file? CACHE_PATH
-        @data = JSON.parse(File.read(CACHE_PATH))
-      else
-        LOGGER.debug("Cache file #{CACHE_PATH} not found. Using empty cache")
-        @data = {}
-      end
-    rescue => e
-      LOGGER.debug('Exception occurred while parsing token cache file:', true)
-      LOGGER.log_exception(e)
-      LOGGER.debug('Continuing with empty cache')
-      @data = {}
-    end
-
-    # Gets a token from this token cache
-    # @param email [String] The email to get the token for
-    # @param password [String] The plaintext password to get the token for
-    # @return [String, nil] the stored token, or nil if unsuccessful (e. g. token not cached or cached token invalid)
-    def token(email, password)
-      if @data[email]
-        begin
-          cached = CachedToken.new(@data[email])
-          if cached.verify_password(password)
-            token = cached.decrypt_token(password)
-            if token
-              begin
-                cached.test_token(token)
-                token
-              rescue => e
-                fail_token('Token cached, verified and decrypted, but rejected by Discord', email, e)
-                sleep 1 # wait some time so we don't get immediately rate limited
-                nil
-              end
-            else; fail_token('Token cached and verified, but decryption failed', email)
-            end
-          else; fail_token('Token verification failed', email)
-          end
-        rescue => e; fail_token('Token cached but invalid', email, e)
-        end
-      else; fail_token('Token not cached at all')
-      end
-    end
-
-    # Caches a token
-    # @param email [String] The email to store this token under
-    # @param password [String] The plaintext password to encrypt the token with
-    # @param token [String] The plaintext token to cache
-    def store_token(email, password, token)
-      cached = CachedToken.new
-      cached.generate_verify_hash(password)
-      cached.encrypt_token(password, token)
-      @data[email] = cached.data
-      write_cache
-    end
-
-    # Writes the cache to a file
-    def write_cache
-      File.write(CACHE_PATH, @data.to_json)
-    end
-
-    private
-
-    def fail_token(msg, email = nil, e = nil)
-      LOGGER.warn("Token not retrieved from cache - #{msg}")
-      LOGGER.log_exception(e) if e
-      @data.delete(email) if email
-      nil
-    end
-  end
-end