rubord 0.1.3

data/lib/rubord/components/select_menu.rb

@@ -0,0 +1,147 @@
+# components/select_menu.rb
+
+module Rubord
+  # Represents a Discord select menu component.
+  #
+  # Select menus are dropdown components that allow users to select
+  # one or multiple options from a list.
+  #
+  # @example Creating a single-select menu
+  #   menu = Rubord::SelectMenu.new(
+  #     custom_id: "game_selection",
+  #     placeholder: "Choose a game..."
+  #   )
+  #   menu.add_option(label: "Minecraft", value: "minecraft")
+  #   menu.add_option(label: "Terraria", value: "terraria")
+  #
+  # @example Creating a multi-select menu
+  #   menu = Rubord::SelectMenu.new(
+  #     custom_id: "hobbies",
+  #     placeholder: "Select your hobbies",
+  #     min_values: 1,
+  #     max_values: 3
+  #   )
+  #
+  # @since 1.0.0
+  # @see https://discord.com/developers/docs/interactions/message-components#select-menus
+  class SelectMenu
+    # @return [Integer] Component type (always 3 for select menus).
+    attr_accessor :type
+    
+    # @return [String] Developer-defined identifier.
+    attr_accessor :custom_id
+    
+    # @return [Array<Hash>] List of available options.
+    attr_accessor :options
+    
+    # @return [String, nil] Placeholder text displayed when no option is selected.
+    attr_accessor :placeholder
+    
+    # @return [Integer] Minimum number of options that must be selected.
+    #   Defaults to 1.
+    attr_accessor :min_values
+    
+    # @return [Integer] Maximum number of options that can be selected.
+    #   Defaults to 1.
+    attr_accessor :max_values
+    
+    # @return [Boolean] Whether the select menu is disabled.
+    attr_accessor :disabled
+
+    # Creates a new select menu component.
+    #
+    # @param custom_id [String] Developer-defined identifier.
+    # @param placeholder [String, nil] Placeholder text.
+    # @param min_values [Integer] Minimum selectable options.
+    #   Defaults to 1.
+    # @param max_values [Integer] Maximum selectable options.
+    #   Defaults to 1.
+    # @param disabled [Boolean] Whether the menu is disabled.
+    #   Defaults to false.
+    #
+    # @example Basic select menu
+    #   SelectMenu.new(
+    #     custom_id: "color_picker",
+    #     placeholder: "Choose a color",
+    #     min_values: 1,
+    #     max_values: 1
+    #   )
+    #
+    # @example Multi-select menu
+    #   SelectMenu.new(
+    #     custom_id: "tags",
+    #     placeholder: "Select up to 3 tags",
+    #     min_values: 0,
+    #     max_values: 3
+    #   )
+    def initialize(custom_id:, placeholder: nil, min_values: 1, max_values: 1, disabled: false)
+      @type = 3
+      @custom_id = custom_id
+      @options = []
+      @placeholder = placeholder
+      @min_values = min_values
+      @max_values = max_values
+      @disabled = disabled
+    end
+
+    # Adds an option to the select menu.
+    #
+    # @param label [String] The user-facing name of the option (max 100 chars).
+    # @param value [String] The developer-defined value of the option (max 100 chars).
+    # @param description [String, nil] Additional description (max 100 chars).
+    # @param emoji [Hash, nil] Emoji to display with the option.
+    # @param default [Boolean] Whether this option is selected by default.
+    #   Defaults to false.
+    #
+    # @return [Rubord::SelectMenu] Self for method chaining.
+    #
+    # @example Adding an option with description
+    #   menu.add_option(
+    #     label: "Ruby",
+    #     value: "ruby_lang",
+    #     description: "Dynamic, object-oriented programming language",
+    #     emoji: { name: "💎" }
+    #   )
+    def add_option(label:, value:, description: nil, emoji: nil, default: false)
+      @options << {
+        label: label,
+        value: value,
+        description: description,
+        emoji: emoji,
+        default: default
+      }.compact
+      self
+    end
+
+    # Converts the select menu to a Discord API-compatible hash.
+    #
+    # @return [Hash] Select menu data in Discord API format.
+    #
+    # @example
+    #   menu = SelectMenu.new(custom_id: "test")
+    #   menu.to_h
+    #   # => {type: 3, custom_id: "test", options: [], min_values: 1, max_values: 1, disabled: false}
+    def to_h
+      {
+        type: @type,
+        custom_id: @custom_id,
+        options: @options,
+        placeholder: @placeholder,
+        min_values: @min_values,
+        max_values: @max_values,
+        disabled: @disabled
+      }.compact
+    end
+  end
+
+  # Factory method for creating SelectMenu instances.
+  #
+  # @param args [Hash] Select menu initialization parameters.
+  # @return [Rubord::SelectMenu] New select menu instance.
+  #
+  # @example
+  #   menu = Rubord.SelectMenu(custom_id: "choices", placeholder: "Make a choice")
+  def self.SelectMenu(**args)
+    SelectMenu.new(**args)
+  end
+end

