discordrb 3.5.0 → 3.6.0

data/lib/discordrb/api.rb

@@ -203,6 +203,11 @@ module Discordrb::API
     "#{cdn_url}/splashes/#{server_id}/#{splash_id}.#{format}"
   end
 
+  # Make a discovery splash URL from server and splash IDs
+  def discovery_splash_url(server_id, splash_id, format = 'webp')
+    "#{cdn_url}/discovery-splashes/#{server_id}/#{splash_id}.#{format}"
+  end
+
   # Make a banner URL from server and banner IDs
   def banner_url(server_id, banner_id, format = 'webp')
     "#{cdn_url}/banners/#{server_id}/#{banner_id}.#{format}"
@@ -231,28 +236,19 @@ module Discordrb::API
     "#{cdn_url}/role-icons/#{role_id}/#{icon_hash}.#{format}"
   end
 
-  # Login to the server
-  def login(email, password)
-    request(
-      :auth_login,
-      nil,
-      :post,
-      "#{api_base}/auth/login",
-      email: email,
-      password: password
-    )
+  # make an avatar decoration URL from an avatar decoration ID.
+  def avatar_decoration_url(avatar_decoration_id, format = 'png')
+    "#{cdn_url}/avatar-decoration-presets/#{avatar_decoration_id}.#{format}"
   end
 
-  # Logout from the server
-  def logout(token)
-    request(
-      :auth_logout,
-      nil,
-      :post,
-      "#{api_base}/auth/logout",
-      nil,
-      Authorization: token
-    )
+  # make a nameplate URL from the nameplate asset.
+  def nameplate_url(nameplate_asset, format = 'webm')
+    "#{cdn_url}/assets/collectibles/#{nameplate_asset.delete_suffix('/')}/asset.#{format}"
+  end
+
+  # make a server tag badge URL from a server ID and badge ID.
+  def server_tag_badge_url(server_id, badge_id, format = 'webp')
+    "#{cdn_url}/guild-tag-badges/#{server_id}/#{badge_id}.#{format}"
   end
 
   # Create an OAuth application

data/lib/discordrb/bot.rb

@@ -2,7 +2,6 @@
 
 require 'rest-client'
 require 'zlib'
-require 'set'
 
 require 'discordrb/events/message'
 require 'discordrb/events/typing'
@@ -107,9 +106,10 @@ module Discordrb
     #   to Discord's gateway. `:none` will request that no payloads are received compressed (not recommended for
     #   production bots). `:large` will request that large payloads are received compressed. `:stream` will request
     #   that all data be received in a continuous compressed stream.
-    # @param intents [:all, :unprivileged, Array<Symbol>, :none] Gateway intents that this bot requires. `:all` will
+    # @param intents [:all, :unprivileged, Array<Symbol>, :none, Integer] Gateway intents that this bot requires. `:all` will
     #   request all intents. `:unprivileged` will request only intents that are not defined as "Privileged". `:none`
