discord_rda 0.1.3

data/lib/discord_rda/entity/color.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+module DiscordRDA
+  # Represents a Discord color.
+  # Provides conversion between RGB, hex, and integer representations.
+  #
+  # @example Creating colors
+  #   Color.new(0xFF5733)           # From integer
+  #   Color.from_rgb(255, 87, 51)    # From RGB
+  #   Color.from_hex('#FF5733')      # From hex string
+  #   Color.teal                     # Named color
+  #
+  class Color
+    # Default Discord colors
+    DEFAULTS = {
+      default: 0,
+      white: 0xFFFFFF,
+      aqua: 0x1ABC9C,
+      green: 0x57F287,
+      blue: 0x3498DB,
+      yellow: 0xFEE75C,
+      purple: 0x9B59B6,
+      luminous_vivid_pink: 0xE91E63,
+      gold: 0xF1C40F,
+      orange: 0xE67E22,
+      red: 0xED4245,
+      grey: 0x95A5A6,
+      navy: 0x34495E,
+      dark_aqua: 0x11806A,
+      dark_green: 0x1F8B4C,
+      dark_blue: 0x206694,
+      dark_purple: 0x71368A,
+      dark_vivid_pink: 0xAD1457,
+      dark_gold: 0xC27C0E,
+      dark_orange: 0xA84300,
+      dark_red: 0x992D22,
+      dark_grey: 0x979C9F,
+      darker_grey: 0x7F8C8D,
+      light_grey: 0xBCC0C0,
+      dark_navy: 0x2C3E50,
+      blurple: 0x5865F2,
+      greyple: 0x99AAB5,
+      dark_but_not_black: 0x2C2F33,
+      not_quite_black: 0x23272A
+    }.freeze
+
+    # @return [Integer] The color value
+    attr_reader :value
+
+    class << self
+      # Create from RGB values
+      # @param r [Integer] Red (0-255)
+      # @param g [Integer] Green (0-255)
+      # @param b [Integer] Blue (0-255)
+      # @return [Color] New color
+      def from_rgb(r, g, b)
+        new((r.to_i << 16) | (g.to_i << 8) | b.to_i)
+      end
+
+      # Create from hex string
+      # @param hex [String] Hex string (#RRGGBB or RRGGBB)
+      # @return [Color] New color
+      def from_hex(hex)
+        hex = hex.to_s.delete_prefix('#')
+        new(hex.to_i(16))
+      end
+
+      # Create from HSL values
+      # @param h [Float] Hue (0-360)
+      # @param s [Float] Saturation (0-1)
+      # @param l [Float] Lightness (0-1)
+      # @return [Color] New color
+      def from_hsl(h, s, l)
+        h = h.to_f / 360.0
+        s = s.to_f
+        l = l.to_f
+
+        r, g, b = if s == 0
+                    [l, l, l]
+                  else
+                    q = l < 0.5 ? l * (1 + s) : l + s - l * s
+                    p = 2 * l - q
+                    [hue_to_rgb(p, q, h + 1.0 / 3),
+                     hue_to_rgb(p, q, h),
+                     hue_to_rgb(p, q, h - 1.0 / 3)]
+                  end
+
+        from_rgb((r * 255).round, (g * 255).round, (b * 255).round)
+      end
+
+      # Generate random color
+      # @return [Color] Random color
+      def random
+        new(rand(0xFFFFFF))
+      end
+
+      # Named color methods
+      DEFAULTS.each do |name, value|
+        define_method(name) { new(value) }
+      end
+
+      private
+
+      def hue_to_rgb(p, q, t)
+        t += 1 if t < 0
+        t -= 1 if t > 1
+        return p + (q - p) * 6 * t if t < 1.0 / 6
+        return q if t < 1.0 / 2
+        return p + (q - p) * (2.0 / 3 - t) * 6 if t < 2.0 / 3
+        p
+      end
+    end
+
+    # Initialize with a color value
+    # @param value [Integer] Color value (0-0xFFFFFF)
+    def initialize(value = 0)
+      @value = value.to_i & 0xFFFFFF
+    end
+
+    # Get red component
+    # @return [Integer] Red (0-255)
+    def r
+      (@value >> 16) & 0xFF
+    end
+    alias red r
+
+    # Get green component
+    # @return [Integer] Green (0-255)
+    def g
+      (@value >> 8) & 0xFF
+    end
+    alias green g
+
+    # Get blue component
+    # @return [Integer] Blue (0-255)
+    def b
+      @value & 0xFF
+    end
+    alias blue b
+
+    # Get RGB array
+    # @return [Array<Integer>] RGB values
+    def rgb
+      [r, g, b]
+    end
+
+    # Get hex string
+    # @param prefix [Boolean] Include # prefix
+    # @return [String] Hex string
+    def to_hex(prefix: true)
+      hex = @value.to_s(16).upcase.rjust(6, '0')
+      prefix ? "##{hex}" : hex
+    end
+
+    # Convert to RGB tuple string
+    # @return [String] RGB string
+    def to_rgb_string
+      "rgb(#{r}, #{g}, #{b})"
+    end
+
+    # Get integer value
+    # @return [Integer] Color value
+    def to_i
+      @value
+    end
+
+    # Convert to decimal color string (for Discord)
+    # @return [String] Decimal string
+    def to_s
+      @value.to_s
+    end
+
+    # Check if color is valid (non-zero)
+    # @return [Boolean] True if has color
+    def valid?
+      @value > 0
+    end
+
+    # Check if color is the default (0)
+    # @return [Boolean] True if default
+    def default?
+      @value == 0
+    end
+
+    # Get brightness (0-255)
+    # @return [Integer] Brightness
+    def brightness
+      (r * 299 + g * 587 + b * 114) / 1000
+    end
+
+    # Check if color is light (brightness > 128)
+    # @return [Boolean] True if light
+    def light?
+      brightness > 128
+    end
+
+    # Check if color is dark (brightness <= 128)
+    # @return [Boolean] True if dark
+    def dark?
+      brightness <= 128
+    end
+
+    # Blend with another color
+    # @param other [Color] Other color
+    # @param ratio [Float] Blend ratio (0-1)
+ # @return [Color] Blended color
+    def blend(other, ratio = 0.5)
+      r = (self.r * (1 - ratio) + other.r * ratio).round
+      g = (self.g * (1 - ratio) + other.g * ratio).round
+      b = (self.b * (1 - ratio) + other.b * ratio).round
+      self.class.from_rgb(r, g, b)
+    end
+
+    # Darken the color
+    # @param amount [Float] Amount to darken (0-1)
+    # @return [Color] Darkened color
+    def darken(amount = 0.2)
+      blend(self.class.new(0), amount)
+    end
+
+    # Lighten the color
+    # @param amount [Float] Amount to lighten (0-1)
+    # @return [Color] Lightened color
+    def lighten(amount = 0.2)
+      blend(self.class.new(0xFFFFFF), amount)
+    end
+
+    # Get complementary color
+    # @return [Color] Complementary color
+    def complementary
+      self.class.from_rgb(255 - r, 255 - g, 255 - b)
+    end
+
+    # Check equality
+    # @param other [Object] Other object
+    # @return [Boolean] True if equal
+    def ==(other)
+      other.is_a?(Color) && @value == other.value
+    end
+
+    # Hash code
+    # @return [Integer] Hash code
+    def hash
+      @value.hash
+    end
+
+    # Inspect
+    # @return [String] Inspect string
+    def inspect
+      "#<Color #{to_hex}>"
+    end
+  end
+end

