onyxcord 1.1.0

data/lib/onyxcord/id_object.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  # Mixin for objects that have IDs
+  module IDObject
+    # @return [Integer] the ID which uniquely identifies this object across Discord.
+    attr_reader :id
+    alias_method :resolve_id, :id
+    alias_method :hash, :id
+
+    # ID based comparison
+    def ==(other)
+      OnyxCord.id_compare?(@id, other)
+    end
+
+    alias_method :eql?, :==
+
+    # Estimates the time this object was generated on based on the beginning of the ID. This is fairly accurate but
+    # shouldn't be relied on as Discord might change its algorithm at any time
+    # @return [Time] when this object was created at
+    def creation_time
+      # Milliseconds
+      ms = (@id >> 22) + DISCORD_EPOCH
+      Time.at(ms / 1000.0)
+    end
+
+    # Creates an artificial snowflake at the given point in time. Useful for comparing against.
+    # @param time [Time] The time the snowflake should represent.
+    # @return [Integer] a snowflake with the timestamp data as the given time
+    def self.synthesise(time)
+      ms = (time.to_f * 1000).to_i
+      (ms - DISCORD_EPOCH) << 22
+    end
+
+    class << self
+      alias_method :synthesize, :synthesise
+    end
+  end
+end

data/lib/onyxcord/light/data.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'onyxcord/data'
+
+module OnyxCord::Light
+  # Represents the bot account used for the light bot, but without any methods to change anything.
+  class LightProfile
+    include OnyxCord::IDObject
+    include OnyxCord::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 OnyxCord::IDObject
+    include OnyxCord::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 [OnyxCord::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 = OnyxCord::Permissions.new(data['permissions'])
+    end
+  end
+end

data/lib/onyxcord/light/integrations.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'onyxcord/data'
+require 'onyxcord/light/data'
+
+module OnyxCord::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 OnyxCord::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/onyxcord/light/light_bot.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'onyxcord/api'
+require 'onyxcord/api/invite'
+require 'onyxcord/api/user'
+require 'onyxcord/light/data'
+require 'onyxcord/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 OnyxCord::Light
+  # A bot that only uses the REST part of the API. Hierarchically unrelated to the regular {OnyxCord::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 = OnyxCord::API::User.profile(@token)
+      LightProfile.new(JSON.parse(response), self)
+    end
+
+    # @return [Array<LightServer>] the servers this bot is connected to.
+    def servers
+      response = OnyxCord::API::User.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)
+      OnyxCord::API::Invite.accept(@token, code)
+    end
+
+    # Gets the connections associated with this account.
+    # @return [Array<Connection>] this account's connections.
+    def connections
+      response = OnyxCord::API::User.connections(@token)
+      JSON.parse(response).map { |e| Connection.new(e, self) }
+    end
+  end
+end

data/lib/onyxcord/light.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'onyxcord/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 OnyxCord::Light
+end

data/lib/onyxcord/logger.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  # The format log timestamps should be in, in strftime format
+  LOG_TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S.%L'
+
+  # Logs debug messages
+  class Logger
+    # @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)
+    # @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
+    MODES = {
+      debug: { long: 'DEBUG', short: 'D', format_code: '' },
+      good: { long: 'GOOD', short: '✓', format_code: "\u001B[32m" }, # green
+      info: { long: 'INFO', short: 'i', format_code: '' },
+      warn: { long: 'WARN', short: '!', format_code: "\u001B[33m" }, # yellow
+      error: { long: 'ERROR', short: '✗', format_code: "\u001B[31m" }, # red
+      out: { long: 'OUT', short: '→', format_code: "\u001B[36m" }, # cyan
+      in: { long: 'IN', short: '←', format_code: "\u001B[35m" }, # purple
+      ratelimit: { long: 'RATELIMIT', short: 'R', format_code: "\u001B[41m" } # red background
+    }.freeze
+
+    # The ANSI format code that resets formatting
+    FORMAT_RESET = "\u001B[0m"
+
+    # The ANSI format code that makes something bold
+    FORMAT_BOLD = "\u001B[1m"
+
+    MODES.each do |mode, hash|
+      define_method(mode) do |message|
+        write(message.to_s, hash) if @enabled_modes.include? mode
+      end
+    end
+
+    # Sets the logging mode to :debug
+    # @param value [true, false] Whether debug mode should be on. If it is off the mode will be set to :normal.
+    def debug=(value)
+      self.mode = value ? :debug : :normal
+    end
+
+    # Sets the logging mode
+    # Possible modes are:
+    #  * :debug logs everything
+    #  * :verbose logs everything except for debug messages
+    #  * :normal logs useful information, warnings and errors
+    #  * :quiet only logs warnings and errors
+    #  * :silent logs nothing
+    # @param value [Symbol] What logging mode to use
+    def mode=(value)
+      case value
+      when :debug
+        @enabled_modes = %i[debug good info warn error out in ratelimit]
+      when :verbose
+        @enabled_modes = %i[good info warn error out in ratelimit]
+      when :normal
+        @enabled_modes = %i[info warn error ratelimit]
+      when :quiet
+        @enabled_modes = %i[warn error]
+      when :silent
+        @enabled_modes = %i[]
+      end
+    end
+
+    # Logs an exception to the console.
+    # @param e [Exception] The exception to log.
+    def log_exception(e)
+      error("Exception: #{e.inspect}")
+      e.backtrace.each { |line| error(line) }
+    end
+
+    private
+
+    def write(message, mode)
+      thread_name = Thread.current[:onyxcord_name]
+      timestamp = Time.now.strftime(LOG_TIMESTAMP_FORMAT)
+
+      # Redact token if set
+      log = if @token && @token != ''
+              message.to_s.gsub(@token, 'REDACTED_TOKEN')
+            else
+              message.to_s
+            end
+
+      @streams.each do |stream|
+        if @fancy && !stream.is_a?(File)
+          fancy_write(stream, log, mode, thread_name, timestamp)
+        else
+          simple_write(stream, log, mode, thread_name, timestamp)
+        end
+      end
+    end
+
+    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(stream, message, mode, thread_name, timestamp)
+      stream.puts "[#{mode[:long]} : #{thread_name} @ #{timestamp}] #{message}"
+      stream.flush
+    end
+  end
+end

