advanced_ruby_command_handler 0.1.5 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b97941216c2de5b7a5c5eac1d8613b3fb6e0670e2c52e9efb01337ab7d9be3ff
-  data.tar.gz: 1d11b79ca18ebb54e0fd7463e359955e005b022c326866a412cbe491d757e759
+  metadata.gz: a11ba24daab81b761181e660e6dbec31f61e66f60e9921ae88ed025ff428dc6f
+  data.tar.gz: 63c1cf7eaf789454969ef8e7340573c11bc81c42a10de4381bf06524aaaccd61
 SHA512:
-  metadata.gz: 5ba9dca758046935b6fe4e888401eda55575461325d76fe5afbac37037de4c2b84f52f0d9ce9aa8004b121a7e2b8b3ae7e00a8c9aa7c601fa05d99a5c0176de7
-  data.tar.gz: e21cd5ddac2ad88a7604eac57fa1b0919f723ef995d44758322053339a03820013ba05b7e72103fec3f5979c89942a1569c96950445bb29e924fcdfc5d4053b7
+  metadata.gz: ff38ee1aa4a2d6a1bb6a11ae8b791f626746ca87bf68787e2d3da82ca549c1401de947c8ee952ca45030b098cdba81295e83bd5daae97ff4447a53ab1b95f87f
+  data.tar.gz: c450efad33bc9ee1070d3658dca1aa2297f0d69da7da99021ba83c3a865766819a6f52a018251cf1ff4ddd1c95aa0c44ef2d805e29f41d8363d653454600940b

data/.github/workflows/ruby.yml

@@ -1,37 +1,12 @@
-# This workflow uses actions that are not certified by GitHub.
-# They are provided by a third-party and are governed by
-# separate terms of service, privacy policy, and support
-# documentation.
-# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
-# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
-
-name: Ruby
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
+name: My workflow
+on: [push, pull_request]
 jobs:
   test:
-
     runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        ruby-version: ['2.6', '2.7', '3.0']
-
     steps:
     - uses: actions/checkout@v2
-    - name: Set up Ruby
-    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
-    # change this to (see https://github.com/ruby/setup-ruby#versioning):
-    # uses: ruby/setup-ruby@v1
-      uses: ruby/setup-ruby@473e4d8fe5dd94ee328fdfca9f8c9c7afc9dae5e
+    - uses: ruby/setup-ruby@v1
       with:
-        ruby-version: ${{ matrix.ruby-version }}
+        ruby-version: 2.6 # Not needed with a .ruby-version file
         bundler-cache: true # runs 'bundle install' and caches installed gems automatically
-    - name: Install dependencies
-      run: bundle install
-    - name: Run tests
-      run: bundle exec rake
+    - run: bundle exec rake

data/.gitignore

@@ -8,4 +8,6 @@
 /tmp/
 /.idea/
 *.gem
-*.yml
+*.yml
+/sig/
+*.env

data/Gemfile

@@ -5,8 +5,16 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in advanced_ruby_command_handler.gemspec
 gemspec
 
+gem "rbs"
+
 gem "rake", "~> 13.0"
 
 gem "rubocop", "~> 1.7"
 
 gem "discordrb"
+
+gem "mongo"
+
+gem "dotenv", "~> 2.7", ">= 2.7.6"
+
+gem "event_emitter"

data/Gemfile.lock

@@ -1,13 +1,14 @@
 PATH
   remote: .
   specs:
-    advanced_ruby_command_handler (0.1.5)
+    advanced_ruby_command_handler (2.0.1)
       discordrb
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.2)
+    bson (4.12.1)
     discordrb (3.4.0)
       discordrb-webhooks (~> 3.3.0)
       ffi (>= 1.9.24)
@@ -18,22 +19,26 @@ GEM
       rest-client (>= 2.1.0.rc1)
     domain_name (0.5.20190701)
       unf (>= 0.0.5, < 1.0.0)
+    dotenv (2.7.6)
     event_emitter (0.2.6)
-    ffi (1.15.0-x64-mingw32)
+    ffi (1.15.4-x64-mingw32)
     http-accept (1.7.0)
-    http-cookie (1.0.3)
+    http-cookie (1.0.4)
       domain_name (~> 0.5)
     mime-types (3.3.1)
       mime-types-data (~> 3.2015)
-    mime-types-data (3.2020.1104)
+    mime-types-data (3.2021.0901)
+    mongo (2.15.1)
+      bson (>= 4.8.2, < 5.0.0)
     netrc (0.11.0)
     opus-ruby (1.0.1)
       ffi