data/lib/discord_rda/entity/embed.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module DiscordRDA
+  # Represents a Discord message embed.
+  #
+  class Embed < Entity
+    # Embed types
+    TYPES = %w[rich image video gifv article link].freeze
+
+    attribute :title, type: :string
+    attribute :type, type: :string, default: 'rich'
+    attribute :description, type: :string
+    attribute :url, type: :string
+    attribute :timestamp, type: :time
+    attribute :color, type: :integer, default: 0
+    attribute :footer, type: :hash
+    attribute :image, type: :hash
+    attribute :thumbnail, type: :hash
+    attribute :video, type: :hash
+    attribute :provider, type: :hash
+    attribute :author, type: :hash
+    attribute :fields, type: :array, default: []
+
+    # Get color as Color object
+    # @return [Color] Embed color
+    def color_object
+      Color.new(color)
+    end
+
+    # Check if embed has fields
+    # @return [Boolean] True if has fields
+    def has_fields?
+      fields.any?
+    end
+
+    # Get fields
+    # @return [Array<EmbedField>] Fields
+    def embed_fields
+      (@raw_data['fields'] || []).map { |f| EmbedField.new(f) }
+    end
+
+    # Get footer
+    # @return [EmbedFooter, nil] Footer
+    def embed_footer
+      EmbedFooter.new(@raw_data['footer']) if @raw_data['footer']
+    end
+
+    # Get image
+    # @return [EmbedImage, nil] Image
+    def embed_image
+      EmbedImage.new(@raw_data['image']) if @raw_data['image']
+    end
+
+    # Get thumbnail
+    # @return [EmbedThumbnail, nil] Thumbnail
+    def embed_thumbnail
+      EmbedThumbnail.new(@raw_data['thumbnail']) if @raw_data['thumbnail']
+    end
+
+    # Get video
+    # @return [EmbedVideo, nil] Video
+    def embed_video
+      EmbedVideo.new(@raw_data['video']) if @raw_data['video']
+    end
+
+    # Get provider
+    # @return [EmbedProvider, nil] Provider
+    def embed_provider
+      EmbedProvider.new(@raw_data['provider']) if @raw_data['provider']
+    end
+
+    # Get author
+    # @return [EmbedAuthor, nil] Author
+    def embed_author
+      EmbedAuthor.new(@raw_data['author']) if @raw_data['author']
+    end
+
+    # Check if embed has image or thumbnail
+    # @return [Boolean] True if has media
+    def has_media?
+      @raw_data['image'] || @raw_data['thumbnail']
+    end
+
+    # Check if embed is empty
+    # @return [Boolean] True if empty
+    def empty?
+      title.nil? && description.nil? && !has_fields?
+    end
+
+    # Builder class for creating embeds
+    class Builder
+      def initialize
+        @data = {}
+      end
+
+      def title(value)
+        @data['title'] = value
+        self
+      end
+
+      def description(value)
+        @data['description'] = value
+        self
+      end
+
+      def url(value)
+        @data['url'] = value
+        self
+      end
+
+      def timestamp(value)
+        @data['timestamp'] = value.iso8601
+        self
+      end
+
+      def color(value)
+        @data['color'] = value.is_a?(Color) ? value.to_i : value
+        self
+      end
+
+      def field(name:, value:, inline: false)
+        @data['fields'] ||= []
+        @data['fields'] << { 'name' => name, 'value' => value, 'inline' => inline }
+        self
+      end
+
+      def footer(text:, icon_url: nil)
+        @data['footer'] = { 'text' => text }
+        @data['footer']['icon_url'] = icon_url if icon_url
+        self
+      end
+
+      def image(url:, proxy_url: nil, height: nil, width: nil)
+        @data['image'] = { 'url' => url }
+        @data['image']['proxy_url'] = proxy_url if proxy_url
+        @data['image']['height'] = height if height
+        @data['image']['width'] = width if width
+        self
+      end
+
+      def thumbnail(url:, proxy_url: nil, height: nil, width: nil)
+        @data['thumbnail'] = { 'url' => url }
+        @data['thumbnail']['proxy_url'] = proxy_url if proxy_url
+        @data['thumbnail']['height'] = height if height
+        @data['thumbnail']['width'] = width if width
+        self
+      end
+
+      def author(name:, url: nil, icon_url: nil)
+        @data['author'] = { 'name' => name }
+        @data['author']['url'] = url if url
+        @data['author']['icon_url'] = icon_url if icon_url
+        self
+      end
+
+      def build
+        Embed.new(@data)
+      end
+
+      def to_h
+        @data
+      end
+    end
+  end
+
+  # Embed field
+  class EmbedField < Entity
+    attribute :name, type: :string
+    attribute :value, type: :string
+    attribute :inline, type: :boolean, default: false
+
+    def inline?
+      inline
+    end
+  end
+
+  # Embed footer
+  class EmbedFooter < Entity
+    attribute :text, type: :string
+    attribute :icon_url, type: :string
+    attribute :proxy_icon_url, type: :string
+  end
+
+  # Embed image
+  class EmbedImage < Entity
+    attribute :url, type: :string
+    attribute :proxy_url, type: :string
+    attribute :height, type: :integer
+    attribute :width, type: :integer
+  end
+
+  # Embed thumbnail
+  class EmbedThumbnail < Entity
+    attribute :url, type: :string
+    attribute :proxy_url, type: :string
+    attribute :height, type: :integer
+    attribute :width, type: :integer
+  end
+
+  # Embed video
+  class EmbedVideo < Entity
+    attribute :url, type: :string
+    attribute :proxy_url, type: :string
+    attribute :height, type: :integer
+    attribute :width, type: :integer
+  end
+
+  # Embed provider
+  class EmbedProvider < Entity
+    attribute :name, type: :string
+    attribute :url, type: :string
+  end
+
+  # Embed author
+  class EmbedAuthor < Entity
+    attribute :name, type: :string
+    attribute :url, type: :string
+    attribute :icon_url, type: :string
+    attribute :proxy_icon_url, type: :string
+  end
+end