data/lib/rubord/models/channel.rb

@@ -0,0 +1,50 @@
+module Rubord
+  class Channel
+    attr_reader :id,
+                :name,
+                :type,
+                :client
+
+    def initialize(data, client)
+      @id     = data["id"]
+      @name   = data["name"]
+      @type   = data["type"]
+      @client = client
+
+      client&.channels&.set(@id, self)
+    end
+
+    def post(content = nil, embeds: nil, components: nil, flags: nil)
+      ensure_client!
+
+      client.rest.send_message(
+        @id,
+        content: content,
+        embeds: embeds,
+        components: components,
+        flags: flags
+      )
+    end
+
+    def fetch_message(message_id)
+      client.rest.get_message(@id, message_id)
+    end
+
+    def guild
+      return nil unless client && client.respond_to?(:guilds)
+      client.guilds.get(guild_id)
+    end
+
+    def text?
+      type == 0
+    end
+
+    def voice?
+      type == 2
+    end
+
+    def inspect
+      "#<Rubord::Channel id=#{id} name=#{name.inspect} type=#{type}>"
+    end
+  end
+end

data/lib/rubord/models/collection.rb

@@ -0,0 +1,70 @@
+module Rubord
+  class Collection
+    include Enumerable
+
+    def initialize
+      @store = {}
+    end
+
+    def [](key)
+      @store[key]
+    end
+
+    def []=(key, value)
+      @store[key] = value
+    end
+
+    def get(key)
+      @store[key]
+    end
+
+    def set(key, value)
+      @store[key] = value
+      self
+    end
+
+    def delete(key)
+      @store.delete(key)
+    end
+
+    def each(&block)
+      @store.each_value(&block)
+    end
+
+    def map(&block)
+      @store.values.map(&block)
+    end
+
+    def filter(&block)
+      self.class.new.tap do |col|
+        @store.each do |k, v|
+          col.set(k, v) if block.call(v)
+        end
+      end
+    end
+
+    def find(&block)
+      @store.values.find(&block)
+    end
+
+    def values
+      @store.values
+    end
+
+    def keys
+      @store.keys
+    end
+
+    def size
+      @store.size
+    end
+
+    def empty?
+      @store.empty?
+    end
+
+    def to_h
+      @store.dup
+    end
+  end
+end

data/lib/rubord/models/commands/base.rb

@@ -0,0 +1,111 @@
+module Rubord
+  # Base class for creating commands.
+  #
+  # @example Creating a simple command
+  #   class PingCommand < Rubord::CommandBase
+  #     name "ping"
+  #     description "Responds with pong"
+  #
+  #     # @yieldparam message [Rubord::Message] The message that triggered the command
+  #     def run(message)
+  #       message.reply("Pong!")
+  #     end
+  #   end
+  #
+  # @abstract
+  class CommandBase
+    class << self
+      attr_reader :command_name,
+                  :description_text,
+                  :command_usage,
+                  :aliases_list,
+                  :cooldown_seconds,
+                  :guild_only_flag,
+                  :dm_only_flag
+
+      def inherited(subclass)
+        super
+        subclass.instance_variable_set(:@aliases_list, [])
+        subclass.instance_variable_set(:@cooldown_seconds, 0)
+        subclass.instance_variable_set(:@guild_only_flag, false)
+        subclass.instance_variable_set(:@dm_only_flag, false)
+      end
+
+      def name(value)
+        @command_name = value.to_s
+      end
+
+      def description(value)
+        @description_text = value.to_s
+      end
+
+      def aliases(*values)
+        @aliases_list.concat(values.map(&:to_s))
+      end
+
+      def cooldown(seconds)
+        @cooldown_seconds = seconds.to_i
+      end
+
+      def guild_only(value = true)
+        @guild_only_flag = value
+      end
+
+      def dm_only(value = true)
+        @dm_only_flag = value
+      end
+
+      def validate!
+        raise ArgumentError, "Command #{self} is missing a name" unless @command_name
+      end
+    end
+
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+      self.class.validate!
+    end
+
+    # @return [String]
+    def name
+      self.class.command_name
+    end
+
+    # @return [String]
+    def description
+      self.class.description_text
+    end
+
+    # @return [Array<String>]
+    def aliases
+      self.class.aliases_list
+    end
+
+    # @return [Integer]
+    def cooldown
+      self.class.cooldown_seconds
+    end
+
+    def guild_only?
+      self.class.guild_only_flag
+    end
+
+    def dm_only?
+      self.class.dm_only_flag
+    end
+
+    # Executes the command.
+    #
+    # @param message [Rubord::Message]
+    # @param args [Array<String>]
+    # @abstract
+    def run(_message, _args = [])
+      raise NotImplementedError, "#{self.class} must implement #run(message)"
+    end
+
+    def inspect
+      "#<#{self.class} name=#{command_name.inspect}>"
+    end
+  end
+end