-    #   will request no intents. An array of symbols will request only those intents specified.
+    #   will request no intents. An array of symbols will request only those intents specified. An integer value will request
+    #   exactly all the intents specified in the bitwise value.
     # @see Discordrb::INTENTS
     def initialize(
       log_mode: :normal,
@@ -307,13 +307,21 @@ module Discordrb
     # Creates an OAuth invite URL that can be used to invite this bot to a particular server.
     # @param server [Server, nil] The server the bot should be invited to, or nil if a general invite should be created.
     # @param permission_bits [String, Integer] Permission bits that should be appended to invite url.
+    # @param redirect_uri [String] Redirect URI that should be appended to invite url.
+    # @param scopes [Array<String>] Scopes that should be appended to invite url.
     # @return [String] the OAuth invite URL.
-    def invite_url(server: nil, permission_bits: nil)
+    def invite_url(server: nil, permission_bits: nil, redirect_uri: nil, scopes: ['bot'])
       @client_id ||= bot_application.id
 
-      server_id_str = server ? "&guild_id=#{server.id}" : ''
-      permission_bits_str = permission_bits ? "&permissions=#{permission_bits}" : ''
-      "https://discord.com/oauth2/authorize?&client_id=#{@client_id}#{server_id_str}#{permission_bits_str}&scope=bot"
+      query = URI.encode_www_form({
+        client_id: @client_id,
+        guild_id: server&.id,
+        permissions: permission_bits,
+        redirect_uri: redirect_uri,
+        scope: scopes.join(' ')
+      }.compact)
+
+      "https://discord.com/oauth2/authorize?#{query}"
     end
 
     # @return [Hash<Integer => VoiceBot>] the voice connections this bot currently has, by the server ID to which they are connected.
@@ -392,17 +400,20 @@ module Discordrb
     # @param tts [true, false] Whether or not this message should be sent using Discord text-to-speech.
     # @param embeds [Hash, Discordrb::Webhooks::Embed, Array<Hash>, Array<Discordrb::Webhooks::Embed> nil] The rich embed(s) to append to this message.
     # @param allowed_mentions [Hash, Discordrb::AllowedMentions, false, nil] Mentions that are allowed to ping on this message. `false` disables all pings
-    # @param message_reference [Message, String, Integer, nil] The message, or message ID, to reply to if any.
+    # @param message_reference [Message, String, Integer, Hash, nil] The message, or message ID, to reply to if any.
     # @param components [View, Array<Hash>] Interaction components to associate with this message.
+    # @param flags [Integer] Flags for this message. Currently only SUPPRESS_EMBEDS (1 << 2), SUPPRESS_NOTIFICATIONS (1 << 12), and IS_COMPONENTS_V2 (1 << 15) can be set.
+    # @param nonce [String, nil] A optional nonce in order to verify that a message was sent. Maximum of twenty-five characters.
+    # @param enforce_nonce [true, false] whether the nonce should be enforced and used for message de-duplication.
     # @return [Message] The message that was sent.
-    def send_message(channel, content, tts = false, embeds = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil)
+    def send_message(channel, content, tts = false, embeds = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil, flags = 0, nonce = nil, enforce_nonce = false)
       channel = channel.resolve_id
       debug("Sending message to #{channel} with content '#{content}'")
       allowed_mentions = { parse: [] } if allowed_mentions == false
-      message_reference = { message_id: message_reference.id } if message_reference.respond_to?(:id)
+      message_reference = { message_id: message_reference.resolve_id } if message_reference.respond_to?(:resolve_id)
       embeds = (embeds.instance_of?(Array) ? embeds.map(&:to_hash) : [embeds&.to_hash]).compact
 
-      response = API::Channel.create_message(token, channel, content, tts, embeds, nil, attachments, allowed_mentions&.to_hash, message_reference, components)
+      response = API::Channel.create_message(token, channel, content, tts, embeds, nonce, attachments, allowed_mentions&.to_hash, message_reference, components, flags, enforce_nonce)
       Message.new(JSON.parse(response), self)
     end
 
@@ -417,11 +428,14 @@ module Discordrb
     # @param allowed_mentions [Hash, Discordrb::AllowedMentions, false, nil] Mentions that are allowed to ping on this message. `false` disables all pings
     # @param message_reference [Message, String, Integer, nil] The message, or message ID, to reply to if any.
     # @param components [View, Array<Hash>] Interaction components to associate with this message.
-    def send_temporary_message(channel, content, timeout, tts = false, embeds = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil)
+    # @param flags [Integer] Flags for this message. Currently only SUPPRESS_EMBEDS (1 << 2), SUPPRESS_NOTIFICATIONS (1 << 12), and IS_COMPONENTS_V2 (1 << 15) can be set.
+    # @param nonce [String, nil] A optional nonce in order to verify that a message was sent. Maximum of twenty-five characters.
+    # @param enforce_nonce [true, false] whether the nonce should be enforced and used for message de-duplication.
+    def send_temporary_message(channel, content, timeout, tts = false, embeds = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil, flags = 0, nonce = nil, enforce_nonce = false)
       Thread.new do
         Thread.current[:discordrb_name] = "#{@current_thread}-temp-msg"
 
-        message = send_message(channel, content, tts, embeds, attachments, allowed_mentions, message_reference, components)
+        message = send_message(channel, content, tts, embeds, attachments, allowed_mentions, message_reference, components, flags, nonce, enforce_nonce)
         sleep(timeout)
         message.delete
       end
@@ -455,20 +469,6 @@ module Discordrb
       Message.new(JSON.parse(response), self)
     end
 
-    # Creates a server on Discord with a specified name and a region.
-    # @note Discord's API doesn't directly return the server when creating it, so this method
-    #   waits until the data has been received via the websocket. This may make the execution take a while.
-    # @param name [String] The name the new server should have. Doesn't have to be alphanumeric.
-    # @param region [Symbol] The region where the server should be created, for example 'eu-central' or 'hongkong'.
-    # @return [Server] The server that was created.
-    def create_server(name, region = :'eu-central')
-      response = API::Server.create(token, name, region)
-      id = JSON.parse(response)['id'].to_i
-      sleep 0.1 until (server = @servers[id])
-      debug "Successfully created server #{server.id} with name #{server.name}"
-      server
-    end
-
     # Creates a new application to do OAuth authorization with. This allows you to use OAuth to authorize users using
     # Discord. For information how to use this, see the docs: https://discord.com/developers/docs/topics/oauth2
     # @param name [String] What your application should be called.
@@ -517,7 +517,7 @@ module Discordrb
             end
           end
         elsif /(?<animated>^a|^${0}):(?<name>\w+):(?<id>\d+)/ =~ mention
-          array_to_return << (emoji(id) || Emoji.new({ 'animated' => !animated.nil?, 'name' => name, 'id' => id }, self, nil))
+          array_to_return << (emoji(id) || Emoji.new({ 'animated' => animated != '', 'name' => name, 'id' => id }, self, nil))
         end
       end
       array_to_return
@@ -824,7 +824,7 @@ module Discordrb
     #       end
     #     end
     #   end
-    def register_application_command(name, description, server_id: nil, default_permission: nil, type: :chat_input)
+    def register_application_command(name, description, server_id: nil, default_permission: nil, type: :chat_input, default_member_permissions: nil, contexts: nil, nsfw: false)
       type = ApplicationCommand::TYPES[type] || type
 
       builder = Interactions::OptionBuilder.new
@@ -832,9 +832,9 @@ module Discordrb
       yield(builder, permission_builder) if block_given?
 
       resp = if server_id
-               API::Application.create_guild_command(@token, profile.id, server_id, name, description, builder.to_a, default_permission, type)
+               API::Application.create_guild_command(@token, profile.id, server_id, name, description, builder.to_a, default_permission, type, default_member_permissions, contexts, nsfw)
              else
-               API::Application.create_global_command(@token, profile.id, name, description, builder.to_a, default_permission, type)
+               API::Application.create_global_command(@token, profile.id, name, description, builder.to_a, default_permission, type, default_member_permissions, contexts, nsfw)
              end
       cmd = ApplicationCommand.new(JSON.parse(resp), self, server_id)
 
@@ -849,7 +849,7 @@ module Discordrb
 
     # @yieldparam [OptionBuilder]
     # @yieldparam [PermissionBuilder]
-    def edit_application_command(command_id, server_id: nil, name: nil, description: nil, default_permission: nil, type: :chat_input)
+    def edit_application_command(command_id, server_id: nil, name: nil, description: nil, default_permission: nil, type: :chat_input, default_member_permissions: nil, contexts: nil, nsfw: nil)
       type = ApplicationCommand::TYPES[type] || type
 
       builder = Interactions::OptionBuilder.new
@@ -858,9 +858,9 @@ module Discordrb
       yield(builder, permission_builder) if block_given?
 
       resp = if server_id
-               API::Application.edit_guild_command(@token, profile.id, server_id, command_id, name, description, builder.to_a, default_permission, type)
+               API::Application.edit_guild_command(@token, profile.id, server_id, command_id, name, description, builder.to_a, default_permission, type, default_member_permissions, contexts, nsfw)
              else
-               API::Application.edit_guild_command(@token, profile.id, command_id, name, description, builder.to_a, default_permission.type)
+               API::Application.edit_global_command(@token, profile.id, command_id, name, description, builder.to_a, default_permission, type, default_member_permissions, contexts, nsfw)
              end
       cmd = ApplicationCommand.new(JSON.parse(resp), self, server_id)
 
@@ -895,6 +895,46 @@ module Discordrb
       API::Application.edit_guild_command_permissions(@token, profile.id, server_id, command_id, permissions)
     end
 
+    # Fetches all the application emojis that the bot can use.
+    # @return [Array<Emoji>] Returns an array of emoji objects.
+    def application_emojis
+      response = API::Application.list_application_emojis(@token, profile.id)
+      JSON.parse(response)['items'].map { |emoji| Emoji.new(emoji, self) }
+    end
+
+    # Fetches a single application emoji from its ID.
+    # @param emoji_id [Integer, String] ID of the application emoji.
+    # @return [Emoji] The application emoji.
+    def application_emoji(emoji_id)
+      response = API::Application.get_application_emoji(@token, profile.id, emoji_id.resolve_id)
+      Emoji.new(JSON.parse(response), self)
+    end
+
+    # Creates a new custom emoji that can be used by this application.
+    # @param name [String] The name of emoji to create.
+    # @param image [String, #read] Base64 string with the image data, or an object that responds to #read.
+    # @return [Emoji] The emoji that has been created.
+    def create_application_emoji(name:, image:)
+      image = image.respond_to?(:read) ? Discordrb.encode64(image) : image
+      response = API::Application.create_application_emoji(@token, profile.id, name, image)
+      Emoji.new(JSON.parse(response), self)
+    end
+
+    # Edits an existing application emoji.
+    # @param emoji_id [Integer, String, Emoji] ID of the application emoji to edit.
+    # @param name [String] The new name of the emoji.
+    # @return [Emoji] Returns the updated emoji object on success.
+    def edit_application_emoji(emoji_id, name:)
+      response = API::Application.edit_application_emoji(@token, profile.id, emoji_id.resolve_id, name)
+      Emoji.new(JSON.parse(response), self)
+    end
+
+    # Deletes an existing application emoji.
+    # @param emoji_id [Integer, String, Emoji] ID of the application emoji to delete.
+    def delete_application_emoji(emoji_id)
+      API::Application.delete_application_emoji(@token, profile.id, emoji_id.resolve_id)
+    end
+
     private
 
     # Throws a useful exception if there's currently no gateway connection.
@@ -1091,12 +1131,12 @@ module Discordrb
       server_id = data['guild_id'].to_i
       server = self.server(server_id)
 
-      member = server.member(data['user']['id'].to_i)
-      member.update_roles(data['roles'])
-      member.update_nick(data['nick'])
-      member.update_global_name(data['user']['global_name']) if data['user']['global_name']
-      member.update_boosting_since(data['premium_since'])
-      member.update_communication_disabled_until(data['communication_disabled_until'])
+      # Only attempt to update members that're already cached
+      if (member = server.member(data['user']['id'].to_i, false))
+        member.update_data(data)
+      else
+        ensure_user(data['user'])
+      end
     end
 
     # Internal handler for GUILD_MEMBER_DELETE
@@ -1212,7 +1252,7 @@ module Discordrb
 
     def handle_dispatch(type, data)
       # Check whether there are still unavailable servers and there have been more than 10 seconds since READY
-      if @unavailable_servers&.positive? && (Time.now - @unavailable_timeout_time) > 10 && !((@intents || 0) & INTENTS[:servers]).zero?
+      if @unavailable_servers&.positive? && (Time.now - @unavailable_timeout_time) > 10 && !(@intents || 0).nobits?(INTENTS[:servers])
         # The server streaming timed out!
         LOGGER.debug("Server streaming timed out with #{@unavailable_servers} servers remaining")
         LOGGER.debug('Calling ready now because server loading is taking a long time. Servers may be unavailable due to an outage, or your bot is on very large servers.')
@@ -1232,6 +1272,8 @@ module Discordrb
 
         @profile = Profile.new(data['user'], self)
 
+        @client_id ||= data['application']['id']&.to_i
+
         # Initialize servers
         @servers = {}
 
@@ -1274,6 +1316,8 @@ module Discordrb
         id = data['guild_id'].to_i
         server = server(id)
         server.process_chunk(data['members'], data['chunk_index'], data['chunk_count'])
+      when :USER_UPDATE
+        @profile = Profile.new(data, self)
       when :INVITE_CREATE
         invite = Invite.new(data, self)
         raise_event(InviteCreateEvent.new(data, invite, self))
@@ -1290,12 +1334,22 @@ module Discordrb
           return
         end
 
+        if !should_parse_self && profile.id == data['author']['id'].to_i
+          debug('Ignored message from the current bot')
+          return
+        end
+
         # If create_message is overwritten with a method that returns the parsed message, use that instead, so we don't
         # parse the message twice (which is just thrown away performance)
         message = create_message(data)
         message = Message.new(data, self) unless message.is_a? Message
 
-        return if message.from_bot? && !should_parse_self
+        # Update the existing member if it exists in the cache.
+        if data['member']
+          member = message.channel.server&.member(data['author']['id'].to_i, false)
+          data['member']['user'] = data['author']
+          member&.update_data(data['member'])
+        end
 
         # Dispatch a ChannelCreateEvent for channels we don't have cached
         if message.channel.private? && @pm_channels[message.channel.recipient.id].nil?
@@ -1319,18 +1373,28 @@ module Discordrb
       when :MESSAGE_UPDATE
         update_message(data)
 
+        if !should_parse_self && profile.id == data['author']['id'].to_i
+          debug('Ignored message from the current bot')
+          return
+        end
+
         message = Message.new(data, self)
 
         event = MessageUpdateEvent.new(message, self)
         raise_event(event)
 
-        return if message.from_bot? && !should_parse_self
-
-        unless message.author
+        if data['author'].nil?
           LOGGER.debug("Edited a message with nil author! Content: #{message.content.inspect}, channel: #{message.channel.inspect}")
           return
         end
 
+        # Update the existing member if it exists in the cache.
+        if data['member']
+          member = message.channel.server&.member(data['author']['id'].to_i, false)
+          data['member']['user'] = data['author']
+          member&.update_data(data['member'])
+        end
+
         event = MessageEditEvent.new(message, self)
         raise_event(event)
       when :MESSAGE_DELETE
@@ -1368,6 +1432,12 @@ module Discordrb
 
         return if profile.id == data['user_id'].to_i && !should_parse_self
 
+        if data['member']
+          server = self.server(data['guild_id'].to_i)
+
+          server&.cache_member(Member.new(data['member'], server, self))
+        end
+
         event = ReactionAddEvent.new(data, self)
         raise_event(event)
       when :MESSAGE_REACTION_REMOVE
@@ -1442,6 +1512,12 @@ module Discordrb
         remove_recipient(data)
 
         event = ChannelRecipientRemoveEvent.new(data, self)
+        raise_event(event)
+      when :CHANNEL_PINS_UPDATE
+        event = ChannelPinsUpdateEvent.new(data, self)
+
+        event.channel.process_last_pin_timestamp(data['last_pin_timestamp']) if data.key?('last_pin_timestamp')
+
         raise_event(event)
       when :GUILD_MEMBER_ADD
         add_guild_member(data)
@@ -1544,6 +1620,10 @@ module Discordrb
           event = ServerEmojiUpdateEvent.new(server, old_emoji_data[e], new_emoji_data[e], self)
           raise_event(event)
         end
+      when :APPLICATION_COMMAND_PERMISSIONS_UPDATE
+        event = ApplicationCommandPermissionsUpdateEvent.new(data, self)
+
+        raise_event(event)
       when :INTERACTION_CREATE
         event = InteractionCreateEvent.new(data, self)
         raise_event(event)
@@ -1552,13 +1632,13 @@ module Discordrb
         when Interaction::TYPES[:command]
           event = ApplicationCommandEvent.new(data, self)
 
-          Thread.new do
-            Thread.current[:discordrb_name] = "it-#{event.interaction.id}"
+          Thread.new(event) do |evt|
+            Thread.current[:discordrb_name] = "it-#{evt.interaction.id}"
 
             begin
-              debug("Executing application command #{event.command_name}:#{event.command_id}")
+              debug("Executing application command #{evt.command_name}:#{evt.command_id}")
 
-              @application_commands[event.command_name]&.call(event)
+              @application_commands[evt.command_name]&.call(evt)
             rescue StandardError => e
               log_exception(e)
             end
@@ -1594,6 +1674,10 @@ module Discordrb
 
           event = ModalSubmitEvent.new(data, self)
           raise_event(event)
+        when Interaction::TYPES[:autocomplete]
+
+          event = AutocompleteEvent.new(data, self)
+          raise_event(event)
         end
       when :WEBHOOKS_UPDATE
         event = WebhookUpdateEvent.new(data, self)
@@ -1673,15 +1757,15 @@ module Discordrb
     end
 
     def call_event(handler, event)
-      t = Thread.new do
+      t = Thread.new(event) do |evt|
         @event_threads ||= []
         @current_thread ||= 0
 
         @event_threads << t
         Thread.current[:discordrb_name] = "et-#{@current_thread += 1}"
         begin
-          handler.call(event)
-          handler.after_call(event)
+          handler.call(evt)
+          handler.after_call(evt)
         rescue StandardError => e
           log_exception(e)
         ensure
@@ -1692,7 +1776,7 @@ module Discordrb
 
     def handle_awaits(event)
       @awaits ||= {}
-      @awaits.each do |_, await|
+      @awaits.each_value do |await|
         key, should_delete = await.match(event)
         next unless key
 
@@ -1705,6 +1789,8 @@ module Discordrb
     end
 
     def calculate_intents(intents)
+      intents = [intents] unless intents.is_a? Array
+
       intents.reduce(0) do |sum, intent|
         case intent
         when Symbol

data/lib/discordrb/cache.rb

@@ -22,6 +22,7 @@ module Discordrb
       @channels = {}
       @pm_channels = {}
       @thread_members = {}
+      @server_previews = {}
     end
 
     # Returns or caches the available voice regions
@@ -134,6 +135,19 @@ module Discordrb
 
     alias_method :private_channel, :pm_channel
 
+    # Get a server preview. If the bot isn't a member of the server, the server must be discoverable.
+    # @param id [Integer, String, Server] the ID of the server preview to get.
+    # @return [ServerPreview, nil] the server preview, or `nil` if the server isn't accessible.
+    def server_preview(id)
+      id = id.resolve_id
+      return @server_previews[id] if @server_previews[id]
+
+      response = JSON.parse(API::Server.preview(token, id))
+      @server_previews[id] = ServerPreview.new(response, self)
+    rescue StandardError
+      nil
+    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.
@@ -199,7 +213,7 @@ module Discordrb
     # @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..] if invite.start_with?('http', 'discord.gg')
+      invite = invite[(invite.rindex('/') + 1)..] if invite.start_with?('http', 'discord.gg')
       invite
     end
 

data/lib/discordrb/commands/command_bot.rb

@@ -109,7 +109,7 @@ module Discordrb::Commands
         spaces_allowed: attributes[:spaces_allowed].nil? ? false : attributes[:spaces_allowed],
 
         # Webhooks allowed to trigger commands
-        webhook_commands: attributes[:webhook_commands].nil? ? true : attributes[:webhook_commands],
+        webhook_commands: attributes[:webhook_commands].nil? || attributes[:webhook_commands],
 
         channels: attributes[:channels] || [],
 
@@ -153,7 +153,9 @@ module Discordrb::Commands
             command = command.aliased_command
             command_name = command.name
           end
+          # rubocop:disable Lint/ReturnInVoidContext
           return "The command `#{command_name}` does not exist!" unless command
+          # rubocop:enable Lint/ReturnInVoidContext
 
           desc = command.attributes[:description] || '*No description available*'
           usage = command.attributes[:usage]
@@ -257,24 +259,16 @@ module Discordrb::Commands
         next arg if types[i].nil? || types[i] == String
 
         if types[i] == Integer
-          begin
-            Integer(arg, 10)
-          rescue ArgumentError
-            nil
-          end
+          Integer(arg, 10, exception: false)
         elsif types[i] == Float
-          begin
-            Float(arg)
-          rescue ArgumentError
-            nil
-          end
+          Float(arg, exception: false)
         elsif types[i] == Time
           begin
             Time.parse arg
           rescue ArgumentError
             nil
           end
-        elsif types[i] == TrueClass || types[i] == FalseClass
+        elsif [TrueClass, FalseClass].include?(types[i])
           if arg.casecmp('true').zero? || arg.downcase.start_with?('y')
             true
           elsif arg.casecmp('false').zero? || arg.downcase.start_with?('n')
@@ -295,11 +289,7 @@ module Discordrb::Commands
             nil
           end
         elsif types[i] == Rational
-          begin
-            Rational(arg)
-          rescue ArgumentError
-            nil
-          end
+          Rational(arg, exception: false)
         elsif types[i] == Range
           begin
             if arg.include? '...'

data/lib/discordrb/commands/parser.rb

@@ -32,10 +32,10 @@ module Discordrb::Commands
         channels: attributes[:channels] || nil,
 
         # Whether this command is usable in a command chain
-        chain_usable: attributes[:chain_usable].nil? ? true : attributes[:chain_usable],
+        chain_usable: attributes[:chain_usable].nil? || attributes[:chain_usable],
 
         # Whether this command should show up in the help command
-        help_available: attributes[:help_available].nil? ? true : attributes[:help_available],
+        help_available: attributes[:help_available].nil? || attributes[:help_available],
 
         # Description (for help command)
         description: attributes[:description] || nil,
@@ -159,7 +159,7 @@ module Discordrb::Commands
       escaped = false
       hacky_delim, hacky_space, hacky_prev, hacky_newline = [0xe001, 0xe002, 0xe003, 0xe004].pack('U*').chars
 
-      @chain.each_char.each_with_index do |char, index|
+      @chain.each_char.with_index do |char, index|
         # Escape character
         if char == '\\' && !escaped
           escaped = true
@@ -211,7 +211,7 @@ module Discordrb::Commands
         b_level -= 1
         next unless b_level.zero?
 
-        nested = @chain[b_start + 1..index - 1]
+        nested = @chain[(b_start + 1)..(index - 1)]
         subchain = CommandChain.new(nested, @bot, true)
         result += subchain.execute(event)
       end
@@ -245,8 +245,8 @@ module Discordrb::Commands
         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..] : ''
+        command_name = first_space ? command[0..(first_space - 1)] : command
+        arguments = first_space ? command[(first_space + 1)..] : ''
 
         # Append a previous sign if none is present
         arguments += @attributes[:previous] unless arguments.include? @attributes[:previous]
@@ -318,7 +318,7 @@ module Discordrb::Commands
           arg.split ' '
         end
 
-        chain = chain[chain_args_index + 1..]
+        chain = chain[(chain_args_index + 1)..]
       end
 
       [chain_args, chain]