discordrb 1.8.1 → 2.0.0

data/lib/discordrb/cache.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require 'discordrb/api'
+require 'discordrb/data'
+
+module Discordrb
+  # This mixin module does caching stuff for the library. It conveniently separates the logic behind
+  # the caching (like, storing the user hashes or making API calls to retrieve things) from the Bot that
+  # actually uses it.
+  module Cache
+    # Initializes this cache
+    def init_cache
+      @users = {}
+
+      @servers = {}
+
+      @channels = {}
+      @private_channels = {}
+
+      @restricted_channels = []
+    end
+
+    # Gets a channel given its ID. This queries the internal channel cache, and if the channel doesn't
+    # exist in there, it will get the data from Discord.
+    # @param id [Integer] The channel ID for which to search for.
+    # @param server [Server] The server for which to search the channel for. If this isn't specified, it will be
+    #   inferred using the API
+    # @return [Channel] The channel identified by the ID.
+    def channel(id, server = nil)
+      id = id.resolve_id
+
+      raise Discordrb::Errors::NoPermission if @restricted_channels.include? id
+
+      debug("Obtaining data for channel with id #{id}")
+      return @channels[id] if @channels[id]
+
+      begin
+        response = API.channel(token, id)
+        channel = Channel.new(JSON.parse(response), self, server)
+        @channels[id] = channel
+      rescue Discordrb::Errors::NoPermission
+        debug "Tried to get access to restricted channel #{id}, blacklisting it"
+        @restricted_channels << id
+        raise
+      end
+    end
+
+    # Gets a user by its ID.
+    # @note This can only resolve users known by the bot (i.e. that share a server with the bot).
+    # @param id [Integer] The user ID that should be resolved.
+    # @return [User, nil] The user identified by the ID, or `nil` if it couldn't be found.
+    def user(id)
+      id = id.resolve_id
+      return @users[id] if @users[id]
+
+      LOGGER.out("Resolving user #{id}")
+      response = API.user(token, id)
+      user = User.new(JSON.parse(response), self)
+      @users[id] = user
+    end
+
+    # Gets a server by its ID.
+    # @note This can only resolve servers the bot is currently in.
+    # @param id [Integer] The server ID that should be resolved.
+    # @return [Server, nil] The server identified by the ID, or `nil` if it couldn't be found.
+    def server(id)
+      id = id.resolve_id
+      return @servers[id] if @servers[id]
+
+      LOGGER.out("Resolving server #{id}")
+      response = API.server(token, id)
+      server = Server.new(JSON.parse(response), self)
+      @servers[id] = server
+    end
+
+    # Gets a member by both IDs
+    # @param server_id [Integer] The server ID for which a member should be resolved
+    # @param user_id [Integer] The ID of the user that should be resolved
+    # @return [Member, nil] The member identified by the IDs, or `nil` if none could be found
+    def member(server_id, user_id)
+      server_id = server_id.resolve_id
+      user_id = user_id.resolve_id
+
+      server = self.server(server_id)
+      return server.member(user_id) if server.member_cached?(user_id)
+
+      LOGGER.out("Resolving member #{server_id} on server #{user_id}")
+      response = API.member(token, server_id, user_id)
+      member = Member.new(JSON.parse(response), server, self)
+      server.cache_member(member)
+    end
+
+    # Creates a private channel for the given user ID, or if one exists already, returns that one.
+    # It is recommended that you use {User#pm} instead, as this is mainly for internal use. However,
+    # usage of this method may be unavoidable if only the user ID is known.
+    # @param id [Integer] The user ID to generate a private channel for.
+    # @return [Channel] A private channel for that user.
+    def private_channel(id)
+      id = id.resolve_id
+      debug("Creating private channel with user id #{id}")
+      return @private_channels[id] if @private_channels[id]
+
+      response = API.create_private(token, @profile.id, id)
+      channel = Channel.new(JSON.parse(response), self)
+      @private_channels[id] = channel
+    end
+
+    # Ensures a given user object is cached and if not, cache it from the given data hash.
+    # @param data [Hash] A data hash representing a user.
+    # @return [User] the user represented by the data hash.
+    def ensure_user(data)
+      if @users.include?(data['id'].to_i)
+        @users[data['id'].to_i]
+      else
+        @users[data['id'].to_i] = User.new(data, self)
+      end
+    end
+
+    # Ensures a given server object is cached and if not, cache it from the given data hash.
+    # @param data [Hash] A data hash representing a server.
+    # @return [Server] the server represented by the data hash.
+    def ensure_server(data)
+      if @servers.include?(data['id'].to_i)
+        @servers[data['id'].to_i]
+      else
+        @servers[data['id'].to_i] = Server.new(data, self)
+      end
+    end
+
+    # Ensures a given channel object is cached and if not, cache it from the given data hash.
+    # @param data [Hash] A data hash representing a channel.
+    # @return [Channel] the channel represented by the data hash.
+    def ensure_channel(data)
+      if @channels.include?(data['id'].to_i)
+        @channels[data['id'].to_i]
+      else
+        @channels[data['id'].to_i] = Channel.new(data, self)
+      end
+    end
+
+    # Requests member chunks for a given server ID.
+    # @param id [Integer] The server ID to request chunks for.
+    def request_chunks(id)
+      chunk_packet = {
+        op: 8,
+        d: {
+          guild_id: id,
+          query: '',
+          limit: 0
+        }
+      }.to_json
+      @ws.send(chunk_packet)
+    end
+
+    # Gets the code for an invite.
+    # @param invite [String, Invite] The invite to get the code for. Possible formats are:
+    #
+    #    * An {Invite} object
+    #    * The code for an invite
+    #    * A fully qualified invite URL (e. g. `https://discordapp.com/invite/0A37aN7fasF7n83q`)
+    #    * A short invite URL with protocol (e. g. `https://discord.gg/0A37aN7fasF7n83q`)
+    #    * A short invite URL without protocol (e. g. `discord.gg/0A37aN7fasF7n83q`)
+    # @return [String] Only the code for the invite.
+    def resolve_invite_code(invite)
+      invite = invite.code if invite.is_a? Discordrb::Invite
+      invite = invite[invite.rindex('/') + 1..-1] if invite.start_with?('http', 'discord.gg')
+      invite
+    end
+
+    # Gets information about an invite.
+    # @param invite [String, Invite] The invite to join. For possible formats see {#resolve_invite_code}.
+    # @return [Invite] The invite with information about the given invite URL.
+    def invite(invite)
+      code = resolve_invite_code(invite)
+      Invite.new(JSON.parse(API.resolve_invite(token, code)), self)
+    end
+
+    # Finds a channel given its name and optionally the name of the server it is in.
+    # @param channel_name [String] The channel to search for.
+    # @param server_name [String] The server to search for, or `nil` if only the channel should be searched for.
+    # @param type [String, nil] The type of channel to search for (`'text'` or `'voice'`), or `nil` if either type of
+    #   channel should be searched for
+    # @return [Array<Channel>] The array of channels that were found. May be empty if none were found.
+    def find_channel(channel_name, server_name = nil, type: nil)
+      results = []
+
+      if /<#(?<id>\d+)>?/ =~ channel_name
+        # Check for channel mentions separately
+        return [channel(id)]
+      end
+
+      @servers.values.each do |server|
+        server.channels.each do |channel|
+          results << channel if channel.name == channel_name && (server_name || server.name) == server.name && (!type || (channel.type == type))
+        end
+      end
+
+      results
+    end
+
+    # Finds a user given its username.
+    # @param username [String] The username to look for.
+    # @return [Array<User>] The array of users that were found. May be empty if none were found.
+    def find_user(username)
+      @users.values.find_all { |e| e.username == username }
+    end
+  end
+end

