erebrus 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 76b069200add69a2d85d26e12f70dd726611b1873e77f9ce0f39b66b5c836efb
+  data.tar.gz: 407eb8f255a7bdc2cc495a66d5dc712e93f467ca8a01f20ff95e5762a89f1add
+SHA512:
+  metadata.gz: e41e9a1e3878050ba948b036576a7630f34d94cbaa9c5e897ce07eadbac10e18fe79ce5aa0d882ff5336178fd7a504e2ec1728552a2dd3a85d7f4f3304831360
+  data.tar.gz: 4a35080e1c2bd7025cc66510457ceba4d9372254cf42916f4908cba345f8ccbdc97cc92a8d833819d577010a2ffdd3c58b515896531dce39b3c49b5c2443152d

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Daedalus OS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,7 @@
+# Erebrus
+
+Modern C/C++ build system like msbuild, with ruby instead of xml
+
+## Usage
+
+TODO

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: :rubocop

data/bin/erebrus

@@ -0,0 +1,401 @@
+#!/usr/bin/env ruby
+require "thor"
+require "erebrus"
+
+class ErebrusCommand < Thor
+  class_option :verbose, aliases: "-v", type: :boolean, desc: "Verbose output"
+  class_option :file, aliases: "-f", desc: "Buildfile to use", default: "Buildfile"
+
+  desc "build [TARGET]", "Builds the project with optional target"
+  option :namespace, aliases: "-n", desc: "Target namespace"
+  option :var, aliases: "-D", type: :hash, desc: "Set variables (e.g., -D CC=gcc -D CFLAGS=-O2)"
+  option :parallel, aliases: "-j", type: :numeric, desc: "Number of parallel jobs"
+  def build(target = nil)
+    load_buildfile_with_error_handling
+
+    target_name = resolve_target_name(target)
+
+    context = prepare_context
+
+    begin
+      Erebrus.build(target_name, context)
+      puts "Build completed successfully!" unless options[:quiet]
+    rescue Erebrus::Error => e
+      puts "Build failed: #{e.message}"
+      exit 1
+    rescue StandardError => e
+      puts "Unexpected error: #{e.message}"
+      puts e.backtrace if options[:verbose]
+      exit 1
+    end
+  end
+
+  desc "list [NAMESPACE]", "Lists all available targets, optionally filtered by namespace"
+  def list(namespace = nil)
+    load_buildfile_with_error_handling
+
+    begin
+      if namespace
+        Erebrus.list_targets(namespace: namespace)
+      else
+        Erebrus.list_targets
+      end
+    rescue StandardError => e
+      puts "Error listing targets: #{e.message}"
+      exit 1
+    end
+  end
+
+  desc "namespaces", "Lists all available namespaces"
+  def namespaces
+    load_buildfile_with_error_handling
+
+    begin
+      Erebrus.list_namespaces
+    rescue StandardError => e
+      puts "Error listing namespaces: #{e.message}"
+      exit 1
+    end
+  end
+
+  desc "init [TYPE]", "Initializes the project with a sample Buildfile"
+  def init(type = "basic")
+    buildfile = options[:file]
+
+    if File.exist?(buildfile)
+      puts "Buildfile '#{buildfile}' already exists!"
+      return
+    end
+
+    sample_content = case type.downcase
+                     when "cpp", "c++"
+                       generate_cpp_buildfile
+                     when "c"
+                       generate_c_buildfile
+                     when "advanced"
+                       generate_advanced_buildfile
+                     else
+                       generate_basic_buildfile
+                     end
+
+    File.write(buildfile, sample_content)
+    puts "Created #{buildfile} (#{type} template)"
+    puts "Edit the file to define your build targets and run 'erebrus build' to build your project"
+  end
+
+  desc "validate", "Validates the Buildfile syntax"
+  def validate
+    buildfile = options[:file]
+
+    unless File.exist?(buildfile)
+      puts "Error: Buildfile '#{buildfile}' not found"
+      exit 1
+    end
+
+    begin
+      Erebrus.reset!
+      Erebrus.load_buildfile(buildfile)
+      puts "Buildfile is valid ✓"
+    rescue StandardError => e
+      puts "Buildfile validation failed: #{e.message}"
+      exit 1
+    end
+  end
+
+  desc "graph [TARGET]", "Shows dependency graph for target"
+  def graph(target = nil)
+    load_buildfile_with_error_handling
+
+    target_name = resolve_target_name(target)
+
+    begin
+      puts "Dependency graph for '#{target_name}':"
+      puts "(Graph visualization not yet implemented)"
+    rescue StandardError => e
+      puts "Error generating graph: #{e.message}"
+      exit 1
+    end
+  end
+
+  desc "clean", "Runs the clean target if available"
+  def clean
+    load_buildfile_with_error_handling
+
+    begin
+      Erebrus.build("clean")
+    rescue Erebrus::Error => e
+      if e.message.include?("not found")
+        puts "No clean target defined"
+      else
+        puts "Clean failed: #{e.message}"
+        exit 1
+      end
+    end
+  end
+
+  desc "version", "Show version"
+  def version
+    puts "Erebrus #{Erebrus::VERSION}"
+  end
+
+  private
+
+  def load_buildfile_with_error_handling
+    buildfile = options[:file]
+
+    unless File.exist?(buildfile)
+      puts "Error: Buildfile '#{buildfile}' not found"
+      puts "Run 'erebrus init' to create a sample Buildfile"
+      exit 1
+    end
+
+    begin
+      Erebrus.reset!
+      Erebrus.load_buildfile(buildfile)
+    rescue StandardError => e
+      puts "Error loading buildfile: #{e.message}"
+      puts e.backtrace if options[:verbose]
+      exit 1
+    end
+  end
+
+  def resolve_target_name(target)
+    return target unless target && options[:namespace]
+
+    "#{options[:namespace]}:#{target}"
+  end
+
+  def prepare_context
+    context = {}
+
+    context.merge!(options[:var]) if options[:var]
+
+    context["PLATFORM"] = RUBY_PLATFORM
+    context["RUBY_VERSION"] = RUBY_VERSION
+    context["PWD"] = Dir.pwd
+
+    context
+  end
+
+  def generate_basic_buildfile
+    <<~BUILDFILE
+      target :clean, description: "Clean build artifacts" do
+        remove "build"
+        remove "dist"
+      end
+
+      target :setup, description: "Setup build environment" do
+        mkdir "build"
+        mkdir "dist"
+      end
+
+      target :build, description: "Build the project" do
+        depends_on :setup
+      #{"  "}
+        action do
+          puts "Building project..."
+        end
+      end
+
+      target :test, description: "Run tests" do
+        depends_on :build
+      #{"  "}
+        action do
+          puts "Running tests..."
+        end
+      end
+
+      default :build
+    BUILDFILE
+  end
+
+  def generate_cpp_buildfile
+    <<~BUILDFILE
+      set_variable 'CXX', get_variable('CXX', 'g++')
+      set_variable 'CXXFLAGS', get_variable('CXXFLAGS', '-std=c++17 -Wall -Wextra -O2')
+      set_variable 'SRCDIR', 'src'
+      set_variable 'BUILDDIR', 'build'
+      set_variable 'BINDIR', 'bin'
+
+      target :clean, description: "Clean build artifacts" do
+        remove "\${BUILDDIR}"
+        remove "\${BINDIR}"
+      end
+
+      target :setup, description: "Setup build directories" do
+        mkdir "\${BUILDDIR}"
+        mkdir "\${BINDIR}"
+      end
+
+      target :compile, description: "Compile source files" do
+        depends_on :setup
+        depends_on_files "\${SRCDIR}/*.cpp", "\${SRCDIR}/*.hpp"
+        produces "\${BUILDDIR}/*.o"
+      #{"  "}
+        run "\${CXX} \${CXXFLAGS} -c \${SRCDIR}/*.cpp"
+        run "mv *.o \${BUILDDIR}/ 2>/dev/null || true"
+      end
+
+      target :link, description: "Link executable" do
+        depends_on :compile
+        produces "\${BINDIR}/myapp"
+      #{"  "}
+        run "\${CXX} \${BUILDDIR}/*.o -o \${BINDIR}/myapp"
+      end
+
+      target :build, description: "Build the complete project" do
+        depends_on :link
+      end
+
+      target :test, description: "Run tests" do
+        depends_on :build
+      #{"  "}
+        run "\${BINDIR}/myapp --test"
+      end
+
+      target :install, description: "Install the application" do
+        depends_on :build
+      #{"  "}
+        platform :linux do
+          copy "\${BINDIR}/myapp", "/usr/local/bin/myapp"
+        end
+      #{"  "}
+        platform :windows do
+          copy "\${BINDIR}/myapp.exe", "C:/Program Files/MyApp/myapp.exe"
+        end
+      end
+
+      default :build
+    BUILDFILE
+  end
+
+  def generate_c_buildfile
+    <<~BUILDFILE
+      set_variable 'CC', get_variable('CC', 'gcc')
+      set_variable 'CFLAGS', get_variable('CFLAGS', '-std=c99 -Wall -Wextra -O2')
+
+      target :clean, description: "Clean build artifacts" do
+        remove "build"
+        remove "bin"
+      end
+
+      target :setup, description: "Setup build directories" do
+        mkdir "build"
+        mkdir "bin"
+      end
+
+      target :compile, description: "Compile source files" do
+        depends_on :setup
+        depends_on_files "src/*.c", "src/*.h"
+      #{"  "}
+        run "\${CC} \${CFLAGS} -c src/*.c"
+        run "mv *.o build/ 2>/dev/null || true"
+      end
+
+      target :link, description: "Link executable" do
+        depends_on :compile
+      #{"  "}
+        run "\${CC} build/*.o -o bin/myapp"
+      end
+
+      target :build, description: "Build the project" do
+        depends_on :link
+      end
+
+      default :build
+    BUILDFILE
+  end
+
+  def generate_advanced_buildfile
+    <<~BUILDFILE
+      set_variable 'PROJECT_NAME', 'MyProject'
+      set_variable 'VERSION', '1.0.0'
+      set_variable 'BUILD_TYPE', get_variable('BUILD_TYPE', 'Release')
+
+      conditional platform?(:windows) do
+        set_variable 'EXE_EXT', '.exe'
+        set_variable 'LIB_EXT', '.dll'
+      end
+
+      conditional platform?(:linux) do
+        set_variable 'EXE_EXT', ''
+        set_variable 'LIB_EXT', '.so'
+      end
+
+      namespace :clean do
+        target :all, description: "Clean everything" do
+          remove "build"
+          remove "dist"
+          remove "temp"
+        end
+
+        target :build, description: "Clean build artifacts only" do
+          remove "build"
+        end
+      end
+
+      namespace :build do
+        target :debug, description: "Build debug version" do
+          set_variable 'BUILD_TYPE', 'Debug'
+          depends_on 'compile:debug'
+          depends_on 'link:debug'
+        end
+
+        target :release, description: "Build release version" do
+          set_variable 'BUILD_TYPE', 'Release'
+          depends_on 'compile:release'
+          depends_on 'link:release'
+        end
+      end
+
+      namespace :compile do
+        target :debug, description: "Compile debug version" do
+          tag :compile, :debug
+          only_if ->(ctx) { ctx['BUILD_TYPE'] == 'Debug' }
+      #{"    "}
+          run "g++ -g -DDEBUG -c src/*.cpp"
+        end
+
+        target :release, description: "Compile release version" do
+          tag :compile, :release
+          only_if ->(ctx) { ctx['BUILD_TYPE'] == 'Release' }
+      #{"    "}
+          run "g++ -O2 -DNDEBUG -c src/*.cpp"
+        end
+      end
+
+      namespace :link do
+        target :debug, description: "Link debug executable" do
+          depends_on 'compile:debug'
+          run "g++ *.o -o bin/\${PROJECT_NAME}_debug\${EXE_EXT}"
+        end
+
+        target :release, description: "Link release executable" do
+          depends_on 'compile:release'
+          run "g++ *.o -o bin/\${PROJECT_NAME}\${EXE_EXT}"
+        end
+      end
+
+      namespace :test do
+        target :unit, description: "Run unit tests" do
+          depends_on 'build:debug'
+          run "bin/\${PROJECT_NAME}_debug\${EXE_EXT} --unit-tests"
+        end
+
+        target :integration, description: "Run integration tests" do
+          depends_on 'build:release'
+          run "bin/\${PROJECT_NAME}\${EXE_EXT} --integration-tests"
+        end
+
+        target :all, description: "Run all tests" do
+          depends_on :unit
+          depends_on :integration
+        end
+      end
+
+      default 'build:release'
+    BUILDFILE
+  end
+end
+
+ErebrusCommand.start