-    parallel (1.20.1)
-    parser (3.0.1.1)
+    parallel (1.21.0)
+    parser (3.0.2.0)
       ast (~> 2.4.1)
     rainbow (3.0.0)
-    rake (13.0.3)
+    rake (13.0.6)
+    rbs (1.6.2)
     regexp_parser (2.1.1)
     rest-client (2.1.0-x64-mingw32)
       ffi (~> 1.9)
@@ -42,22 +47,22 @@ GEM
       mime-types (>= 1.16, < 4.0)
       netrc (~> 0.8)
     rexml (3.2.5)
-    rubocop (1.18.1)
+    rubocop (1.22.1)
       parallel (~> 1.10)
       parser (>= 3.0.0.0)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml
-      rubocop-ast (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 1.12.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.7.0)
+    rubocop-ast (1.12.0)
       parser (>= 3.0.1.1)
     ruby-progressbar (1.11.0)
     unf (0.1.4)
       unf_ext
-    unf_ext (0.0.7.7)
-    unicode-display_width (2.0.0)
+    unf_ext (0.0.8-x64-mingw32)
+    unicode-display_width (2.1.0)
     websocket (1.2.9)
     websocket-client-simple (0.3.0)
       event_emitter
@@ -69,7 +74,11 @@ PLATFORMS
 DEPENDENCIES
   advanced_ruby_command_handler!
   discordrb
+  dotenv (~> 2.7, >= 2.7.6)
+  event_emitter
+  mongo
   rake (~> 13.0)
+  rbs
   rubocop (~> 1.7)
 
 BUNDLED WITH

data/README.md

