dragonruby-egg 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dbdcd93f1ddb45e46dda6c8ea2cb44eeace67558a04a417367fd6c7cc50d1e93
+  data.tar.gz: f3d41e967e4b7c6001b3b050a0329a23940db9ac574c285551f0107473176163
+SHA512:
+  metadata.gz: 283be22db3317bf2de5cfea3c914e19c78b53599f21d91f8e28371a3f86f041caf19cd9a159d5e84f51471c40713eaa6ef616b97bfca8f1ef6ff5ae497068da0
+  data.tar.gz: 831e2537cccd96361543fd1e2b6700d5381fab124af774befe6aee210ca9363b16761e3a0fdd6605ca94eb87dcef54c1b21ddf8a99676f9dbeeaa89b28166f73

data/app/arguments.rb

@@ -0,0 +1,60 @@
+module Dre
+  @options = {
+    is_docs: false,
+    is_egg: false,
+    root_path: nil,
+    path: nil,
+    install: nil,
+    new: nil
+  }
+  @options[:path] = OptionParser.last_arg if Dir.exist?(OptionParser.last_arg)
+
+  OptionParser.parse do |parser|
+    parser.banner(
+      "#{DragonrubyEgg::Constants::APP_FULL_NAME} is a tool for managing DragonRuby.\n" +
+      "Usage: #{APP_NAME} [options] [path]\n" +
+      "\nOptions:"
+    )
+    parser.on( "new NAME", "", "They will create a new game project.") do |name|
+      @options[:new] = name
+    end
+    parser.on( "install MODULE", "", "Installs the module in the working folder.\n" +
+               "(Example: install dr-core-rb,\n" +
+               "install filipvrba.dr-core-rb)\n" ) do |repo_module|
+      @options[:install] = repo_module
+    end
+    parser.on( "-e", "--egg", "This opens a page in the main browser\n" +
+               "that lists all the modules that can be\n"+
+               "installed in the game project." ) do
+      @options[:is_egg] = true
+    end
+    parser.on( "-d", "--docs", "Opens the documentation for DragonRuby\n" +
+                               "in the main browser." ) do
+      @options[:is_docs] = true
+    end
+    parser.on( "-sr PATH", "--set-root PATH",
+        "This command sets the root\n" +
+        "path to DragonRuby.\n" +
+        "(Default: '#{@configuration.parse(:root_path)}')"
+      ) do |path|
+      @options[:root_path] = path
+    end
+    parser.on( "-h", "--help", "Show help" ) do
+      puts parser
+      exit
+    end
+    parser.on( "-v", "--version", "Show version" ) do
+      DragonrubyEgg::Event.print('VERSION', DragonrubyEgg::VERSION)
+      exit
+    end
+  end
+
+  def self.options_empty?
+    @options.each do |k, v|
+      if k != :path and v
+        return false
+      end
+    end
+    return true
+  end
+end

data/app/configuration.rb

@@ -0,0 +1,36 @@
+module Dre
+  module_function
+
+  @configuration = JsonParser.new File.join(ROOT, 'config/default.json')
+  h_root_path = lambda { |_| @configuration.parse(:root_path) }
+  DragonrubyEgg::Event.add(:root_path, h_root_path)
+
+  def configuration_on
+    @configuration.on_handler(:root_path,
+      lambda do
+        r_path = DragonrubyEgg::Executable.find_root_path
+        unless r_path
+          DragonrubyEgg::Event.print('ROOT-PATH',
+            "No DragonRuby root path has been found."
+          )
+          DragonrubyEgg::Event.print('WARNING',
+            "Please set the root path using the -sr " +
+            "or --set-root argument."
+          )
+        end
+        return r_path
+      end
+    ) do |is_end, r_path|
+      unless is_end
+        DragonrubyEgg::Event.print('ROOT-PATH',
+          "The root path has not been set and so the analysis " +
+          "of the root path is performed."
+        )
+      else
+        DragonrubyEgg::Event.print('SET', "root_path: #{r_path}")
+      end
+    end
+  end
+end
+
+Dre.configuration_on()

data/app/inputs.rb

@@ -0,0 +1,14 @@
+module Dre
+  h_correct = lambda do |d|
+    print "Install this '#{d[0]}.#{d[1]}' module? (y/N): "
+    input = STDIN.gets.chomp
+    result = false
+
+    if input.downcase.index("y")
+      result = true
+    end
+    return result
+  end
+
+  DragonrubyEgg::Event.add(:input_correct, h_correct)
+end