data/examples/Buildfile

@@ -0,0 +1,96 @@
+# Erebrus Buildfile Example
+# This demonstrates the Ruby build DSL for C/C++ projects
+
+target :clean, description: "Clean all build artifacts" do
+  remove "build"
+  remove "dist"
+  remove "obj"
+end
+
+target :setup, description: "Setup build directories" do
+  mkdir "build"
+  mkdir "dist"
+  mkdir "obj"
+end
+
+target :configure, description: "Configure build environment" do
+  depends_on :setup
+  
+  action do |context|
+    puts "Configuring build for #{context[:platform] || 'default'} platform"
+  end
+end
+
+target :compile_sources, description: "Compile source files" do
+  depends_on :configure
+  
+  # Compile all C++ files in src/
+  run "g++ -std=c++17 -Wall -Wextra -O2 -c src/*.cpp -Iinclude"
+  
+  # Move object files to obj directory
+  run "mv *.o obj/ 2>/dev/null || true"
+end
+
+target :compile_tests, description: "Compile test files" do
+  depends_on :compile_sources
+  
+  run "g++ -std=c++17 -Wall -Wextra -O2 -c tests/*.cpp -Iinclude -Isrc"
+  run "mv *.o obj/ 2>/dev/null || true"
+end
+
+target :link_main, description: "Link main executable" do
+  depends_on :compile_sources
+  
+  run "g++ obj/*.o -o dist/myapp"
+end
+
+target :link_tests, description: "Link test executable" do
+  depends_on :compile_tests
+  
+  run "g++ obj/*.o -o dist/test_runner"
+end
+
+target :build, description: "Build the main application" do
+  depends_on :link_main
+  
+  action do
+    puts "Build completed successfully!"
+    puts "Executable: dist/myapp"
+  end
+end
+
+target :test, description: "Run all tests" do
+  depends_on :link_tests
+  
+  run "dist/test_runner"
+end
+
+target :install, description: "Install the application" do
+  depends_on :build
+  
+  copy "dist/myapp", "/usr/local/bin/myapp"
+  
+  action do
+    puts "Application installed to /usr/local/bin/myapp"
+  end
+end
+
+target :package, description: "Create distribution package" do
+  depends_on :build
+  
+  mkdir "package"
+  copy "dist/myapp", "package/"
+  copy "README.md", "package/"
+  copy "LICENSE", "package/"
+  
+  run "tar -czf dist/myapp-1.0.tar.gz -C package ."
+  remove "package"
+end
+
+target :all, description: "Build, test, and package" do
+  depends_on :test
+  depends_on :package
+end
+
+# Set the default target
+default :build