data/lib/discordrb/commands/command_bot.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'discordrb/bot'
 require 'discordrb/data'
 require 'discordrb/commands/parser'
@@ -19,22 +21,22 @@ module Discordrb::Commands
     include CommandContainer
 
     # Creates a new CommandBot and logs in to Discord.
-    # @param email [String] The email to use to log in.
-    # @param password [String] The password corresponding to the email.
-    # @param prefix [String] The prefix that should trigger this bot's commands. Can be any string (including the empty
+    # @param attributes [Hash] The attributes to initialize the CommandBot with.
+    # @see {Discordrb::Bot#initialize} for other attributes that should be used to create the underlying regular bot.
+    # @option attributes [String] :prefix The prefix that should trigger this bot's commands. Can be any string (including the empty
     #   string), but note that it will be literal - if the prefix is "hi" then the corresponding trigger string for
     #   a command called "test" would be "hitest". Don't forget to put spaces in if you need them!
-    # @param attributes [Hash] The attributes to initialize the CommandBot with.
-    # @param debug [true, false] Whether or not debug mode should be used - debug mode logs tons of extra stuff to the
-    #   console that may be useful in development.
     # @option attributes [true, false] :advanced_functionality Whether to enable advanced functionality (very powerful
     #   way to nest commands into chains, see https://github.com/meew0/discordrb/wiki/Commands#command-chain-syntax
     #   for info. Default is true.
