onyxcord 2.0.13 → 3.2.0

data/lib/onyxcord/{cache.rb → cache/manager.rb}

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 require 'lru_redux'
-require 'onyxcord/api'
-require 'onyxcord/api/server'
-require 'onyxcord/api/invite'
-require 'onyxcord/api/user'
-require 'onyxcord/configuration'
-require 'onyxcord/data'
+require 'onyxcord/rest/client'
+require 'onyxcord/rest/routes/server'
+require 'onyxcord/rest/routes/invite'
+require 'onyxcord/rest/routes/user'
+require 'onyxcord/core/configuration'
+require 'onyxcord/models'
 
 module OnyxCord
   # This mixin module does caching stuff for the library. It conveniently separates the logic behind
@@ -73,7 +73,7 @@ module OnyxCord
     def fetch_voice_regions
       regions_by_id = {}
 
-      regions = JSON.parse API.voice_regions(token)
+      regions = JSON.parse REST.voice_regions(token)
       regions.each do |data|
         regions_by_id[data['id']] = VoiceRegion.new(data)
       end
@@ -95,7 +95,7 @@ module OnyxCord
       return @channels[id] if @channels&.[](id)
 
       begin
-        response = API::Channel.resolve(token, id)
+        response = REST::Channel.resolve(token, id)
       rescue OnyxCord::Errors::UnknownChannel
         return nil
       end
@@ -116,7 +116,7 @@ module OnyxCord
 
       LOGGER.out("Resolving user #{id}")
       begin
-        response = API::User.resolve(token, id)
+        response = REST::User.resolve(token, id)
       rescue OnyxCord::Errors::UnknownUser
         return nil
       end
@@ -135,7 +135,7 @@ module OnyxCord
 
       LOGGER.out("Resolving server #{id}")
       begin
-        response = API::Server.resolve(token, id)
+        response = REST::Server.resolve(token, id)
       rescue OnyxCord::Errors::NoPermission
         return nil
       end
@@ -157,7 +157,7 @@ module OnyxCord
 
       LOGGER.out("Resolving member #{server_id} on server #{user_id}")
       begin
-        response = API::Server.resolve_member(token, server_id, user_id)
+        response = REST::Server.resolve_member(token, server_id, user_id)
       rescue OnyxCord::Errors::UnknownUser, OnyxCord::Errors::UnknownMember
         return nil
       end
@@ -175,7 +175,7 @@ module OnyxCord
       return @pm_channels[id] if @pm_channels&.[](id)
 
       debug("Creating pm channel with user id #{id}")
-      response = API::User.create_pm(token, id)
+      response = REST::User.create_pm(token, id)
       channel = Channel.new(JSON.parse(response), self)
       @pm_channels[id] = channel if cache_enabled?(:pm_channels)
       channel
@@ -190,7 +190,7 @@ module OnyxCord
       id = id.resolve_id
       return @server_previews[id] if @server_previews&.[](id)
 
-      response = JSON.parse(API::Server.preview(token, id))
+      response = JSON.parse(REST::Server.preview(token, id))
       preview = ServerPreview.new(response, self)
       @server_previews[id] = preview if cache_enabled?(:server_previews)
       preview
@@ -301,7 +301,7 @@ module OnyxCord
     # @return [Invite] The invite with information about the given invite URL.
     def invite(invite)
       code = resolve_invite_code(invite)
-      Invite.new(JSON.parse(API::Invite.resolve(token, code)), self)
+      Invite.new(JSON.parse(REST::Invite.resolve(token, code)), self)
     end
 
     # Finds a channel given its name and optionally the name of the server it is in.
@@ -352,3 +352,5 @@ module OnyxCord
     end
   end
 end
+
+require 'onyxcord/cache/stores/gateway'