data/lib/erebrus/build_engine.rb

@@ -0,0 +1,449 @@
+require "pathname"
+
+module Erebrus
+  class BuildEngine
+    attr_reader :targets, :namespaces, :variables, :included_files
+    attr_accessor :current_namespace
+
+    def initialize
+      @targets = {}
+      @namespaces = {}
+      @variables = {}
+      @default_target = nil
+      @current_namespace = nil
+      @included_files = Set.new
+      @file_watchers = {}
+      @conditional_stack = []
+    end
+
+    def target(name, description: nil, namespace: nil, &block)
+      full_name = build_target_name(name, namespace || @current_namespace)
+      target_obj = Target.new(full_name, description: description)
+      target_obj.namespace = namespace || @current_namespace
+      @targets[full_name] = target_obj
+
+      ns = namespace || @current_namespace
+      if ns
+        @namespaces[ns] ||= []
+        @namespaces[ns] << full_name
+      end
+
+      if block_given?
+        target_context = TargetContext.new(target_obj, self)
+        target_context.instance_eval(&block)
+      end
+
+      target_obj
+    end
+
+    def namespace(name, &block)
+      old_namespace = @current_namespace
+      @current_namespace = name.to_s
+
+      begin
+        yield if block_given?
+      ensure
+        @current_namespace = old_namespace
+      end
+    end
+
+    def include_buildfile(file_path, namespace: nil)
+      resolved_path = resolve_file_path(file_path)
+
+      if @included_files.include?(resolved_path)
+        puts "Warning: Buildfile '#{resolved_path}' already included, skipping"
+        return
+      end
+
+      raise Error, "Buildfile not found: #{resolved_path}" unless File.exist?(resolved_path)
+
+      @included_files.add(resolved_path)
+
+      old_namespace = @current_namespace
+      @current_namespace = namespace if namespace
+
+      begin
+        content = File.read(resolved_path)
+        instance_eval(content, resolved_path)
+      ensure
+        @current_namespace = old_namespace
+      end
+    end
+
+    def set_variable(name, value)
+      @variables[name.to_s] = value
+    end
+
+    def get_variable(name, default = nil)
+      @variables[name.to_s] || ENV[name.to_s] || default
+    end
+
+    def conditional(condition, &block)
+      @conditional_stack.push(condition)
+
+      begin
+        yield if condition && block_given?
+      ensure
+        @conditional_stack.pop
+      end
+    end
+
+    def platform?(name)
+      case name.to_s.downcase
+      when "windows", "win32"
+        Gem.win_platform?
+      when "linux"
+        RUBY_PLATFORM.include?("linux")
+      when "macos", "darwin"
+        RUBY_PLATFORM.include?("darwin")
+      else
+        RUBY_PLATFORM.include?(name.to_s)
+      end
+    end
+
+    def file_exists?(path)
+      File.exist?(resolve_file_path(path))
+    end
+
+    def directory_exists?(path)
+      Dir.exist?(resolve_file_path(path))
+    end
+
+    def default(target_name)
+      @default_target = resolve_target_name(target_name)
+    end
+
+    def build(target_name = nil, context = {})
+      target_name = resolve_target_name(target_name || @default_target)
+
+      raise Error, "No target specified and no default target set" unless target_name
+
+      target_obj = @targets[target_name]
+      unless target_obj
+        available_targets = @targets.keys.sort
+        raise Error, "Target '#{target_name}' not found. Available targets: #{available_targets.join(", ")}"
+      end
+
+      merged_context = @variables.merge(context)
+
+      reset_all_targets!
+      execute_target(target_obj, merged_context)
+    end
+
+    def list_targets(namespace: nil)
+      targets_to_show = if namespace
+                          @namespaces[namespace.to_s] || []
+                        else
+                          @targets.keys
+                        end
+
+      if namespace
+        puts "Targets in namespace '#{namespace}':"
+      else
+        puts "Available targets:"
+      end
+
+      targets_to_show.sort.each do |name|
+        target = @targets[name]
+        next unless target
+
+        puts "  #{name}:"
+        puts "    Description: #{target.description}" if target.description
+        puts "    Namespace: #{target.namespace}" if target.namespace && !namespace
+        puts "    Dependencies: #{target.dependencies.join(", ")}" unless target.dependencies.empty?
+        puts "    Conditions: #{target.conditions.join(", ")}" unless target.conditions.empty?
+        puts
+      end
+    end
+
+    def list_namespaces
+      puts "Available namespaces:"
+      @namespaces.each do |ns, targets|
+        puts "  #{ns}: #{targets.size} targets"
+      end
+    end
+
+    def watch_file(pattern, &block)
+      @file_watchers[pattern] = block
+    end
+
+    def check_file_changes
+      @file_watchers.each do |pattern, callback|
+        Dir.glob(pattern).each do |file|
+          callback.call(file) if File.mtime(file) > (@last_check || Time.at(0))
+        end
+      end
+      @last_check = Time.now
+    end
+
+    private
+
+    def build_target_name(name, namespace = nil)
+      if namespace
+        "#{namespace}:#{name}"
+      else
+        name.to_s
+      end
+    end
+
+    def resolve_target_name(name)
+      return nil unless name
+
+      name_str = name.to_s
+
+      return name_str if name_str.include?(":")
+
+      if @current_namespace
+        namespaced = "#{@current_namespace}:#{name_str}"
+        return namespaced if @targets.key?(namespaced)
+      end
+
+      name_str
+    end
+
+    def resolve_file_path(path)
+      pathname = Pathname.new(path)
+      return pathname.to_s if pathname.absolute?
+
+      Pathname.pwd.join(path).to_s
+    end
+
+    def execute_target(target, context, visited = Set.new)
+      target_name = target.name
+
+      if visited.include?(target_name)
+        raise Error, "Circular dependency detected: #{visited.to_a.join(" -> ")} -> #{target_name}"
+      end
+
+      return if target.executed
+
+      unless target.conditions.all? { |condition| condition.call(context) }
+        puts "Skipping target '#{target_name}' (conditions not met)"
+        target.executed = true
+        return
+      end
+
+      visited.add(target_name)
+
+      target.dependencies.each do |dep_name|
+        resolved_dep = resolve_target_name(dep_name)
+        dep_target = @targets[resolved_dep]
+        raise Error, "Dependency '#{dep_name}' not found for target '#{target_name}'" unless dep_target
+
+        execute_target(dep_target, context, visited.dup)
+      end
+
+      target.execute(context)
+
+      visited.delete(target_name)
+    end
+
+    def reset_all_targets!
+      @targets.each_value(&:reset!)
+    end
+  end
+
+  class TargetContext
+    def initialize(target, engine = nil)
+      @target = target
+      @engine = engine
+    end
+
+    def depends_on(*deps)
+      @target.depends_on(*deps)
+    end
+
+    def depends_on_files(*files)
+      @target.depends_on_files(*files)
+    end
+
+    def produces(*files)
+      @target.produces(*files)
+    end
+
+    def condition(&block)
+      @target.condition(&block)
+    end
+
+    def only_if(condition)
+      @target.only_if(condition)
+    end
+
+    def tag(*tags)
+      @target.tag(*tags)
+    end
+
+    def action(&block)
+      @target.action(&block)
+    end
+
+    def run(command, options = {})
+      @target.action do |context|
+        expanded_command = expand_variables(command, context)
+        puts "Running: #{expanded_command}"
+
+        if options[:capture]
+          result = `#{expanded_command}`
+          raise Error, "Command failed: #{expanded_command}" unless $?.success?
+
+          result.chomp
+        else
+          system(expanded_command) || raise(Error, "Command failed: #{expanded_command}")
+        end
+      end
+    end
+
+    def copy(source, destination, options = {})
+      @target.action do |context|
+        expanded_source = expand_variables(source, context)
+        expanded_dest = expand_variables(destination, context)
+
+        puts "Copying #{expanded_source} to #{expanded_dest}"
+        require "fileutils"
+
+        if options[:preserve]
+          FileUtils.cp_r(expanded_source, expanded_dest, preserve: true)
+        else
+          FileUtils.cp_r(expanded_source, expanded_dest)
+        end
+      end
+    end
+
+    def mkdir(path)
+      @target.action do |context|
+        expanded_path = expand_variables(path, context)
+        puts "Creating directory: #{expanded_path}"
+        require "fileutils"
+        FileUtils.mkdir_p(expanded_path)
+      end
+    end
+
+    def remove(path)
+      @target.action do |context|
+        expanded_path = expand_variables(path, context)
+        puts "Removing: #{expanded_path}"
+        require "fileutils"
+        FileUtils.rm_rf(expanded_path)
+      end
+    end
+
+    def touch(path)
+      @target.action do |context|
+        expanded_path = expand_variables(path, context)
+        puts "Touching: #{expanded_path}"
+        require "fileutils"
+        FileUtils.touch(expanded_path)
+      end
+    end
+
+    def chmod(mode, path)
+      @target.action do |context|
+        expanded_path = expand_variables(path, context)
+        puts "Changing permissions of #{expanded_path} to #{mode}"
+        require "fileutils"
+        FileUtils.chmod(mode, expanded_path)
+      end
+    end
+
+    def download(url, destination)
+      @target.action do |context|
+        expanded_url = expand_variables(url, context)
+        expanded_dest = expand_variables(destination, context)
+
+        puts "Downloading #{expanded_url} to #{expanded_dest}"
+        require "net/http"
+        require "uri"
+
+        uri = URI(expanded_url)
+        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
+          request = Net::HTTP::Get.new(uri)
+          response = http.request(request)
+
+          raise Error, "Download failed: #{response.code} #{response.message}" unless response.code == "200"
+
+          File.write(expanded_dest, response.body)
+        end
+      end
+    end
+
+    def template(template_file, output_file, variables = {})
+      @target.action do |context|
+        expanded_template = expand_variables(template_file, context)
+        expanded_output = expand_variables(output_file, context)
+
+        puts "Processing template #{expanded_template} -> #{expanded_output}"
+
+        template_content = File.read(expanded_template)
+        merged_vars = context.merge(variables)
+
+        result = template_content.gsub(/\{\{(\w+)\}\}/) do |match|
+          var_name = ::Regexp.last_match(1)
+          merged_vars[var_name] || merged_vars[var_name.to_sym] || match
+        end
+
+        File.write(expanded_output, result)
+      end
+    end
+
+    def parallel(*targets)
+      @target.action do
+        threads = targets.map do |target_name|
+          Thread.new do
+            @engine&.build(target_name) if @engine
+          end
+        end
+        threads.each(&:join)
+      end
+    end
+
+    def conditional(condition, &block)
+      @target.action do |context|
+        result = case condition
+                 when Proc
+                   condition.call(context)
+                 when Symbol
+                   context[condition]
+                 when String
+                   context[condition] || ENV[condition]
+                 else
+                   !!condition
+                 end
+
+        block.call(context) if result && block_given?
+      end
+    end
+
+    def platform(name, &block)
+      conditional(->(ctx) { @engine&.platform?(name) }, &block)
+    end
+
+    def file_exists(path, &block)
+      conditional(->(ctx) { File.exist?(expand_variables(path, ctx)) }, &block)
+    end
+
+    def directory_exists(path, &block)
+      conditional(->(ctx) { Dir.exist?(expand_variables(path, ctx)) }, &block)
+    end
+
+    def set_variable(name, value)
+      @target.action do |context|
+        @engine&.set_variable(name, expand_variables(value, context))
+      end
+    end
+
+    def get_variable(name, default = nil)
+      @engine&.get_variable(name, default)
+    end
+
+    private
+
+    def expand_variables(text, context)
+      return text unless text.is_a?(String)
+
+      text.gsub(/\$\{(\w+)\}|\$(\w+)/) do |match|
+        var_name = ::Regexp.last_match(1) || ::Regexp.last_match(2)
+        context[var_name] || context[var_name.to_sym] || ENV[var_name] || match
+      end
+    end
+  end
+end