data/app/main.rb

@@ -0,0 +1,49 @@
+require 'dragonruby_egg'
+require 'option_parser'
+require 'json_parser'
+
+require_relative './configuration'
+require_relative './arguments'
+require_relative './inputs'
+
+module Dre
+  module_function
+
+  def root_path_state
+    sym = :root_path
+    root_path = @options[sym]
+    if root_path
+      if root_path == ''
+        DragonrubyEgg::Event.print('WARNING', "An empty string for" +
+          "the root path is not acceptable.")
+        @configuration.delete(sym)
+        configuration_on()
+      else
+        @configuration.parse(sym, root_path)
+        DragonrubyEgg::Event.print('SET', "#{sym.to_s}: #{root_path.to_s}")
+      end
+    end
+  end
+
+  def main_state
+    if options_empty?
+      DragonrubyEgg::Executable.dragonruby(@options[:path])
+    elsif @options[:is_docs]
+      DragonrubyEgg::Executable.docs()
+    elsif @options[:is_egg]
+      DragonrubyEgg::Executable.egg()
+    elsif @options[:install]
+      if @options[:path]
+        DragonrubyEgg::Executable.install(@options[:install], @options[:path])
+      else
+        DragonrubyEgg::Event.print('WARNING', "A working path must " +
+          "be defined to install the module.")
+      end
+    elsif @options[:new]
+      DragonrubyEgg::Executable.new_project(@options[:new], @options[:path])
+    end
+  end
+end
+
+Dre.root_path_state()
+Dre.main_state()

data/bin/dre

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+APP_NAME = File.basename($0)
+ROOT = File.expand_path("..", __dir__)
+$: << File.join(ROOT, 'lib')
+require_relative "../app/main"

data/lib/dragonruby_egg/constants.rb

@@ -0,0 +1,13 @@
+module DragonrubyEgg
+  VERSION = "1.0.0"
+  module Constants
+    APP_FULL_NAME = 'DragonRuby-Egg'
+    DR_EXES = {
+      dr: 'dragonruby',
+      drh: 'dragonruby-httpd',
+      drp: 'dragonruby-publish'
+    }
+    DR_DOCS = 'docs/docs.html'
+    DRE_URL = 'https://dragonruby-egg-ui-rjs.vercel.app/'
+  end
+end

data/lib/dragonruby_egg/database.rb

@@ -0,0 +1,21 @@
+require 'rest-client'
+require 'json'
+
+module DragonrubyEgg
+  module Database
+    GUARD_MODULES = "Ku3biL772AhmQndV"
+    DB_NAME = 1
+
+    module_function
+
+    def get_modules
+      rest_data = RestClient.get('https://bef.fly.dev/api/v1/guard', {
+        params: {
+          token: GUARD_MODULES,
+          database: DB_NAME
+        }
+      })
+      return JSON.parse(rest_data)
+    end
+  end
+end

data/lib/dragonruby_egg/event.rb

@@ -0,0 +1,28 @@
+module DragonrubyEgg
+  module Event
+    HANDLERS = {}
+    @is_print_active = true
+
+    module_function
+
+    def set_print_active(bool)
+      @is_print_active = bool
+    end
+
+    def print(event, message = "")
+      unless @is_print_active
+        return
+      end
+
+      puts("#{Time.now.strftime("%l:%M:%S %p").lstrip} [#{APP_NAME}] #{event} | #{message}")
+    end
+
+    def add(symbol, handler)
+      HANDLERS[symbol] = handler
+    end
+
+    def emit(symbol, *args)
+      HANDLERS[symbol].call(args)
+    end
+  end
+end

data/lib/dragonruby_egg/executable.rb