data/lib/onyxcord/cache/stores/gateway.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  module Cache
+    module Stores
+      module Gateway
+        private
+
+        # Internal handler for PRESENCE_UPDATE
+        def update_presence(data)
+          # Friends list presences have no server ID so ignore these to not cause an error
+          return unless data['guild_id']
+
+          user_id = data['user']['id'].to_i
+          server_id = data['guild_id'].to_i
+          server = server(server_id)
+          return unless server
+
+          member_is_new = false
+
+          if server.member_cached?(user_id)
+            member = server.member(user_id)
+          else
+            # If the member is not cached yet, it means that it just came online from not being cached at all
+            # due to large_threshold. Fortunately, Discord sends the entire member object in this case, and
+            # not just a part of it - we can just cache this member directly
+            member = Member.new(data, server, self)
+            debug("Implicitly adding presence-obtained member #{user_id} to #{server_id} cache")
+
+            member_is_new = true
+          end
+
+          username = data['user']['username']
+          if username && !member_is_new # Don't set the username for newly-cached members
+            debug "Implicitly updating presence-obtained information username for member #{user_id}"
+            member.update_username(username)
+          end
+
+          global_name = data['user']['global_name']
+          if global_name && !member_is_new # Don't set the global_name for newly-cached members
+            debug "Implicitly updating presence-obtained information global_name for member #{user_id}"
+            member.update_global_name(global_name)
+          end
+
+          member.update_presence(data)
+
+          member.avatar_id = data['user']['avatar'] if data['user']['avatar']
+
+          server.cache_member(member)
+        end
+
+        # Internal handler for VOICE_STATE_UPDATE
+        def update_voice_state(data)
+          @session_id = data['session_id']
+
+          server_id = data['guild_id'].to_i
+          server = @servers&.[](server_id)
+          return unless server
+
+          user_id = data['user_id'].to_i
+          old_voice_state = server.voice_states[user_id]
+          old_channel_id = old_voice_state&.channel_id || old_voice_state&.voice_channel&.id
+
+          server.update_voice_state(data)
+
+          existing_voice = @voices[server_id]
+          if user_id == @profile.id && existing_voice
+            new_channel_id = data['channel_id']
+            if new_channel_id
+              channel_id = new_channel_id.to_i
+              new_channel = @channels&.[](channel_id) || server.channels.find { |channel| channel.id == channel_id }
+              existing_voice.channel = new_channel
+            else
+              voice_destroy(server_id)
+            end
+          end
+
+          old_channel_id
+        end
+
+        # Internal handler for VOICE_SERVER_UPDATE
+        def update_voice_server(data)
+          server_id = data['guild_id'].to_i
+          channel = @should_connect_to_voice[server_id]
+
+          debug("Voice server update received! chan: #{channel.inspect}")
+          return unless channel
+
+          @should_connect_to_voice.delete(server_id)
+          debug('Updating voice server!')
+
+          token = data['token']
+          endpoint = data['endpoint']
+
+          unless endpoint
+            debug('VOICE_SERVER_UPDATE sent with nil endpoint! Ignoring')
+            return
+          end
+
+          debug('Got data, now creating the bot.')
+          @voices[server_id] = OnyxCord::Voice::Client.new(channel, self, token, @session_id, endpoint)
+        end
+
+        # Internal handler for CHANNEL_CREATE
+        def create_channel(data)
+          channel = data.is_a?(OnyxCord::Channel) ? data : Channel.new(data, self)
+          server = channel.server
+
+          # The last message ID of a forum channel is the most recent post
+          channel.parent.process_last_message_id(channel.id) if channel.parent&.forum? || channel.parent&.media?
+
+          # Handle normal and private channels separately
+          if server
+            server.add_channel(channel)
+            @channels[channel.id] = channel if @channels
+          elsif channel.private?
+            @pm_channels[channel.recipient.id] = channel if @pm_channels
+          elsif channel.group?
+            @channels[channel.id] = channel if @channels
+          end
+        end
+
+        # Internal handler for CHANNEL_UPDATE
+        def update_channel(data)
+          @channels&.[](data['id'].to_i)&.update_data(data)
+        end
+
+        # Internal handler for CHANNEL_DELETE
+        def delete_channel(data)
+          channel = Channel.new(data, self)
+          server = channel.server
+
+          # Handle normal and private channels separately
+          if server
+            @channels&.delete(channel.id)
+            server.delete_channel(channel.id)
+          elsif channel.pm?
+            @pm_channels&.delete(channel.recipient.id)
+          elsif channel.group?
+            @channels&.delete(channel.id)
+          end
+
+          @thread_members&.delete(channel.id) if channel.thread?
+        end
+
+        # Internal handler for GUILD_MEMBER_ADD
+        def add_guild_member(data)
+          server_id = data['guild_id'].to_i
+          server = self.server(server_id)
+
+          member = Member.new(data, server, self)
+          server.add_member(member)
+        end
+
+        # Internal handler for GUILD_MEMBER_UPDATE
+        def update_guild_member(data)
+          server_id = data['guild_id'].to_i
+          server = self.server(server_id)
+
+          # 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
+        def delete_guild_member(data)
+          server_id = data['guild_id'].to_i
+          server = self.server(server_id)
+          return unless server
+
+          user_id = data['user']['id'].to_i
+          server.delete_member(user_id)
+        rescue OnyxCord::Errors::NoPermission
+          OnyxCord::LOGGER.warn("delete_guild_member attempted to access a server for which the bot doesn't have permission! Not sure what happened here, ignoring")
+        end
+
+        # Internal handler for GUILD_CREATE
+        def create_guild(data)
+          ensure_server(data, true)
+        end
+
+        # Internal handler for GUILD_UPDATE
+        def update_guild(data)
+          server_id = data['id'].to_i
+          server = @servers&.[](server_id)
+
+          if server
+            server.update_data(data)
+          else
+            LOGGER.warn("GUILD_UPDATE received for uncached server #{server_id}; caching from payload")
+            ensure_server(data, true)
+          end
+        end
+
+        # Internal handler for GUILD_DELETE
+        def delete_guild(data)
+          id = data['id'].to_i
+          @servers.delete(id)
+        end
+
+        # Internal handler for GUILD_ROLE_CREATE and GUILD_ROLE_UPDATE
+        def update_guild_role(data)
+          server = @servers[data['guild_id'].to_i]
+
+          if (role = server&.role(data['role']['id'].to_i))
+            role.update_data(data['role'])
+          else
+            server&.add_role(Role.new(data['role'], self, server))
+          end
+        end
+
+        # Internal handler for GUILD_ROLE_DELETE
+        def delete_guild_role(data)
+          role_id = data['role_id'].to_i
+          server_id = data['guild_id'].to_i
+          server = @servers[server_id]
+          server&.delete_role(role_id)
+        end
+
+        # Internal handler for GUILD_EMOJIS_UPDATE
+        def update_guild_emoji(data)
+          server_id = data['guild_id'].to_i
+          server = @servers[server_id]
+          server&.update_emoji_data(data)
+        end
+
+        # Internal handler for GUILD_SCHEDULED_EVENT_CREATE and GUILD_SCHEDULED_EVENT_UPDATE
+        def update_guild_scheduled_event(data)
+          server = @servers[data['guild_id'].to_i]
+
+          if (event = server&.scheduled_event(data['id'].to_i, request: false))
+            event&.update_data(data)
+          else
+            server&.cache_scheduled_event(ScheduledEvent.new(data, server, self))
+          end
+        end
+
+        # Internal handler for MESSAGE_CREATE
+        def create_message(data); end
+
+        # Internal handler for TYPING_START
+        def start_typing(data); end
+
+        # Internal handler for MESSAGE_UPDATE
+        def update_message(data); end
+
+        # Internal handler for MESSAGE_DELETE
+        def delete_message(data); end
+
+        # Internal handler for MESSAGE_REACTION_ADD
+        def add_message_reaction(data); end
+
+        # Internal handler for MESSAGE_REACTION_REMOVE
+        def remove_message_reaction(data); end
+
+        # Internal handler for MESSAGE_REACTION_REMOVE_ALL
+        def remove_all_message_reactions(data); end
+
+        # Internal handler for GUILD_BAN_ADD
+        def add_user_ban(data); end
+
+        # Internal handler for GUILD_BAN_REMOVE
+        def remove_user_ban(data); end
+      end
+    end
+
+    include Stores::Gateway
+  end
+end