data/lib/erebrus/dsl.rb

@@ -0,0 +1,165 @@
+module Erebrus
+  module DSL
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def build_engine
+        @build_engine ||= BuildEngine.new
+      end
+
+      def target(name, description: nil, namespace: nil, &block)
+        build_engine.target(name, description: description, namespace: namespace, &block)
+      end
+
+      def namespace(name, &block)
+        build_engine.namespace(name, &block)
+      end
+
+      def include_buildfile(file_path, namespace: nil)
+        build_engine.include_buildfile(file_path, namespace: namespace)
+      end
+
+      def set_variable(name, value)
+        build_engine.set_variable(name, value)
+      end
+
+      def get_variable(name, default = nil)
+        build_engine.get_variable(name, default)
+      end
+
+      def conditional(condition, &block)
+        build_engine.conditional(condition, &block)
+      end
+
+      def platform?(name)
+        build_engine.platform?(name)
+      end
+
+      def default(target_name)
+        build_engine.default(target_name)
+      end
+
+      def build(target_name = nil, context = {})
+        build_engine.build(target_name, context)
+      end
+
+      def list_targets(namespace: nil)
+        build_engine.list_targets(namespace: namespace)
+      end
+
+      def list_namespaces
+        build_engine.list_namespaces
+      end
+    end
+
+    def target(name, description: nil, namespace: nil, &block)
+      self.class.build_engine.target(name, description: description, namespace: namespace, &block)
+    end
+
+    def namespace(name, &block)
+      self.class.build_engine.namespace(name, &block)
+    end
+
+    def include_buildfile(file_path, namespace: nil)
+      self.class.build_engine.include_buildfile(file_path, namespace: namespace)
+    end
+
+    def set_variable(name, value)
+      self.class.build_engine.set_variable(name, value)
+    end
+
+    def get_variable(name, default = nil)
+      self.class.build_engine.get_variable(name, default)
+    end
+
+    def conditional(condition, &block)
+      self.class.build_engine.conditional(condition, &block)
+    end
+
+    def platform?(name)
+      self.class.build_engine.platform?(name)
+    end
+
+    def default(target_name)
+      self.class.build_engine.default(target_name)
+    end
+
+    def build(target_name = nil, context = {})
+      self.class.build_engine.build(target_name, context)
+    end
+
+    def list_targets(namespace: nil)
+      self.class.build_engine.list_targets(namespace: namespace)
+    end
+
+    def list_namespaces
+      self.class.build_engine.list_namespaces
+    end
+  end
+
+  def self.target(name, description: nil, namespace: nil, &block)
+    @global_engine ||= BuildEngine.new
+    @global_engine.target(name, description: description, namespace: namespace, &block)
+  end
+
+  def self.namespace(name, &block)
+    @global_engine ||= BuildEngine.new
+    @global_engine.namespace(name, &block)
+  end
+
+  def self.include_buildfile(file_path, namespace: nil)
+    @global_engine ||= BuildEngine.new
+    @global_engine.include_buildfile(file_path, namespace: namespace)
+  end
+
+  def self.set_variable(name, value)
+    @global_engine ||= BuildEngine.new
+    @global_engine.set_variable(name, value)
+  end
+
+  def self.get_variable(name, default = nil)
+    @global_engine ||= BuildEngine.new
+    @global_engine.get_variable(name, default)
+  end
+
+  def self.conditional(condition, &block)
+    @global_engine ||= BuildEngine.new
+    @global_engine.conditional(condition, &block)
+  end
+
+  def self.platform?(name)
+    @global_engine ||= BuildEngine.new
+    @global_engine.platform?(name)
+  end
+
+  def self.default(target_name)
+    @global_engine ||= BuildEngine.new
+    @global_engine.default(target_name)
+  end
+
+  def self.build(target_name = nil, context = {})
+    @global_engine ||= BuildEngine.new
+    @global_engine.build(target_name, context)
+  end
+
+  def self.list_targets(namespace: nil)
+    @global_engine ||= BuildEngine.new
+    @global_engine.list_targets(namespace: namespace)
+  end
+
+  def self.list_namespaces
+    @global_engine ||= BuildEngine.new
+    @global_engine.list_namespaces
+  end
+
+  def self.load_buildfile(file_path)
+    @global_engine ||= BuildEngine.new
+    @global_engine.include_buildfile(file_path)
+  end
+
+  def self.reset!
+    @global_engine = nil
+  end
+end