@@ -0,0 +1,81 @@
+module DragonrubyEgg
+  module Executable
+    module_function
+
+    def root_path? path
+      exes = Constants::DR_EXES.map { |_,v| File.join(path, v) }
+      exes.each do |exe|
+        is_existing = File.exist?(exe) && File.executable?(exe)
+        unless is_existing
+          return false
+        end
+      end
+
+      return true 
+    end
+
+    def find_root_path(root = '/')
+      paths = Dir.glob(
+        "#{root}/**/#{Constants::DR_EXES[:dr]}",
+        File::FNM_DOTMATCH
+      )
+      paths.each do |path|
+        if File.exist?(path)
+          r_path = File.dirname(path)
+          if root_path?(r_path)
+            return r_path
+          end
+        end
+      end
+
+      return nil
+    end
+
+    def web_brower
+      %x(xdg-settings get default-web-browser)
+        .sub(/\..*$/, '').rstrip
+    end
+
+    def dragonruby arg
+      root_path = Event::emit(:root_path)
+      path = File.join(root_path, Constants::DR_EXES[:dr])
+      system("#{path} #{arg}")
+    end
+
+    def docs
+      root_path = Event::emit(:root_path)
+      doc_file = File.join(root_path, Constants::DR_DOCS)
+      system("#{web_brower} #{doc_file} &")
+    end
+
+    def egg
+      root_path = Event::emit(:root_path)
+      system("#{web_brower} #{Constants::DRE_URL} &")
+    end
+
+    def install repo_module, path
+      module_url = Modules.get_module_url(repo_module)
+      unless module_url
+        return
+      end
+      module_path = "#{path}/modules/#{repo_module}"
+
+      is_install = system("git clone --recurse-submodules #{module_url}.git '#{module_path}'")
+      if is_install
+        Event.print('INSTALL', "The '#{repo_module}' module " +
+          "has been installed in this '.#{module_path.sub(path, '')}' folder.")
+      end
+    end
+
+    def new_project name, path
+      root_path = Event::emit(:root_path)
+      unless path
+        path = Dir.pwd
+      end
+      is_copy = system("cp -r '#{root_path}/mygame' '#{path}/#{name}'")
+      if is_copy
+        Event.print('NEW', "The '#{name}' project has been created.")
+      end
+    end
+  end
+end

data/lib/dragonruby_egg/modules.rb