data/lib/onyxcord/commands/bot/channels.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class OnyxCord::Commands::Bot
+  module Channels
+    # @see Commands::Bot#update_channels
+    def channels=(channels)
+      update_channels(channels)
+    end
+
+    # Update the list of channels the bot accepts commands from.
+    # @param channels [Array<String, Integer, Channel>] The channels this command bot accepts commands on.
+
+    def update_channels(channels = [])
+      @attributes[:channels] = Array(channels)
+    end
+
+    # Add a channel to the list of channels the bot accepts commands from.
+    # @param channel [String, Integer, Channel] The channel name, integer ID, or `Channel` object to be added
+
+    def add_channel(channel)
+      return if @attributes[:channels].find { |c| channel.resolve_id == c.resolve_id }
+
+      @attributes[:channels] << channel
+    end
+
+    # Remove a channel from the list of channels the bot accepts commands from.
+    # @param channel [String, Integer, Channel] The channel name, integer ID, or `Channel` object to be removed
+
+    def remove_channel(channel)
+      @attributes[:channels].delete_if { |c| channel.resolve_id == c.resolve_id }
+    end
+
+    private
+
+    # Internal handler for MESSAGE_CREATE that is overwritten to allow for command handling
+
+    def channels?(channel, channels)
+      return true if channels.nil? || channels.empty?
+
+      channels.any? do |c|
+        # if c is string, make sure to remove the "#" from channel names in case it was specified
+        return true if c.is_a?(String) && c.delete('#') == channel.name
+
+        c.resolve_id == channel.resolve_id
+      end
+    end
+  end
+end