data/lib/onyxcord/message_components.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  # Helpers for Discord message component payloads.
+  module MessageComponents
+    # Discord message flag for the Components V2 layout system.
+    IS_COMPONENTS_V2 = 1 << 15
+
+    # Component types that only exist in the Components V2 message system.
+    V2_COMPONENT_TYPES = [9, 10, 11, 12, 13, 14, 17].freeze
+
+    module_function
+
+    def payload(components)
+      case components
+      when nil
+        []
+      when Array
+        components.map { |component| component.respond_to?(:to_h) ? component.to_h : component }
+      when Hash
+        [components]
+      else
+        if components.respond_to?(:to_a)
+          components.to_a
+        elsif components.respond_to?(:to_h)
+          [components.to_h]
+        else
+          Array(components)
+        end
+      end
+    end
+
+    def components_v2?(components)
+      payload(components).any? { |component| component_v2?(component) }
+    end
+
+    def apply_v2_flag(flags, components, force: false)
+      return flags unless force || components_v2?(components)
+
+      flag_value(flags) | IS_COMPONENTS_V2
+    end
+
+    def component_v2?(component)
+      return false if component.nil?
+
+      component = component.to_h if component.respond_to?(:to_h)
+      return false unless component.is_a?(Hash)
+
+      type = component[:type] || component['type']
+      return true if V2_COMPONENT_TYPES.include?(type)
+
+      children = component[:components] || component['components']
+      return true if children && components_v2?(children)
+
+      accessory = component[:accessory] || component['accessory']
+      component_v2?(accessory)
+    end
+
+    def flag_value(flags)
+      case flags
+      when nil, :undef
+        0
+      when Array
+        flags.map { |flag| flag.respond_to?(:to_i) ? flag.to_i : 0 }.reduce(0, &:|)
+      else
+        flags.respond_to?(:to_i) ? flags.to_i : 0
+      end
+    end
+  end
+end

data/lib/onyxcord/paginator.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module OnyxCord
+  # Utility class for wrapping paginated endpoints. It is [Enumerable](https://ruby-doc.org/core-2.5.1/Enumerable.html),
+  # similar to an `Array`, so most of the same methods can be used to filter the results of the request
+  # that it wraps. If you simply want an array of all of the results, `#to_a` can be called.
+  class Paginator
+    include Enumerable
+
+    # @return [Integer] the total amount of elements that have been fetched so far.
+    attr_reader :amount_fetched
+
+    # Creates a new {Paginator}
+    # @param limit [Integer] the maximum number of items to request before stopping
+    # @param direction [:up, :down] the order in which results are returned in
+    # @yield [Array, nil] the last page of results, or nil if this is the first iteration.
+    #   This should be used to request the next page of results.
+    # @yieldreturn [Array] the next page of results
+    def initialize(limit, direction, &block)
+      @amount_fetched = 0
+      @limit = limit
+      @direction = direction
+      @block = block
+    end
+
+    # Yields every item produced by the wrapped request, until it returns
+    # no more results or the configured `limit` is reached.
+    def each
+      last_page = nil
+      until limit_exceeded?
+        page = @block.call(last_page)
+        return if page.empty?
+
+        enumerator = case @direction
+                     when :down
+                       page.each
+                     when :up
+                       page.reverse_each
+                     end
+
+        enumerator.each do |item|
+          yield item
+          @amount_fetched += 1
+          break if limit_exceeded?
+        end
+
+        last_page = page
+      end
+    end
+
+    private
+
+    # Whether the paginator limit has been exceeded
+    def limit_exceeded?
+      return false if @limit.nil?
+
+      @amount_fetched >= @limit
+    end
+  end
+end