data/lib/rubord/models/commands/command.rb

@@ -0,0 +1,3 @@
+require_relative "base.rb"
+require_relative "loader.rb"
+require_relative "registry.rb"

data/lib/rubord/models/commands/loader.rb

@@ -0,0 +1,36 @@
+# loader.rb
+module Rubord
+  class CommandLoader
+    def self.load(path, client, registry)
+      full_path = File.expand_path(path)
+      files = Dir["#{full_path}/**/*.rb"]
+
+      files.each do |file|
+        begin
+          Kernel.load(file)
+        rescue => e
+          puts "[Rubord:Commands] ERRO ao carregar #{file}:"
+          puts "  #{e.class}: #{e.message}"
+        end
+      end
+
+      found_classes = []
+      ObjectSpace.each_object(Class) do |klass|
+        next if klass == Rubord::CommandBase
+
+        if klass.ancestors.include?(Rubord::CommandBase)
+          found_classes << klass
+        end
+      end
+
+      found_classes.each do |klass|
+        begin
+          registry.register(klass, client)
+        rescue => e
+          puts "[Rubord:Commands] ERRO ao registrar #{klass}:"
+          puts "  #{e.class}: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/rubord/models/commands/registry.rb

@@ -0,0 +1,26 @@
+module Rubord
+  class CommandRegistry
+    def initialize
+      @commands = {}
+      @command_classes = {}
+    end
+
+    def register(klass, client)
+      name = klass.command_name
+      raise "Command missing name" unless name
+      
+      @command_classes[name] = klass
+      @commands[name] = klass.new(client)
+      
+      Rubord::Logger.success "[Rubord:Commands] Registered command: #{name}"
+    end
+
+    def get(name)
+      @commands[name]
+    end
+
+    def all
+      @commands.values.freeze
+    end
+  end
+end

data/lib/rubord/models/components.rb

@@ -0,0 +1,5 @@
+require_relative "../components/button"
+require_relative "../components/select_menu"
+require_relative "../components/modal"
+require_relative "../components/actionRow.rb"
+require_relative "../components/componentsV2.rb"

data/lib/rubord/models/embed.rb

@@ -0,0 +1,87 @@
+module Rubord
+  class Embed
+    attr_accessor :title,
+                  :description,
+                  :url,
+                  :timestamp,
+                  :color,
+                  :footer,
+                  :image,
+                  :thumbnail,
+                  :author,
+                  :fields
+
+    def initialize
+      @fields = []
+    end
+
+    def title(text)
+      @title = text
+      self
+    end
+
+    def description(text)
+      @description = text
+      self
+    end
+
+    def url(link)
+      @url = link
+      self
+    end
+
+    def timestamp(time = Time.now)
+      @timestamp = time.utc.iso8601
+      self
+    end
+
+    def color(hex)
+      @color = Rubord.Parser.color(hex)
+      self
+    end
+
+    def footer(text:, icon_url: nil)
+      @footer = { text: text, icon_url: icon_url }
+      self
+    end
+
+    def image(url)
+      @image = { url: url }
+      self
+    end
+
+    def thumbnail(url)
+      @thumbnail = { url: url }
+      self
+    end
+
+    def author(name:, url: nil, icon_url: nil)
+      @author = { name: name, url: url, icon_url: icon_url }
+      self
+    end
+
+    def add_field(name, value, inline = false)
+      @fields << { name: name, value: value, inline: inline }
+      self
+    end
+
+    def to_h
+      {
+        title: @title,
+        description: @description,
+        url: @url,
+        timestamp: @timestamp,
+        color: @color,
+        footer: @footer,
+        image: @image,
+        thumbnail: @thumbnail,
+        author: @author,
+        fields: @fields.empty? ? nil : @fields
+      }.compact
+    end
+  end
+  
+  def self.Embed
+    Embed.new
+  end
+end