data/lib/onyxcord/commands/bot/execution.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+class OnyxCord::Commands::Bot
+  module Execution
+    # Returns all aliases for the command with the given name
+    # @param name [Symbol] the name of the `Command`
+    # @return [Array<CommandAlias>]
+    def command_aliases(name)
+      commands.values.select do |command|
+        command.is_a?(OnyxCord::Commands::CommandAlias) && command.aliased_command.name == name
+      end
+    end
+
+    # Executes a particular command on the bot. Mostly useful for internal stuff, but one can never know.
+    # @param name [Symbol] The command to execute.
+    # @param event [CommandEvent] The event to pass to the command.
+    # @param arguments [Array<String>] The arguments to pass to the command.
+    # @param chained [true, false] Whether or not it should be executed as part of a command chain. If this is false,
+    #   commands that have chain_usable set to false will not work.
+    # @param check_permissions [true, false] Whether permission parameters such as `required_permission` or
+    #   `permission_level` should be checked.
+    # @return [String, nil] the command's result, if there is any.
+
+    def execute_command(name, event, arguments, chained = false, check_permissions = true)
+      debug("Executing command #{name} with arguments #{arguments}")
+      return unless @commands
+
+      command = @commands[name]
+      command = command.aliased_command if command.is_a?(OnyxCord::Commands::CommandAlias)
+      return unless !check_permissions || channels?(event.channel, @attributes[:channels]) ||
+                    (command && !command.attributes[:channels].nil?)
+
+      unless command
+        if @attributes[:command_doesnt_exist_message]
+          message = @attributes[:command_doesnt_exist_message]
+          message = message.call(event) if message.respond_to?(:call)
+          event.respond message.gsub('%command%', name.to_s) if message
+        end
+        return
+      end
+      return unless !check_permissions || channels?(event.channel, command.attributes[:channels])
+
+      arguments = arg_check(arguments, command.attributes[:arg_types], event.server) if check_permissions
+      if (check_permissions &&
+         permission?(event.author, command.attributes[:permission_level], event.server) &&
+         required_permissions?(event.author, command.attributes[:required_permissions], event.channel) &&
+         required_roles?(event.author, command.attributes[:required_roles]) &&
+         allowed_roles?(event.author, command.attributes[:allowed_roles])) ||
+         !check_permissions
+        event.command = command
+        result = command.call(event, arguments, chained, check_permissions)
+        stringify(result)
+      else
+        event.respond command.attributes[:permission_message].gsub('%name%', name.to_s) if command.attributes[:permission_message]
+        nil
+      end
+    rescue OnyxCord::Errors::NoPermission
+      event.respond @attributes[:no_permission_message] unless @attributes[:no_permission_message].nil?
+      raise
+    end
+
+    # Transforms an array of string arguments based on types array.
+    # For example, `['1', '10..14']` with types `[Integer, Range]` would turn into `[1, 10..14]`.
+
+    def arg_check(args, types = nil, server = nil)
+      return args unless types
+
+      args.each_with_index.map do |arg, i|
+        next arg if types[i].nil? || types[i] == String
+
+        if types[i] == Integer
+          Integer(arg, 10, exception: false)
+        elsif types[i] == Float
+          Float(arg, exception: false)
+        elsif types[i] == Time
+          begin
+            Time.parse arg
+          rescue ArgumentError
+            nil
+          end
+        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')
+            false
+          end
+        elsif types[i] == Symbol
+          arg.to_sym
+        elsif types[i] == Encoding
+          begin
+            Encoding.find arg
+          rescue ArgumentError
+            nil
+          end
+        elsif types[i] == Regexp
+          begin
+            Regexp.new arg
+          rescue ArgumentError
+            nil
+          end
+        elsif types[i] == Rational
+          Rational(arg, exception: false)
+        elsif types[i] == Range
+          begin
+            if arg.include? '...'
+              Range.new(*arg.split('...').map(&:to_i), true)
+            elsif arg.include? '..'
+              Range.new(*arg.split('..').map(&:to_i))
+            end
+          rescue ArgumentError
+            nil
+          end
+        elsif types[i] == NilClass
+          nil
+        elsif [OnyxCord::User, OnyxCord::Role, OnyxCord::Emoji].include? types[i]
+          result = parse_mention arg, server
+          result if result.instance_of? types[i]
+        elsif types[i] == OnyxCord::Invite
+          resolve_invite_code arg
+        elsif types[i].respond_to?(:from_argument)
+          begin
+            types[i].from_argument arg
+          rescue StandardError
+            nil
+          end
+        else
+          raise ArgumentError, "#{types[i]} doesn't implement from_argument"
+        end
+      end
+    end
+
+    # Executes a command in a simple manner, without command chains or permissions.
+    # @param chain [String] The command with its arguments separated by spaces.
+    # @param event [CommandEvent] The event to pass to the command.
+    # @return [String, nil] the command's result, if there is any.
+
+    def simple_execute(chain, event)
+      return nil if chain.empty?
+
+      args = chain.split(' ')
+      execute_command(args[0].to_sym, event, args[1..])
+    end
+
+    # Sets the permission level of a user
+    # @param id [Integer] the ID of the user whose level to set
+    # @param level [Integer] the level to set the permission to
+
+    private
+
+    def execute_chain(chain, event)
+      Async do
+        debug("Parsing command chain #{chain}")
+        result = @attributes[:advanced_functionality] ? OnyxCord::Commands::CommandChain.new(chain, self).execute(event) : simple_execute(chain, event)
+        result = event.drain_into(result)
+
+        if event.file
+          event.send_file(event.file, caption: result)
+        else
+          event.respond result unless result.nil? || result.empty?
+        end
+      rescue StandardError => e
+        log_exception(e)
+      end
+    end
+
+    # Turns the object into a string, using to_s by default
+
+    def stringify(object)
+      return '' if object.is_a? OnyxCord::Message
+
+      object.to_s
+    end
+  end
+end