-    # @option attributes [Symbol, Array<Symbol>] :help_command The name of the command that displays info for other
-    #   commands. Use an array if you want to have aliases. Default is "help".
+    # @option attributes [Symbol, Array<Symbol>, false] :help_command The name of the command that displays info for
+    #   other commands. Use an array if you want to have aliases. Default is "help". If none should be created, use
+    #   `false` as the value.
     # @option attributes [String] :command_doesnt_exist_message The message that should be displayed if a user attempts
     #   to use a command that does not exist. If none is specified, no message will be displayed. In the message, you
     #   can use the string '%command%' that will be replaced with the name of the command.
+    # @option attributes [true, false] :spaces_allowed Whether spaces are allowed to occur between the prefix and the
+    #   command. Default is false.
     # @option attributes [String] :previous Character that should designate the result of the previous command in
     #   a command chain (see :advanced_functionality). Default is '~'.
     # @option attributes [String] :chain_delimiter Character that should designate that a new command begins in the
@@ -49,20 +51,34 @@ module Discordrb::Commands
     #   :advanced_functionality). Default is '"'.
     # @option attributes [String] :quote_end Character that should end a quoted string (see
     #   :advanced_functionality). Default is '"'.
-    def initialize(email, password, prefix, attributes = {}, debug = false)
-      super(email, password, debug)
-      @prefix = prefix
+    def initialize(attributes = {})
+      super(
+        email: attributes[:email],
+        password: attributes[:password],
+        log_mode: attributes[:log_mode],
+        token: attributes[:token],
+        application_id: attributes[:application_id],
+        type: attributes[:type],
+        name: attributes[:name],
+        fancy_log: attributes[:fancy_log],
+        suppress_ready: attributes[:suppress_ready],
+        parse_self: attributes[:parse_self])
+
+      @prefix = attributes[:prefix]
       @attributes = {
         # Whether advanced functionality such as command chains are enabled
-        advanced_functionality: attributes[:advanced_functionality].nil? ? true : attributes[:advanced_functionality],
+        advanced_functionality: attributes[:advanced_functionality].nil? ? false : attributes[:advanced_functionality],
 
-        # The name of the help command (that displays information to other commands). Nil if none should exist
-        help_command: attributes[:help_command] || :help,
+        # The name of the help command (that displays information to other commands). False if none should exist
+        help_command: (attributes[:help_command].is_a? FalseClass) ? nil : (attributes[:help_command] || :help),
 
         # The message to display for when a command doesn't exist, %command% to get the command name in question and nil for no message
         # No default value here because it may not be desired behaviour
         command_doesnt_exist_message: attributes[:command_doesnt_exist_message],
 
+        # Spaces allowed between prefix and command
+        spaces_allowed: attributes[:spaces_allowed].nil? ? false : attributes[:spaces_allowed],
+
         # All of the following need to be one character
         # String to designate previous result in command chain
         previous: attributes[:previous] || '~',
@@ -99,7 +115,8 @@ module Discordrb::Commands
           desc = command.attributes[:description] || '*No description available*'
           usage = command.attributes[:usage]
           result = "**`#{command_name}`**: #{desc}"
-          result << "\nUsage: `#{usage}`" if usage
+          result += "\nUsage: `#{usage}`" if usage
+          result
         else
           available_commands = @commands.values.reject { |c| !c.attributes[:help_available] }
           case available_commands.length
@@ -133,10 +150,10 @@ module Discordrb::Commands
         event.respond @attributes[:command_doesnt_exist_message].gsub('%command%', name.to_s) if @attributes[:command_doesnt_exist_message]
         return
       end
-      if permission?(user(event.user.id), command.attributes[:permission_level], event.server)
+      if permission?(event.user, command.attributes[:permission_level], event.server)
         event.command = command
         result = command.call(event, arguments, chained)
-        result.to_s
+        stringify(result)
       else
         event.respond "You don't have permission to execute command `#{name}`!"
       end
@@ -172,7 +189,7 @@ module Discordrb::Commands
     # @param server [Server] The server on which to check
     # @return [true, false] whether or not the user has the given permission
     def permission?(user, level, server)
-      determined_level = server.nil? ? 0 : user.roles[server.id].each.reduce(0) do |memo, role|
+      determined_level = server.nil? ? 0 : user.roles.reduce(0) do |memo, role|
         [@permissions[:roles][role.id] || 0, memo].max
       end
       [@permissions[:users][user.id] || 0, determined_level].max >= level
@@ -183,11 +200,19 @@ module Discordrb::Commands
     # Internal handler for MESSAGE_CREATE that is overwritten to allow for command handling
     def create_message(data)
       message = Discordrb::Message.new(data, self)
+      return if message.from_bot? && !@should_parse_self
+
       event = CommandEvent.new(message, self)
 
       return unless message.content.start_with? @prefix
       chain = message.content[@prefix.length..-1]
 
+      # Don't allow spaces between the prefix and the command
+      if chain.start_with?(' ') && !@attributes[:spaces_allowed]
+        debug('Chain starts with a space')
+        return
+      end
+
       if chain.strip.empty?
         debug('Chain is empty')
         return
@@ -212,5 +237,12 @@ module Discordrb::Commands
         end
       end
     end
+
+    # Turns the object into a string, using to_s by default
+    def stringify(object)
+      return '' if object.is_a? Discordrb::Message
+
+      object.to_s
+    end
   end
 end

data/lib/discordrb/commands/container.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'discordrb/container'
 require 'discordrb/commands/rate_limiter'
 
@@ -34,8 +36,13 @@ module Discordrb::Commands
     def command(name, attributes = {}, &block)
       @commands ||= {}
       if name.is_a? Array
-        new_command = Command.new(name[0], attributes, &block)
-        name.each { |n| @commands[n] = new_command }
+        new_command = nil
+
+        name.each do |e|
+          new_command = Command.new(e, attributes, &block)
+          @commands[e] = new_command
+        end
+
         new_command
       else
         @commands[name] = Command.new(name, attributes, &block)
@@ -53,6 +60,8 @@ module Discordrb::Commands
     # @param container [Module] A module that `extend`s {CommandContainer} from which the commands will be added.
     def include_commands(container)
       handlers = container.instance_variable_get '@commands'
+      return unless handlers
+
       @commands ||= {}
       @commands.merge! handlers
     end

data/lib/discordrb/commands/events.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'discordrb/events/message'
 
 module Discordrb::Commands

data/lib/discordrb/commands/parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Discordrb::Commands
   # Command that can be called in a chain
   class Command
@@ -136,14 +138,14 @@ module Discordrb::Commands
           b_level += 1
         end
 
-        result << char if b_level <= 0
+        result += char if b_level <= 0
 
         next unless char == @attributes[:sub_chain_end] && !quoted
         b_level -= 1
         next unless b_level == 0
         nested = @chain[b_start + 1..index - 1]
         subchain = CommandChain.new(nested, @bot, true)
-        result << subchain.execute(event)
+        result += subchain.execute(event)
       end
 
       event.respond("Your subchains are mismatched! Make sure you don't have any extra #{@attributes[:sub_chain_start]}'s or #{@attributes[:sub_chain_end]}'s") unless b_level == 0
@@ -165,21 +167,21 @@ module Discordrb::Commands
         command = @attributes[:chain_delimiter] + command if first && @chain.start_with?(@attributes[:chain_delimiter])
         first = false
 
-        command.strip!
+        command = command.strip
 
         # Replace the hacky delimiter that was used inside quotes with actual delimiters
-        command.gsub! hacky_delim, @attributes[:chain_delimiter]
+        command = command.gsub hacky_delim, @attributes[:chain_delimiter]
 
         first_space = command.index ' '
         command_name = first_space ? command[0..first_space - 1] : command
         arguments = first_space ? command[first_space + 1..-1] : ''
 
         # Append a previous sign if none is present
-        arguments << @attributes[:previous] unless arguments.include? @attributes[:previous]
-        arguments.gsub! @attributes[:previous], prev
+        arguments += @attributes[:previous] unless arguments.include? @attributes[:previous]
+        arguments = arguments.gsub @attributes[:previous], prev
 
         # Replace hacky previous signs with actual ones
-        arguments.gsub! hacky_prev, @attributes[:previous]
+        arguments = arguments.gsub hacky_prev, @attributes[:previous]
 
         arguments = arguments.split ' '
 
@@ -214,7 +216,7 @@ module Discordrb::Commands
           executed_chain = divide_chain(old_chain).last
 
           arg[1].to_i.times do
-            new_result << CommandChain.new(executed_chain, @bot).execute(event)
+            new_result += CommandChain.new(executed_chain, @bot).execute(event)
           end
 
           result = new_result

data/lib/discordrb/commands/rate_limiter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Discordrb::Commands
   # This class represents a bucket for rate limiting - it keeps track of how many requests have been made and when
   # exactly the user should be rate limited.