data/lib/discord_rda/entity/emoji.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module DiscordRDA
+  # Represents a Discord emoji (custom or Unicode).
+  #
+  class Emoji < Entity
+    attribute :name, type: :string
+    attribute :roles, type: :array, default: []
+    attribute :user, type: :hash
+    attribute :require_colons, type: :boolean, default: true
+    attribute :managed, type: :boolean, default: false
+    attribute :animated, type: :boolean, default: false
+    attribute :available, type: :boolean, default: true
+
+    # Get the guild ID
+    # @return [Snowflake, nil] Guild ID
+    def guild_id
+      @raw_data['guild_id'] ? Snowflake.new(@raw_data['guild_id']) : nil
+    end
+
+    # Check if emoji is animated
+    # @return [Boolean] True if animated
+    def animated?
+      animated
+    end
+
+    # Check if emoji requires colons
+    # @return [Boolean] True if requires colons
+    def require_colons?
+      require_colons
+    end
+
+    # Check if emoji is managed by integration
+    # @return [Boolean] True if managed
+    def managed?
+      managed
+    end
+
+    # Check if emoji is available (not blocked by role restrictions)
+    # @return [Boolean] True if available
+    def available?
+      available
+    end
+
+    # Get the emoji creator
+    # @return [User, nil] Creator
+    def user
+      @user ||= User.new(@raw_data['user']) if @raw_data['user']
+    end
+
+    # Get role restrictions
+    # @return [Array<Snowflake>] Role IDs
+    def role_ids
+      (@raw_data['roles'] || []).map { |r| Snowflake.new(r) }
+    end
+
+    # Get the emoji URL
+    # @return [String] Emoji URL
+    def url
+      ext = animated? ? 'gif' : 'png'
+      "https://cdn.discordapp.com/emojis/#{id}.#{ext}"
+    end
+
+    # Get the emoji mention string
+    # @return [String] Emoji mention
+    def mention
+      prefix = animated? ? 'a' : ''
+      "<#{prefix}:#{name}:#{id}>"
+    end
+
+    # Check if this is a Unicode emoji (no ID)
+    # @return [Boolean] True if Unicode emoji
+    def unicode?
+      id.nil?
+    end
+
+    # Check if this is a custom emoji
+    # @return [Boolean] True if custom emoji
+    def custom?
+      !id.nil?
+    end
+
+    # Get creation time (custom emojis only)
+    # @return [Time, nil] Creation time
+    def created_at
+      id&.timestamp
+    end
+  end
+end