@@ -0,0 +1,24 @@
+module DragonrubyEgg
+  module Modules
+    module_function
+
+    def get_module_url(repo_module)
+      modules = Database.get_modules()
+
+      modules.each do |_module|
+        author = _module["author"]
+        name = _module["name"]
+        url = _module["github_url"]
+        
+        if repo_module.index(/^(#{author}.)?#{name}$/)
+          is_correct = Event.emit(:input_correct, author, name)
+          if is_correct
+            return url
+          end
+        end
+      end # modules each
+
+      return nil
+    end
+  end
+end

data/lib/dragonruby_egg.rb

@@ -0,0 +1,8 @@
+require 'dragonruby_egg/constants'
+require 'dragonruby_egg/event'
+require 'dragonruby_egg/database'
+require 'dragonruby_egg/modules'
+require 'dragonruby_egg/executable'
+
+module DragonrubyEgg
+end

data/lib/json_parser.rb

@@ -0,0 +1,107 @@
+require "json"
+require 'fileutils'
+
+class JsonParser
+  attr_reader :path, :db
+  
+  def initialize path, auto_write = true
+    @path = path
+    @db = open @path
+    @auto_write = auto_write
+  end
+
+  def on symbol, value
+    unless @db.include?(symbol.to_s)
+      parse symbol, value
+    end
+  end
+
+  def on_handler symbol, handler, &block
+    unless @db.include?(symbol.to_s)
+      block.call(false) if block
+      value = handler.call()
+      if value
+        parse symbol, value
+        block.call(true, value) if block
+      end
+    end
+  end
+
+  def parse symbols, value = nil, delete = nil
+    symbols_join = ""
+    if symbols.class.name == "Array"
+      symbols_join = symbols.join("\"][\"")
+    else
+      symbols_join = symbols.to_s
+    end
+    symbols_join = "[\"#{symbols_join}\"]"
+
+    unless delete
+      unless value
+        eval "@db#{ symbols_join }"
+      else
+        eval "@db#{ symbols_join } = value"
+        
+        if @auto_write
+          write @path, @db
+        end
+      end
+    else
+      if symbols
+        eval "@db#{ symbols_join }.delete('#{delete}')"
+      else
+        eval "@db.delete('#{delete}')"
+      end
+
+      if @auto_write
+        write @path, @db
+      end
+    end
+  end
+
+  def exist?
+    @db.empty?
+  end
+
+  def delete key, symbols = nil
+    parse(symbols, nil, key)
+  end
+
+  private
+  def open path
+    begin
+      result = String.new
+      File.open path do |f|
+        result = JSON.parse f.read
+      end
+
+      return result
+    rescue
+      return Hash.new
+    end
+  end
+
+  def write path, db
+    begin
+      create_dir path do 
+
+        f = File.new path, "w"
+        f.write JSON.pretty_generate db
+        f.close
+      end
+    end
+  end
+
+  def create_dir path, &callback
+    begin
+      dir_path = File.dirname path
+      unless Dir.exist? dir_path
+        FileUtils.mkpath dir_path
+      end
+
+      callback.call
+    rescue
+      
+    end
+  end
+end

data/lib/option_parser.rb

@@ -0,0 +1,91 @@
+class OptionParser
+
+	LEFT = 2
+	MIDDLE = 33
+
+    attr_reader :args
+
+    def self.parse(args = ARGV)
+        parser = OptionParser.new
+        yield parser
+        parser.process args
+        parser
+    end
+
+    def self.last_arg(args = ARGV)
+        args.length >= 1 ? args[args.length - 1] : ''
+    end
+
+    def initialize(args = ARGV)
+        @args = args
+        @banner = nil
+        @flags = Array.new
+    end
+
+    def banner(banner)
+        @banner = banner
+    end
+
+    def on(short_flag, long_flag, description, &block)
+        @flags << { short_flag: short_flag || '', long_flag: long_flag || '',
+            description: description || '', block: block }
+    end
+
+    def process( args = ARGV )
+        unless args.length == 0
+            args.each_with_index do |arg, i|
+                @flags.each do |flag|
+                    name = -> (type_flag) do
+                        flag[type_flag].gsub( /[a-z -]/, '' )
+                    end
+
+                    flag_strip = -> (type_flag) do
+                        flag[type_flag].sub( name.(type_flag), '' ).strip()
+                    end
+                    has_flag = -> (type_flag) { arg == flag_strip.(type_flag) }
+
+                    if has_flag.(:short_flag) or
+                    has_flag.(:long_flag)
+
+                        has_name = -> (type_flag) do
+                            name.(type_flag) != ""
+                        end
+                        value = nil
+
+                        if has_name.(:short_flag) or
+                        has_name.(:long_flag)
+                            value = args[i + 1]
+                        end
+
+                        flag[:block].call( value )
+                    end
+                end
+            end
+        else
+            flag = @flags[0]
+            flag[:block].call
+        end
+    end
+
+    def self.get_empty_spaces
+        " " * (MIDDLE + LEFT)
+    end
+
+    def to_s()
+        io = Array.new
+        if banner = @banner
+            io << banner
+            io << "\n"
+        end
+        
+        @flags.each do |flag|
+            l_flag = !flag[:long_flag].empty? ? ", #{flag[:long_flag]}" : ""
+			flags = "#{flag[:short_flag]}#{l_flag}".ljust(MIDDLE)
+			desc = flag[:description].gsub("\n", "\n#{OptionParser.get_empty_spaces}")
+            io << "".ljust(LEFT) + flags + desc
+            io << "\n"
+        end
+
+        io.join
+    end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: dragonruby-egg
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Filip Vrba
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-04-25 00:00:00.000000000 Z
+dependencies: []
+description: With the tool, you can create new projects, install modules into a game
+  project and open documentation using a command. There are many more functions and
+  they are started with the 'dre' command.
+email: filipvrbaxi@gmail.com
+executables:
+- dre
+extensions: []
+extra_rdoc_files: []
+files:
+- app/arguments.rb
+- app/configuration.rb
+- app/inputs.rb
+- app/main.rb
+- bin/dre
+- lib/dragonruby_egg.rb
+- lib/dragonruby_egg/constants.rb
+- lib/dragonruby_egg/database.rb
+- lib/dragonruby_egg/event.rb
+- lib/dragonruby_egg/executable.rb
+- lib/dragonruby_egg/modules.rb
+- lib/json_parser.rb
+- lib/option_parser.rb
+homepage: https://dragonruby-egg-ui-rjs.vercel.app/
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/filipvrba/dragonruby-egg-rb
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key: 
+specification_version: 4
+summary: DragonRuby-Egg is a tool for managing DragonRuby.
+test_files: []