@@ -1,7 +1,7 @@
 
 [![forthebadge](https://forthebadge.com/images/badges/made-with-ruby.svg)](https://forthebadge.com)
 
-[![Les Laboratoires Ruby](https://invidget.switchblade.xyz/4P7XcmbDnt)](https://discord.gg/4P7XcmbDnt)
+[Les Laboratoires Ruby](https://discord.gg/4P7XcmbDnt)
 
 # AdvancedRubyCommandHandler
 ## Installation
@@ -29,55 +29,65 @@ Firstly, you have to create a ruby file, where you put the followwing line:
 require "advanced_ruby_command_handler"
 ```
 
-Then, initialize the command handler. Specifying the directories and the config file path
+Then, initialize the command handler. Specifying the directories and the modules.
 
 ```rb
-client = CommandHandler.new(commands_dir: "src/commands", events_dir: "src/events", config_file: "src/private/config.yml")
+command_handler = CommandHandler.new(Hash[
+                                       :commands_dir => "src/commands/",
+                                       :events_dir => "src/events/",
+                                       :commands_module_name => "Commands",
+                                       :events_module_name => "Events"
+                                     ])
+                                .load_commands
+                                .load_events
 ```
-Note: if these files dose not exist, the command handler will create them
+Note: if these directories dosen't exist, the command handler will create them
 
 And run the bot:
 ```ruby
-client.run
+command_handler.client.run
 ```
 
 ### Events&Commands
 
 The command handler have base events as message or ready, but you can create your owns events (in events directory).
 
-Create a file with the name of your event (see https://www.rubydoc.info/github/meew0/discordrb/Discordrb/Events)
+Create a file with the name of your event (see [https://www.rubydoc.info/github/meew0/discordrb/Discordrb/Events](the doc))
 
 And use the following template:
 ```ruby
+# src/events/message.rb
 # frozen_string_literal: true
 
 module Events
-  def self.<event>(client)
-    client.<event> do
-      client.console_logger.info("Event!")
+  # self.<event_name>
+  def self.message(command_handler)
+    Event.new(:message, command_handler.client) do |message|
+      Logger.check("Message! : #{message.content}")
     end
-  end
+   end
 end
 ```
-Now, when the event will be emitted, the program will puts "Event!"
+Now, when a message is sent, the program will puts "Message! : 'message content'"
 
 If you want to add some commands in your bot, you can create sub directories in your command directory.
 In these directories, you can create ruby files for commands, here's an example:
 
 ```ruby
+# src/commands/utils/ping.rb
 # frozen_string_literal: true
 
-require_relative "advanced_ruby_command_handler"
-
 module Commands
-  def self.hello
-    CommandHandler::Command.new({
-                                  :name => "hello"
-                                }) do |message, client|
-      message.respond "Hello Discord!"
+  # self.<command_name>
+  def self.ping
+    Command.new(Hash[
+                  :name => "ping"
+                ]) do |client, message|
+      message.respond "Pong!"
     end
   end
 end
+
 ```
 
 Now you can create events and commands ! ;)

data/lib/advanced_ruby_command_handler/base.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "dotenv/load"
+require "fileutils"
+
+class BaseDatabase
+  attr_reader :client
+
+  def initialize(client)
+    @client = client
+  end
+
+  def to_s
+    @client.database.name
+  end
+
+  def options
+    @client.hash
+  end
+end
+
+class BaseClient < Discordrb::Bot
+  def initialize
+    %w[BOT_TOKEN BOT_BASE_PREFIX BOT_OWNER].each do |environment_variable|
+      raise Errors::MissingEnvironmentVariable.new(environment_variable, "Environment variable '#{environment_variable}' missing in your .env file") unless ENV[environment_variable]
+    end
+    super(:token => ENV["BOT_TOKEN"], :ignore_bots => true)
+  end
+end
+
+class BaseCommandHandler
+  attr_accessor :commands_dir, :events_dir
+  attr_reader :commands_module_name, :events_module_name
+
+  def initialize(options)
+    %i[commands_dir events_dir commands_module_name events_module_name].each do |dir|
+      raise Errors::MissingParameter.new(dir, "Parameter '#{dir}' unspecified") unless options[dir]
+    end
+    @commands_dir = options[:commands_dir]
+    @events_dir = options[:events_dir]
+    @commands_module_name = options[:commands_module_name]
+    @events_module_name = options[:events_module_name]
+    FileUtils.mkdir_p [@commands_dir, @events_dir]
+  end
+
+  def get_module_by_string(module_name)
+    raise Errors::NonExistingModule.new(module_name, "Module '#{module_name}' doesn't exist. Please specify an existing module") unless Object.const_defined?(module_name)
+
+    Object.const_get(module_name)
+  end
+end

data/lib/advanced_ruby_command_handler/client.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "yaml"
+require File.expand_path("base", File.dirname(__FILE__))
+
+module AdvancedRubyCommandHandler
+  class Client < BaseClient
+    def run
+      Logger.check("Client run")
+      Thread.new do
+        Logger.info("Type '.exit' to turn off the bot")
+        loop do
+          Process.exit!(true) if $stdin.gets.chomp == ".exit"
+        end
+      end
+      super.run
+    end
+  end
+end

data/lib/advanced_ruby_command_handler/command.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+class Command
+  attr_reader :run
+
+  def initialize(props, &block)
+    @run = block
+    load_proprieties(props)
+  end
+
+  def load_proprieties(props)
+    command_props = %i[
+      name
+      aliases
+      description
+      category
+      usage
+      args
+      strict_args
+      cooldown
+      owner_only
+      server_only
+      member_permissions
+      bot_permissions
+    ]
+    command_props.each do |prop|
+      Command.attr_accessor prop
+    end
+    @name = props[:name]
+    @aliases = props[:aliases] if props[:aliases]
+    @description = props[:description] if props[:description]
+    @category = props[:category] if props[:category]
+    @usage = props[:usage] if props[:usage]
+    @args = props[:args] if props[:args]
+    @strict_args = props[:strict_args] if props[:strict_args]
+    @cooldown = props[:cooldown] if props[:cooldown]
+    @owner_only = true if props[:owner_only]
+    @server_only = true if props[:server_only]
+
+    client_base_permissions = %i[
+      add_reactions
+      send_messages
+      embed_links
+      attach_files
+      use_external_emoji
+    ]
+    case props[:bot_permissions]
+    when String
+      permissions = props[:bot_permissions].split(/\s+/).map(&:to_sym)
+      client_base_permissions.each { |p| permissions << p unless permissions.include?(p) }
+      @bot_permissions = permissions
+    when Array
+      permissions = props[:bot_permissions].map(&:to_sym)
+      client_base_permissions.each { |p| permissions << p unless permissions.include?(p) }
+      @bot_permissions = permissions
+    else @bot_permissions = client_base_permissions end
+
+    @member_permissions = case props[:member_permissions]
+                          when String
+                            props[:member_permissions].split(/\s+/).map(&:to_sym)
+                          else [] end
+    command_props.each { |p| instance_variable_set(:"@#{p}", false) unless instance_variable_get(:"@#{p}") }
+  end
+  private :load_proprieties
+end

data/lib/advanced_ruby_command_handler/command_handler.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "event_emitter"
+require File.expand_path("base", File.dirname(__FILE__))
+require File.expand_path("utils", File.dirname(__FILE__))
+
+class CommandHandler < BaseCommandHandler
+  include EventEmitter
+  include Utils
+  attr_reader :client, :commands, :events, :commands_module, :events_module, :loaded_events
+
+  def initialize(options)
+    super(options)
+    @client = AdvancedRubyCommandHandler::Client.new
+    @loaded_events = []
+
+    Thread.new do
+      Logger.info("Type '.reload' to load/reload all the commands & events files")
+      loop do
+        next unless $stdin.gets.chomp == ".reload"
+
+        load_commands
+        load_events
+        Logger.check("All commands & events loaded")
+      end
+    end
+  end
+
+  def load_commands
+    @commands = []
+    Dir.entries(@commands_dir).each do |dir|
+      next if %w[. ..].include?(dir)
+
+      Dir.entries("#{@commands_dir}#{dir}").each do |file|
+        next if %w[. ..].include?(file)
+
+        load File.join(@commands_dir, dir, file)
+        @commands << File.basename(file, ".rb")
+      end
+    end
+    @commands_module = get_module_by_string(@commands_module_name)
+
+    emit :commands_loaded, @commands
+    self
+  end
+
+  def load_events
+    @events = []
+    Dir.entries(@events_dir).each do |file|
+      next if %w[. ..].include?(file)
+
+      load File.join(@events_dir, file)
+      @events << File.basename(file, ".rb")
+    end
+
+    Dir["#{File.dirname(__FILE__)}/defaults/events/*.rb"].sort.each do |default_event|
+      next if @loaded_events.include?(File.basename(default_event, ".rb")) || @events.include?(File.basename(default_event, ".rb"))
+
+      require default_event
+
+      @events << File.basename(default_event, ".rb")
+    end
+    @event_module = get_module_by_string(@events_module_name)
+
+    emit :events_loaded, @events
+
+    @events.each do |event|
+      next if @loaded_events.include?(event)
+
+      @event_module.method(event).call(self)
+      @loaded_events << event
+    end
+
+    self
+  end
+end

data/lib/advanced_ruby_command_handler/database.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "mongo"
+require File.expand_path("base", File.dirname(__FILE__))
+
+module AdvancedRubyCommandHandler
+  class Database < BaseDatabase
+    attr_accessor :client, :path
+
+    def initialize(path)
+      @path = path
+      @client = Mongo::Client.new(path)
+      super(@client)
+    end
+  end
+end

data/lib/advanced_ruby_command_handler/defaults/events/message.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Events
+  def self.message(command_handler)
+    Event.new(:message, command_handler.client) do |message|
+      next unless message.content.start_with?(ENV["BOT_BASE_PREFIX"])
+
+      args = message.content.slice(ENV["BOT_BASE_PREFIX"].size, message.content.size).strip.split(/\s+/)
+      command = command_handler.find_command(args.shift)
+
+      next unless command
+
+      command.run.call(command_handler.client, message.message)
+      Logger.check("Command #{command.name} used!")
+    end
+  end
+end

data/lib/advanced_ruby_command_handler/errors.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Errors
+  class LoadCommandError < RuntimeError
+    attr_reader :command
+
+    def initialize(command, message = nil)
+      super(message)
+      @command = command
+    end
+  end
+
+  class LoadEventError < RuntimeError
+    attr_reader :event
+
+    def initialize(event, message = nil)
+      super(message)
+      @event = event
+    end
+  end
+
+  class MissingEnvironmentVariable < RuntimeError
+    attr_reader :environment_variable
+
+    def initialize(environment_variable, message = nil)
+      super(message)
+      @environment_variable = environment_variable
+    end
+  end
+
+  class MissingParameter < RuntimeError
+    attr_reader :parameter
+
+    def initialize(parameter, message = nil)
+      super(message)
+      @parameter = parameter
+    end
+  end
+
+  class NonExistingModule < RuntimeError
+    attr_reader :module_name
+
+    def initialize(module_name, message = nil)
+      super(message)
+      @module_name = module_name
+    end
+  end
+end

data/lib/advanced_ruby_command_handler/event.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Event
+  def initialize(event, client, &block)
+    return unless client.methods.include?(event)
+
+    client.method(event).call { |e| block.call(e) }
+  end
+end

data/lib/advanced_ruby_command_handler/logger.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class Logger
+  COLORS = {
+    :default => "\e[38m",
+    :white => "\e[39m",
+    :black => "\e[30m",
+    :red => "\e[31m",
+    :green => "\e[32m",
+    :brown => "\e[33m",
+    :blue => "\e[34m",
+    :magenta => "\e[35m",
+    :cyan => "\e[36m",
+    :gray => "\e[37m",
+    :yellow => "\e[33m"
+  }.freeze
+  MODES = {
+    :info => :cyan,
+    :error => :red,
+    :warn => :yellow,
+    :check => :green
+  }.freeze
+
+  class << self
+    def console_color(color, message)
+      "#{COLORS[color]}#{message}\e[0m"
+    end
+
+    private :console_color
+  end
+
+  MODES.each do |mode, color|
+    define_singleton_method(mode) do |message|
+      time = Time.now.strftime("%Y-%m-%d-%H:%M:%S")
+      puts "[#{console_color(:magenta, time)}] - [#{console_color(color, mode.to_s.upcase)}] : #{message.to_s}"
+    end
+  end
+end

data/lib/advanced_ruby_command_handler/utils.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Utils
+  def find_command(name)
+    return unless commands_module.methods.include?(name.to_sym)
+
+    commands_module.method(name.to_sym).call
+  end
+end

data/lib/advanced_ruby_command_handler/version.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
-
-module AdvancedRubyCommandHandler
-  VERSION = "0.1.5"
-end
+# frozen_string_literal: true
+
+module AdvancedRubyCommandHandler
+  VERSION = "2.0.1"
+end

data/lib/advanced_ruby_command_handler.rb

@@ -1,19 +1,16 @@
 # frozen_string_literal: true
 
-require_relative "advanced_ruby_command_handler/app/app"
-require_relative "advanced_ruby_command_handler/app/command"
-require_relative "advanced_ruby_command_handler/app/utils"
+require "discordrb"
+require File.expand_path("advanced_ruby_command_handler/database", File.dirname(__FILE__))
+require File.expand_path("advanced_ruby_command_handler/errors", File.dirname(__FILE__))
+require File.expand_path("advanced_ruby_command_handler/client", File.dirname(__FILE__))
+require File.expand_path("advanced_ruby_command_handler/utils", File.dirname(__FILE__))
+require File.expand_path("advanced_ruby_command_handler/command_handler", File.dirname(__FILE__))
+require File.expand_path("advanced_ruby_command_handler/event", File.dirname(__FILE__))
+require File.expand_path("advanced_ruby_command_handler/logger", File.dirname(__FILE__))
 
-##
-# Represent the CommandHandler as a simply class
-module CommandHandler
-  ##
-  # @!method new
-  # @param [String] commands_dir The command's directory path
-  # @param [String] events_dir The event's directory path
-  # @param [String] config_file The config's file path
-  # @return [AdvancedRubyCommandHandler::Client] the created client
-  def self.new(commands_dir: "commands", events_dir: "events", config_file: "config.yml")
-    AdvancedRubyCommandHandler::Client.new(:commands_dir => commands_dir, :events_dir => events_dir, :config_file => config_file)
-  end
+module AdvancedRubyCommandHandler
+  include Discordrb
+  include Errors
+  include Utils
 end

data/sig/lib/advanced_ruby_command_handler/base.rbs

@@ -0,0 +1,21 @@
+class BaseDatabase
+  attr_reader client: Mongo::Client
+
+  def initialize: (Mongo::CLient client) -> void
+
+  def to_s: () -> String
+
+  def options: () -> Hash|String
+end
+
+class BaseClient < Discordrb::Bot
+  def initialize: () -> void
+end
+
+class BaseCommandHandler
+  attr_accessor commands_dir: String
+
+  attr_accessor events_dir: String
+
+  def initialize: (Hash options) -> void
+end

data/sig/lib/advanced_ruby_command_handler/database.rbs

@@ -0,0 +1,7 @@
+class Database < BaseDatabase
+  attr_accessor database: Mongo::Client
+
+  attr_accessor path: String
+
+  def initialize: (String path) -> void
+end

data/sig/lib/advanced_ruby_command_handler/errors.rbs

@@ -0,0 +1,19 @@
+module Errors
+  class LoadCommandError < RuntimeError
+    attr_reader command: String
+
+    def initialize: (String command, ?String? message) -> void
+  end
+
+  class LoadEventError < RuntimeError
+    attr_reader event: String
+
+    def initialize: (String event, ?String? message) -> void
+  end
+
+  class MissingEnvironmentVariable < RuntimeError
+    attr_reader environment_variable: String
+
+    def initialize: (String environment_variable, ?String? message) -> void
+  end
+end

data/tests/index.rb

@@ -2,5 +2,20 @@
 
 require_relative "../lib/advanced_ruby_command_handler"
 
-CommandHandler.new(:commands_dir => "tests/commands", :events_dir => "tests/events", :config_file => "tests/config.yml")
-              .run
+command_handler = CommandHandler.new(Hash[
+                                       :commands_dir => "tests/src/commands/",
+                                       :events_dir => "tests/src/events/",
+                                       :commands_module_name => "Commands",
+                                       :events_module_name => "Events"
+                                     ])
+command_handler.on :commands_loaded do |commands|
+  Logger.check("#{commands.size} commands loaded!")
+end
+
+command_handler.on :events_loaded do |events|
+  Logger.check("#{events.size} events loaded!")
+end
+
+command_handler.load_commands
+               .load_events
+command_handler.client.run

data/tests/src/commands/tests/test.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "././../../../src/../../lib/advanced_ruby_command_handler/command"
+
+module Commands
+  def self.test
+    Command.new(Hash[
+                  :name => "test"
+                ]) do |client, message|
+      message.respond "#{client.profile.username} prêt!"
+    end
+  end
+end

data/tests/src/events/ready.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Events
+  def self.ready(command_handler)
+    Event.new(:ready, command_handler.client) do
+      puts "Ready!"
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: advanced_ruby_command_handler
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 2.0.1
 platform: ruby
 authors:
 - senchuu
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-02 00:00:00.000000000 Z
+date: 2021-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: discordrb
@@ -45,20 +45,23 @@ files:
 - bin/console
 - bin/setup
 - lib/advanced_ruby_command_handler.rb
-- lib/advanced_ruby_command_handler/app/app.rb
-- lib/advanced_ruby_command_handler/app/client.rb
-- lib/advanced_ruby_command_handler/app/command.rb
-- lib/advanced_ruby_command_handler/app/command_handler.rb
-- lib/advanced_ruby_command_handler/app/defaults/events/message.rb
-- lib/advanced_ruby_command_handler/app/defaults/events/ready.rb
-- lib/advanced_ruby_command_handler/app/event_handler.rb
-- lib/advanced_ruby_command_handler/app/logger.rb
-- lib/advanced_ruby_command_handler/app/utils.rb
+- lib/advanced_ruby_command_handler/base.rb
+- lib/advanced_ruby_command_handler/client.rb
+- lib/advanced_ruby_command_handler/command.rb
+- lib/advanced_ruby_command_handler/command_handler.rb
+- lib/advanced_ruby_command_handler/database.rb
+- lib/advanced_ruby_command_handler/defaults/events/message.rb
+- lib/advanced_ruby_command_handler/errors.rb
+- lib/advanced_ruby_command_handler/event.rb
+- lib/advanced_ruby_command_handler/logger.rb
+- lib/advanced_ruby_command_handler/utils.rb
 - lib/advanced_ruby_command_handler/version.rb
-- tests/commands/test/test.rb
-- tests/config.yml
-- tests/events/ready.rb
+- sig/lib/advanced_ruby_command_handler/base.rbs
+- sig/lib/advanced_ruby_command_handler/database.rbs
+- sig/lib/advanced_ruby_command_handler/errors.rbs
 - tests/index.rb
+- tests/src/commands/tests/test.rb
+- tests/src/events/ready.rb
 homepage: https://github.com/Senchuu/Advanced-Bot.rb
 licenses:
 - MIT

data/lib/advanced_ruby_command_handler/app/app.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../version"
-require_relative "logger"
-require_relative "client"
-
-module AdvancedRubyCommandHandler; end

data/lib/advanced_ruby_command_handler/app/client.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require "discordrb"
-require "fileutils"
-require "yaml"
-require_relative "command_handler"
-require_relative "event_handler"
-require_relative "utils"
-
-module AdvancedRubyCommandHandler
-  class Client < Discordrb::Bot
-    attr_reader :commands_dir, :events_dir, :commands, :config, :console_logger, :file_logger
-
-    def initialize(commands_dir: "commands", events_dir: "events", config_file: "config.yml")
-      FileUtils.mkdir_p [commands_dir, events_dir]
-      @commands_dir = commands_dir
-      @events_dir = events_dir
-      @file_logger = AdvancedRubyCommandHandler::Logger.new(:file)
-      @console_logger = AdvancedRubyCommandHandler::Logger.new(:console)
-
-      base_data = YAML.dump({
-                              :token => "",
-                              :prefix => "",
-                              :owners => []
-                            })
-
-      File.open(config_file, "w+") { |file| file.write(base_data) } unless File.exist? config_file
-
-      @config = YAML.load_file(config_file)
-
-      %i[token prefix owners].each do |prop|
-        next if @config[prop] && !@config[prop].empty?
-
-        @console_logger.error("You have to add '#{prop.to_s}' value in your config file")
-        raise "'#{prop}' missing or empty"
-      end
-
-      super(:token => @config[:token])
-
-      @commands = AdvancedRubyCommandHandler::CommandHandler.load_commands(self)
-      AdvancedRubyCommandHandler::EventHandler.load_events(self)
-                                              .each do |event|
-        Events.method(event).call(self)
-      end
-
-      at_exit { @console_logger.info("Application exited") }
-    end
-
-    def run
-      @console_logger.info("Client login!")
-
-      Thread.new do
-        @console_logger.info("Type '.exit' to turn off the bot")
-        # @console_logger.info("Type '.reload' to reload the bot")
-        loop do
-          Process.exit!(true) if $stdin.gets.chomp == ".exit"
-        end
-      end
-
-      super.run
-    end
-  end
-end

data/lib/advanced_ruby_command_handler/app/command.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module CommandHandler
-  class Command
-    attr_reader :props, :run
-
-    def initialize(props, &run)
-      @props = load_proprieties(props)
-      @run = run
-    end
-
-    def load_proprieties(props)
-      return props unless props.instance_of?(Hash)
-
-      props[:aliases] ||= nil
-      props[:description] ||= nil
-      props[:args] ||= nil
-      props[:strict_args] ||= false
-      props[:use_example] ||= nil
-      props[:category] ||= nil
-      props[:user_permissions] ||= []
-      props[:client_permissions] ||= []
-      if props[:client_permissions].instance_of?(Array) && props[:client_permissions].empty?
-        props[:client_permissions].push(
-          :add_reactions,
-          :send_messages,
-          :embed_links,
-          :attach_files,
-          :use_external_emoji
-        )
-      elsif props[:client_permissions] == :default
-        props[:client_permissions] = %i[
-          add_reactions
-          send_messages
-          embed_links
-          attach_files
-          use_external_emoji
-        ]
-      end
-
-      Hash[
-        :name => props[:name],
-        :aliases => props[:aliases],
-        :description => props[:description],
-        :args => props[:args],
-        :strict_args => props[:strict_args],
-        :use_example => props[:use_example],
-        :category => props[:category],
-        :user_permissions => props[:user_permissions],
-        :client_permissions => props[:client_permissions]
-      ]
-    end
-    private :load_proprieties
-  end
-end

data/lib/advanced_ruby_command_handler/app/command_handler.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "app"
-
-module AdvancedRubyCommandHandler
-  module CommandHandler
-    def self.load_commands(client)
-      commands = []
-      Dir.entries(client.commands_dir).each do |dir|
-        next if %w[. ..].include?(dir)
-
-        Dir.entries("#{client.commands_dir}/#{dir}").each do |file|
-          next if %w[. ..].include?(file)
-
-          p "#{client.commands_dir}/#{dir}/#{file}"
-
-          load "#{client.commands_dir}/#{dir}/#{file}"
-
-          commands << File.basename(file, ".rb")
-        end
-      end
-      commands
-    end
-  end
-end

data/lib/advanced_ruby_command_handler/app/defaults/events/message.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../../utils"
-
-module Events
-  def self.message(client)
-    client.message(:start_with => client.config[:prefix]) do |message|
-      args = message.content.slice(client.config[:prefix].size, message.content.size).split(" ")
-      name = args.shift
-      command = CommandHandler::Utils.get_command(name)
-
-      next unless command
-
-      begin
-        command.run.call(message, client)
-      rescue StandardError => e
-        client.console_logger.error(e)
-        client.file_logger.write(e, :errors)
-      ensure
-        client.console_logger.info("Command '#{command.props[:name]}' used by #{message.author.username}")
-      end
-    end
-  end
-end

data/lib/advanced_ruby_command_handler/app/defaults/events/ready.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Events
-  def self.ready(client)
-    client.ready do
-      client.console_logger.info("Client ready!")
-    end
-  end
-end

data/lib/advanced_ruby_command_handler/app/event_handler.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "app"
-
-module AdvancedRubyCommandHandler
-  module EventHandler
-    def self.load_events(client)
-      events = []
-      Dir.entries(client.events_dir).each do |file|
-        next if %w[. ..].include?(file)
-
-        load "#{client.events_dir}/#{file}"
-        events << File.basename(file, ".rb")
-      end
-
-      Dir["#{File.dirname(__FILE__)}/defaults/events/*.rb"].sort.each do |file|
-        next if events.include?(File.basename(file, ".rb"))
-
-        require file
-
-        events << File.basename(file, ".rb")
-      end
-
-      events
-    end
-  end
-end

data/lib/advanced_ruby_command_handler/app/logger.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-
-module AdvancedRubyCommandHandler
-  class Logger
-    attr_reader :mode
-    attr_accessor :write_targets
-
-    COLORS = {
-      :default => "\e[38m",
-      :white => "\e[39m",
-      :black => "\e[30m",
-      :red => "\e[31m",
-      :green => "\e[32m",
-      :brown => "\e[33m",
-      :blue => "\e[34m",
-      :magenta => "\e[35m",
-      :cyan => "\e[36m",
-      :gray => "\e[37m",
-      :yellow => "\e[33m"
-    }.freeze
-    MODES = {
-      :info => :cyan,
-      :error => :red,
-      :warn => :yellow,
-      :check => :green
-    }.freeze
-    def initialize(mode = :console, write_targets = { :errors => "logs/errors.txt", :informations => "logs/infos.txt" })
-      @mode = mode.to_sym
-      @write_targets = write_targets if @mode == :file
-    end
-
-    def console_color(color, message)
-      "#{COLORS[color]}#{message}\e[0m"
-    end
-
-    def write(message, write_target = :informations)
-      return Logger.new(:console).warn("The file logs aren't available on #{@mode} mode") unless @mode == :file
-
-      time = Time.now.strftime("%Y-%m-%d-%H:%M:%S")
-
-      FileUtils.mkdir_p File.dirname @write_targets[write_target]
-
-      File.open(@write_targets[write_target], "w") unless File.exist? @write_targets[write_target]
-
-      File.open(@write_targets[write_target], "a+") do |file|
-        file.write("#{time} - #{write_target.to_s.upcase} : #{message}\n")
-      end
-    end
-
-    MODES.each do |mode, color|
-      define_method(mode) do |message|
-        return Logger.new(:console).warn("The console logs aren't available on #{@mode} mode") unless @mode == :console
-
-        time = Time.now.strftime("%Y-%m-%d-%H:%M:%S")
-        puts "[#{console_color(:magenta, time)}] - [#{console_color(color, mode.to_s.upcase)}] : #{message.to_s}"
-      end
-    end
-    private :console_color
-  end
-end

data/lib/advanced_ruby_command_handler/app/utils.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module CommandHandler
-  module Utils
-    def self.get_command(command_name)
-      return Commands.method(command_name).call if defined?(Commands) && Commands.respond_to?(command_name)
-
-      false
-    end
-
-    # Do NOT use that
-    # FIXME
-    def reload_files(dirs)
-      dirs.each do |dir|
-        Dir.glob("#{dir}/**/*.rb").each { |file| load file }
-      end
-    end
-  end
-end

data/tests/commands/test/test.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../../../lib/advanced_ruby_command_handler/app/command"
-require_relative "../../../lib/advanced_ruby_command_handler/app/utils"
-
-module Commands
-  def self.test
-    CommandHandler::Command.new({
-                                  :name => "test",
-                                  :aliases => ["t"],
-                                  :description => "Une commande pour faire des tests!",
-                                  :args => false,
-                                  :use_example => :default,
-                                  :category => :default
-                                }) do |message, _client|
-      message.respond "Test"
-    end
-  end
-end

data/tests/config.yml

@@ -1,4 +0,0 @@
----
-:token: 'NzEwMTIxODk2OTM0NjM3NjY5.Xrv2jQ._ypS5jOkYr4onqigdoxGzF2dRj0'
-:prefix: '!'
-:owners: [123456789]

data/tests/events/ready.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Events
-  def self.ready(client)
-    client.ready do
-      client.console_logger.info("Client ready!")
-    end
-  end
-end