data/lib/discord_rda/entity/factory.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module DiscordRDA
+  # Factory for creating Discord entities from API data.
+  # Supports registration of custom entity types.
+  #
+  # @example Basic usage
+  #   user = EntityFactory.create(:user, api_data)
+  #   guild = EntityFactory.create(:guild, api_data)
+  #
+  # @example Custom entity registration
+  #   class CustomGuild < Guild
+  #     # custom implementation
+  #   end
+  #   EntityFactory.register(:guild, CustomGuild)
+  #
+  class EntityFactory
+    # Default entity mappings
+    DEFAULT_ENTITIES = {
+      user: 'DiscordRDA::User',
+      guild: 'DiscordRDA::Guild',
+      channel: 'DiscordRDA::Channel',
+      message: 'DiscordRDA::Message',
+      role: 'DiscordRDA::Role',
+      member: 'DiscordRDA::Member',
+      emoji: 'DiscordRDA::Emoji',
+      attachment: 'DiscordRDA::Attachment',
+      embed: 'DiscordRDA::Embed',
+      webhook: 'DiscordRDA::Webhook'
+    }.freeze
+
+    class << self
+      # Register an entity type
+      # @param type [Symbol] Entity type identifier
+      # @param klass [Class] Entity class
+      # @return [void]
+      def register(type, klass)
+        registry[type.to_sym] = klass
+      end
+
+      # Create an entity from data
+      # @param type [Symbol] Entity type
+      # @param data [Hash] API data
+      # @return [Entity] Created entity
+      def create(type, data)
+        klass = registry[type.to_sym]
+        raise ArgumentError, "Unknown entity type: #{type}" unless klass
+
+        klass.new(data)
+      end
+
+      # Create multiple entities from array data
+      # @param type [Symbol] Entity type
+      # @param data_array [Array<Hash>] Array of API data
+      # @return [Array<Entity>] Created entities
+      def create_many(type, data_array)
+        return [] unless data_array.is_a?(Array)
+
+        data_array.map { |data| create(type, data) }
+      end
+
+      # Check if an entity type is registered
+      # @param type [Symbol] Entity type
+      # @return [Boolean] True if registered
+      def registered?(type)
+        registry.key?(type.to_sym)
+      end
+
+      # Get all registered types
+      # @return [Array<Symbol>] Registered type names
+      def registered_types
+        registry.keys
+      end
+
+      # Unregister an entity type
+      # @param type [Symbol] Entity type to unregister
+      # @return [void]
+      def unregister(type)
+        registry.delete(type.to_sym)
+      end
+
+      # Reset to default registrations
+      # @return [void]
+      def reset!
+        @registry = nil
+      end
+
+      private
+
+      def registry
+        @registry ||= build_default_registry
+      end
+
+      def build_default_registry
+        DEFAULT_ENTITIES.transform_values { |class_name| Object.const_get(class_name) }
+      end
+    end
+  end
+end