data/lib/erebrus/target.rb

@@ -0,0 +1,130 @@
+module Erebrus
+  class Target
+    attr_reader :name, :dependencies, :description, :conditions, :file_dependencies, :outputs
+    attr_accessor :executed, :namespace, :tags, :priority
+
+    def initialize(name, description: nil)
+      @name = name.to_s
+      @description = description
+      @dependencies = []
+      @actions = []
+      @conditions = []
+      @file_dependencies = []
+      @outputs = []
+      @executed = false
+      @namespace = nil
+      @tags = []
+      @priority = 0
+      @last_run = nil
+    end
+
+    def depends_on(*deps)
+      @dependencies.concat(deps.map(&:to_s))
+      self
+    end
+
+    def depends_on_files(*files)
+      @file_dependencies.concat(files.map(&:to_s))
+      self
+    end
+
+    def produces(*files)
+      @outputs.concat(files.map(&:to_s))
+      self
+    end
+
+    def condition(&block)
+      @conditions << block if block_given?
+      self
+    end
+
+    def only_if(condition)
+      @conditions << case condition
+                     when Proc
+                       condition
+                     when Symbol
+                       ->(ctx) { ctx[condition] }
+                     when String
+                       ->(ctx) { ctx[condition] || ENV[condition] }
+                     else
+                       ->(_) { !!condition }
+                     end
+      self
+    end
+
+    def tag(*tags)
+      @tags.concat(tags.map(&:to_s))
+      self
+    end
+
+    def action(&block)
+      @actions << block if block_given?
+      self
+    end
+
+    def needs_execution?(context = {})
+      return true if @executed == false
+
+      return true if file_dependencies_changed?
+
+      @conditions.any? { |condition| !condition.call(context) }
+    end
+
+    def execute(context = {})
+      return if @executed
+
+      start_time = Time.now
+
+      puts "Executing target: #{@name}"
+      puts "  #{@description}" if @description
+      puts "  Namespace: #{@namespace}" if @namespace
+      puts "  Tags: #{@tags.join(", ")}" unless @tags.empty?
+
+      begin
+        @actions.each_with_index do |action, index|
+          puts "  Action #{index + 1}/#{@actions.size}" if @actions.size > 1
+
+          if action.arity == 0
+            action.call
+          else
+            action.call(context)
+          end
+        end
+
+        @executed = true
+        @last_run = Time.now
+
+        execution_time = Time.now - start_time
+        puts "  Completed in #{execution_time.round(2)}s"
+      rescue StandardError => e
+        puts "  Failed: #{e.message}"
+        raise Error, "Target '#{@name}' failed: #{e.message}"
+      end
+    end
+
+    def reset!
+      @executed = false
+    end
+
+    def file_dependencies_changed?
+      return false if @file_dependencies.empty? || @outputs.empty?
+
+      output_times = @outputs.map do |file|
+        File.exist?(file) ? File.mtime(file) : Time.at(0)
+      end
+      oldest_output = output_times.min
+
+      @file_dependencies.any? do |file|
+        File.exist?(file) && File.mtime(file) > oldest_output
+      end
+    end
+
+    def to_s
+      @name
+    end
+
+    def inspect
+      "#<Erebrus::Target:#{@name} ns=#{@namespace} deps=#{@dependencies} executed=#{@executed}>"
+    end
+  end
+end

data/lib/erebrus/version.rb

@@ -0,0 +1,3 @@
+module Erebrus
+  VERSION = "0.1.0"
+end

data/lib/erebrus.rb

@@ -0,0 +1,10 @@
+require_relative "erebrus/version"
+require_relative "erebrus/target"
+require_relative "erebrus/build_engine"
+require_relative "erebrus/dsl"
+
+module Erebrus
+  class Error < StandardError; end
+
+  extend DSL::ClassMethods
+end

data/sig/erebrus.rbs

@@ -0,0 +1,4 @@
+module Erebrus
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: erebrus
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- jel9
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+email:
+- chloedev@proton.me
+executables:
+- erebrus
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- bin/erebrus
+- examples/Buildfile
+- lib/erebrus.rb
+- lib/erebrus/build_engine.rb
+- lib/erebrus/dsl.rb
+- lib/erebrus/target.rb
+- lib/erebrus/version.rb
+- sig/erebrus.rbs
+homepage: https://github.com/daedalus-os/erebrus
+licenses: []
+metadata:
+  homepage_uri: https://github.com/daedalus-os/erebrus
+  source_code_uri: https://github.com/daedalus-os/erebrus
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Modern C/C++ build system like msbuild, with ruby instead of xml
+test_files: []