data/lib/onyxcord/commands/bot/message_dispatch.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+class OnyxCord::Commands::Bot
+  module MessageDispatch
+    private
+
+    # Internal handler for MESSAGE_CREATE that is overwritten to allow for command handling
+    def create_message(data)
+      message = OnyxCord::Message.new(data, self)
+      return message if message.from_bot? && !@should_parse_self
+      return message if message.webhook? && !@attributes[:webhook_commands]
+
+      unless message.author
+        OnyxCord::LOGGER.warn("Received a message (#{message.inspect}) with nil author! Ignoring, please report this if you can")
+        return
+      end
+
+      event = OnyxCord::Commands::CommandEvent.new(message, self)
+
+      chain = trigger?(message)
+      return message unless chain
+
+      # Don't allow spaces between the prefix and the command
+      if chain.start_with?(' ') && !@attributes[:spaces_allowed]
+        debug('Chain starts with a space')
+        return message
+      end
+
+      if chain.strip.empty?
+        debug('Chain is empty')
+        return message
+      end
+
+      execute_chain(chain, event)
+
+      # Return the message so it doesn't get parsed again during the rest of the dispatch handling
+      message
+    end
+
+    # Check whether a message should trigger command execution, and if it does, return the raw chain
+
+    def trigger?(message)
+      if @prefix.is_a? String
+        standard_prefix_trigger(message.content, @prefix)
+      elsif @prefix.is_a? Array
+        @prefix.map { |e| standard_prefix_trigger(message.content, e) }.reduce { |m, e| m || e }
+      elsif @prefix.respond_to? :call
+        @prefix.call(message)
+      end
+    end
+
+    def standard_prefix_trigger(message, prefix)
+      return nil unless message.start_with? prefix
+
+      message[prefix.length..]
+    end
+  end
+end