erebrus 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76b069200add69a2d85d26e12f70dd726611b1873e77f9ce0f39b66b5c836efb
-  data.tar.gz: 407eb8f255a7bdc2cc495a66d5dc712e93f467ca8a01f20ff95e5762a89f1add
+  metadata.gz: c0a0cf035d47b272eefe1385dd63919f5b6c58c75765248dc165f3ba942057b6
+  data.tar.gz: 637e125435680c16aefe62e318bc78990b2b0e1910d3c669071757996442279c
 SHA512:
-  metadata.gz: e41e9a1e3878050ba948b036576a7630f34d94cbaa9c5e897ce07eadbac10e18fe79ce5aa0d882ff5336178fd7a504e2ec1728552a2dd3a85d7f4f3304831360
-  data.tar.gz: 4a35080e1c2bd7025cc66510457ceba4d9372254cf42916f4908cba345f8ccbdc97cc92a8d833819d577010a2ffdd3c58b515896531dce39b3c49b5c2443152d
+  metadata.gz: 935badb603ccfa49c812c702fd884f143a130fa051fda3f66fab25080a704549c11df48fc4fb3d731dd3789a1225488d2bd3229a700a5ef0dcab42cb6136bd9f
+  data.tar.gz: '008219953c4f5ca5f9e245240bc824c7db35cba780830dee4e2fa58680fe3a8259a87350e4146f42bb91ab838381a51c0b8b899a960338e6eb4bdcd69496861d'

data/README.md

@@ -1,6 +1,6 @@
 # Erebrus
 
-Modern C/C++ build system like msbuild, with ruby instead of xml
+Modern Ruby based build system like make.
 
 ## Usage
 

data/bin/erebrus

@@ -5,147 +5,186 @@ 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"
+  class_option :color, type: :boolean, default: true, desc: "Enable colored output (--no-color to disable)"
+  class_option :dir, aliases: "-d", type: :string, desc: "Directory to run the build in"
 
   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
+    in_working_dir do
+      load_buildfile_with_error_handling
 
-    target_name = resolve_target_name(target)
+      target_name = resolve_target_name(target)
 
-    context = prepare_context
+      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
+      begin
+        Erebrus.build(target_name, context)
+      rescue Erebrus::Error => e
+        say_error "Build failed: #{e.message}"
+        exit 1
+      rescue StandardError => e
+        say_error "Unexpected error: #{e.message}"
+        puts e.backtrace if options[:verbose]
+        exit 1
+      end
     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
+    in_working_dir do
+      load_buildfile_with_error_handling
+
+      begin
+        puts "" # spacing for readability
+        if namespace
+          say_title("Targets in namespace '#{namespace}'")
+        else
+          say_title("Available targets")
+        end
+        if namespace
+          Erebrus.list_targets(namespace: namespace)
+        else
+          Erebrus.list_targets
+        end
+      rescue StandardError => e
+        say_error "Error listing targets: #{e.message}"
+        exit 1
       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
+    in_working_dir do
+      load_buildfile_with_error_handling
+
+      begin
+        say_title "Available namespaces"
+        Erebrus.list_namespaces
+      rescue StandardError => e
+        say_error "Error listing namespaces: #{e.message}"
+        exit 1
+      end
     end
   end
 
   desc "init [TYPE]", "Initializes the project with a sample Buildfile"
   def init(type = "basic")
-    buildfile = options[:file]
+    in_working_dir do
+      buildfile = options[:file]
 
-    if File.exist?(buildfile)
-      puts "Buildfile '#{buildfile}' already exists!"
-      return
-    end
+      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"
+      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)
+      say_success "Created #{buildfile} (#{type} template)"
+      say_info "Edit the file to define your build targets and run 'erebrus build' to build your project"
+    end
   end
 
   desc "validate", "Validates the Buildfile syntax"
   def validate
-    buildfile = options[:file]
+    in_working_dir do
+      buildfile = options[:file]
 
-    unless File.exist?(buildfile)
-      puts "Error: Buildfile '#{buildfile}' not found"
-      exit 1
-    end
+      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
+      begin
+        Erebrus.reset!
+        Erebrus.load_buildfile(buildfile)
+        say_success "Buildfile is valid \u2713"
+      rescue StandardError => e
+        say_error "Buildfile validation failed: #{e.message}"
+        exit 1
+      end
     end
   end
 
   desc "graph [TARGET]", "Shows dependency graph for target"
   def graph(target = nil)
-    load_buildfile_with_error_handling
+    in_working_dir do
+      load_buildfile_with_error_handling
 
-    target_name = resolve_target_name(target)
+      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
+      begin
+        say_title "Dependency graph for '#{target_name}'"
+        say_info "(Graph visualization not yet implemented)"
+      rescue StandardError => e
+        say_error "Error generating graph: #{e.message}"
+        exit 1
+      end
     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
+    in_working_dir do
+      load_buildfile_with_error_handling
+
+      begin
+        Erebrus.build("clean")
+      rescue Erebrus::Error => e
+        if e.message.include?("not found")
+          say_warn "No clean target defined"
+        else
+          say_error "Clean failed: #{e.message}"
+          exit 1
+        end
       end
     end
   end
 
   desc "version", "Show version"
   def version
-    puts "Erebrus #{Erebrus::VERSION}"
+    say_info "Erebrus #{Erebrus::VERSION}"
   end
 
   private
 
+  def in_working_dir
+    dir = options[:dir]
+    return yield unless dir
+
+    unless Dir.exist?(dir)
+      say_error "Error: directory '#{dir}' not found"
+      exit 1
+    end
+    old = Dir.pwd
+    Dir.chdir(dir)
+    begin
+      yield
+    ensure
+      Dir.chdir(old)
+    end
+  end
+
   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"
+      say_error "Error: Buildfile '#{buildfile}' not found"
+      say_info "Run 'erebrus init' to create a sample Buildfile"
       exit 1
     end
 
@@ -153,7 +192,7 @@ class ErebrusCommand < Thor
       Erebrus.reset!
       Erebrus.load_buildfile(buildfile)
     rescue StandardError => e
-      puts "Error loading buildfile: #{e.message}"
+      say_error "Error loading buildfile: #{e.message}"
       puts e.backtrace if options[:verbose]
       exit 1
     end
@@ -170,6 +209,7 @@ class ErebrusCommand < Thor
 
     context.merge!(options[:var]) if options[:var]
 
+    # Legacy variables for backward compatibility
     context["PLATFORM"] = RUBY_PLATFORM
     context["RUBY_VERSION"] = RUBY_VERSION
     context["PWD"] = Dir.pwd
@@ -177,6 +217,57 @@ class ErebrusCommand < Thor
     context
   end
 
+  # --- Styling helpers -----------------------------------------------------
+  def color_enabled?
+    options[:color] && $stdout.respond_to?(:isatty) && $stdout.isatty && ENV["NO_COLOR"].nil?
+  rescue StandardError
+    options[:color]
+  end
+
+  def color_code(color)
+    case color
+    when :black then 30
+    when :red then 31
+    when :green then 32
+    when :yellow then 33
+    when :blue then 34
+    when :magenta then 35
+    when :cyan then 36
+    when :white then 37
+    else nil
+    end
+  end
+
+  def c(text, color = nil, bold: false)
+    return text unless color_enabled? && (bold || color)
+
+    codes = []
+    codes << 1 if bold
+    cc = color_code(color)
+    codes << cc if cc
+    "\e[#{codes.join(";")}m#{text}\e[0m"
+  end
+
+  def say_title(msg)
+    puts c("==> #{msg}", :blue, bold: true)
+  end
+
+  def say_success(msg)
+    puts c(msg, :green, bold: true)
+  end
+
+  def say_error(msg)
+    puts c(msg, :red, bold: true)
+  end
+
+  def say_warn(msg)
+    puts c(msg, :yellow)
+  end
+
+  def say_info(msg)
+    puts c(msg, :cyan)
+  end
+
   def generate_basic_buildfile
     <<~BUILDFILE
       target :clean, description: "Clean build artifacts" do

data/examples/.gitignore

@@ -0,0 +1,5 @@
+dist/
+obj/
+package/
+build/
+/package

data/examples/Buildfile

@@ -1,6 +1,10 @@
 # Erebrus Buildfile Example
 # This demonstrates the Ruby build DSL for C/C++ projects
 
+# Global variables used in the example and templates
+set_variable "APP_NAME", "myapp"
+set_variable "VERSION", "1.0.0"
+
 target :clean, description: "Clean all build artifacts" do
   remove "build"
   remove "dist"
@@ -15,44 +19,53 @@ end
 
 target :configure, description: "Configure build environment" do
   depends_on :setup
-  
+
   action do |context|
-    puts "Configuring build for #{context[:platform] || 'default'} platform"
+    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"
+
+  action do
+    require "fileutils"
+    Dir.glob("*.o").each do |obj|
+      FileUtils.mv(obj, File.join("obj", File.basename(obj)))
+    end
+  end
 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"
+
+  action do
+    require "fileutils"
+    Dir.glob("*.o").each do |obj|
+      FileUtils.mv(obj, File.join("obj", File.basename(obj)))
+    end
+  end
 end
 
 target :link_main, description: "Link main executable" do
   depends_on :compile_sources
-  
-  run "g++ obj/*.o -o dist/myapp"
+
+  run "g++ obj/main.o obj/hello.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"
+
+  run "g++ obj/test_main.o obj/hello.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"
@@ -61,29 +74,65 @@ 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"
-  
+
+  platform :linux do
+    directory_exists "/usr/local/bin" do
+      copy "dist/myapp", "/usr/local/bin/myapp"
+    end
+  end
+  platform :windows do
+    directory_exists "C:/Users/Public" do
+      copy "dist/myapp", "C:/Users/Public/myapp.exe"
+    end
+  end
+  platform :darwin do
+    directory_exists "/usr/local/bin" do
+      copy "dist/myapp", "/usr/local/bin/myapp"
+    end
+  end
+
   action do
-    puts "Application installed to /usr/local/bin/myapp"
+    puts "Application installed for ${HOST_OS}"
   end
 end
 
 target :package, description: "Create distribution package" do
   depends_on :build
-  
+
+  # Ensure stale file or directory doesn't block packaging
+  remove "package"
   mkdir "package"
-  copy "dist/myapp", "package/"
-  copy "README.md", "package/"
-  copy "LICENSE", "package/"
-  
-  run "tar -czf dist/myapp-1.0.tar.gz -C package ."
+  # Copy executable (handle Windows .exe)
+  file_exists "dist/myapp" do
+    copy "dist/myapp", "package"
+  end
+  file_exists "dist/myapp.exe" do
+    copy "dist/myapp.exe", "package"
+  end
+  # Include docs
+  file_exists "README.md" do
+    copy "README.md", "package"
+  end
+  file_exists "LICENSE" do
+    copy "LICENSE", "package"
+  end
+
+  platform :linux do
+    run "tar -czf dist/myapp-1.0.tar.gz -C package ."
+  end
+  platform :darwin do
+    run "tar -czf dist/myapp-1.0.tar.gz -C package ."
+  end
+  platform :windows do
+    echo "Creating zip archive on Windows"
+    run "powershell -NoProfile -Command \"Compress-Archive -Path package/* -DestinationPath dist/myapp-1.0.zip -Force\""
+  end
   remove "package"
 end
 
@@ -92,5 +141,86 @@ target :all, description: "Build, test, and package" do
   depends_on :package
 end
 
+target :show_info, description: "Show host and environment info" do
+  echo "Host OS: ${HOST_OS}"
+  echo "Host Architecture: ${HOST_ARCH}"
+  echo "CPU Count: ${CPU_COUNT}"
+  echo "User: ${USER}"
+  echo "Home Directory: ${HOME}"
+  echo "Temp Directory: ${TEMP_DIR}"
+  echo "Build Time: ${BUILD_TIME}"
+  echo "Build Timestamp: ${BUILD_TIMESTAMP}"
+  echo "Ruby: ${RUBY_VERSION}"
+  echo "PWD: ${PWD}"
+end
+
+target :gen_config, description: "Generate config from template" do
+  depends_on :setup
+  template "templates/app_config.tpl", "dist/config.txt"
+end
+
+# Demonstrate write/append utilities
+target :write_demo, description: "Write and append notes" do
+  depends_on :setup
+  write "dist/notes.txt", "Build Notes\n"
+  append "dist/notes.txt", "Host: ${HOST_OS} ${HOST_ARCH}\n"
+  append "dist/notes.txt", "User: ${USER}\n"
+  append "dist/notes.txt", "Built at: ${BUILD_TIME}\n"
+  append "dist/notes.txt", "CPU Count: ${CPU_COUNT}\n"
+end
+
+# Demonstrate environment handling
+target :env_demo, description: "Run with temporary environment" do
+  with_env("MY_FLAG" => "42") do |ctx|
+    run "ruby -e \"puts ENV['MY_FLAG']\""
+  end
+end
+
+# Demonstrate optional symlink on Unix-like systems
+target :symlink_demo, description: "Create a symlink to myapp (Unix only)" do
+  depends_on :build
+  platform :linux do
+    symlink "dist/myapp", "dist/myapp_link"
+  end
+  platform :darwin do
+    symlink "dist/myapp", "dist/myapp_link"
+  end
+end
+
+# Parallel demonstration: compile sources and tests concurrently
+target :parallel_compile, description: "Compile sources and tests in parallel" do
+  parallel :compile_sources, :compile_tests
+end
+
+# Demonstrate conditional logic with system variables
+target :system_specific, description: "Show system-specific behavior" do
+  echo "Detected system: ${HOST_OS} on ${HOST_ARCH}"
+  
+  conditional(get_variable("HOST_OS") == "windows") do
+    echo "Running Windows-specific commands"
+    echo "User profile: ${HOME}"
+    echo "Temp directory: ${TEMP_DIR}"
+  end
+  
+  conditional(get_variable("HOST_ARCH") == "x64") do
+    echo "64-bit architecture detected"
+    echo "Using optimized 64-bit settings"
+  end
+  
+  # Show CPU-based logic
+  echo "System has ${CPU_COUNT} CPU cores available"
+end
+
+# Aggregate demo target
+target :demo, description: "Run all demonstration features" do
+  depends_on :show_info
+  depends_on :gen_config
+  depends_on :write_demo
+  depends_on :env_demo
+  depends_on :system_specific
+  depends_on :build
+  depends_on :symlink_demo
+end
+
 # Set the default target
-default :build
+default :build

data/examples/include/hello.hpp

@@ -0,0 +1,4 @@
+#pragma once
+#include <string>
+
+std::string hello();

data/examples/src/hello.cpp

@@ -0,0 +1,5 @@
+#include "../include/hello.hpp"
+
+std::string hello() {
+  return "Hello from Erebrus example";
+}

data/examples/src/main.cpp

@@ -0,0 +1,7 @@
+#include <iostream>
+#include "../include/hello.hpp"
+
+int main() {
+  std::cout << hello() << std::endl;
+  return 0;
+}

data/examples/templates/app_config.tpl

@@ -0,0 +1,8 @@
+# Application Configuration
+AppName={{APP_NAME}}
+Version={{VERSION}}
+HostOS={{HOST_OS}}
+Binary=dist/myapp
+
+# This file is generated by the Erebrus examples Buildfile.
+# You can reference variables defined via set_variable or passed context.

data/examples/tests/test_main.cpp

@@ -0,0 +1,10 @@
+#include <iostream>
+#include <cassert>
+#include "../include/hello.hpp"
+
+int main() {
+  std::string msg = hello();
+  assert(msg == "Hello from Erebrus example");
+  std::cout << "Test passed: hello() returns expected message" << std::endl;
+  return 0;
+}

data/lib/erebrus/build_engine.rb

@@ -1,4 +1,5 @@
 require "pathname"
+require "rbconfig"
 
 module Erebrus
   class BuildEngine
@@ -14,6 +15,19 @@ module Erebrus
       @included_files = Set.new
       @file_watchers = {}
       @conditional_stack = []
+      @progress_total = 0
+      @progress_count = 0
+      @progress_enabled = false
+      @progress_line_open = false
+      # Predefine useful system and build variables
+      @variables["HOST_OS"] = detect_host_os
+      @variables["HOST_ARCH"] = detect_host_arch
+      @variables["CPU_COUNT"] = detect_cpu_count
+      @variables["USER"] = detect_user
+      @variables["HOME"] = detect_home_dir
+      @variables["TEMP_DIR"] = detect_temp_dir
+      @variables["BUILD_TIME"] = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+      @variables["BUILD_TIMESTAMP"] = Time.now.to_i.to_s
     end
 
     def target(name, description: nil, namespace: nil, &block)
@@ -126,8 +140,16 @@ module Erebrus
 
       merged_context = @variables.merge(context)
 
+      # Setup build-level progress bar across targets to execute
+      target_obj = @targets[target_name]
+      to_run = collect_targets_to_run(target_obj)
+      @progress_total = to_run.size
+      @progress_count = 0
+      @progress_enabled = $stdout.respond_to?(:isatty) && $stdout.isatty
+
       reset_all_targets!
       execute_target(target_obj, merged_context)
+      finish_progress_bar if @progress_enabled
     end
 
     def list_targets(namespace: nil)
@@ -218,8 +240,8 @@ module Erebrus
       return if target.executed
 
       unless target.conditions.all? { |condition| condition.call(context) }
-        puts "Skipping target '#{target_name}' (conditions not met)"
         target.executed = true
+        increment_progress!
         return
       end
 
@@ -233,7 +255,10 @@ module Erebrus
         execute_target(dep_target, context, visited.dup)
       end
 
+      # Ensure progress bar line is terminated before any action output
+      finish_progress_bar if @progress_enabled
       target.execute(context)
+      increment_progress!
 
       visited.delete(target_name)
     end
@@ -241,6 +266,103 @@ module Erebrus
     def reset_all_targets!
       @targets.each_value(&:reset!)
     end
+
+    # Progress helpers -------------------------------------------------------
+    def collect_targets_to_run(root)
+      seen = Set.new
+      stack = [root]
+      until stack.empty?
+        t = stack.pop
+        next if seen.include?(t.name)
+
+        seen.add(t.name)
+        t.dependencies.each do |dep|
+          dep_name = resolve_target_name(dep)
+          dt = @targets[dep_name]
+          stack << dt if dt
+        end
+      end
+      seen
+    end
+
+    def increment_progress!
+      return unless @progress_enabled
+
+      @progress_count += 1
+      print_progress_bar(@progress_count, @progress_total)
+    end
+
+    def print_progress_bar(current, total)
+      current = [current, total].min
+      percent = total.zero? ? 100 : ((current.to_f / total) * 100).round
+      bar_length = 30
+      filled = (percent * bar_length / 100.0).round
+      bar = "[" + "#" * filled + " " * (bar_length - filled) + "]"
+      $stdout.print "\rProgress #{bar} #{percent}% (#{current}/#{total})"
+      $stdout.flush
+      @progress_line_open = true
+    end
+
+    def finish_progress_bar
+      return unless @progress_enabled
+      return unless @progress_line_open
+
+      $stdout.puts
+      @progress_line_open = false
+    end
+
+    private
+
+    def detect_host_os
+      host = RbConfig::CONFIG["host_os"].downcase
+      case host
+      when /mswin|mingw|cygwin/
+        "windows"
+      when /darwin|mac os/
+        "macos"
+      when /linux/
+        "linux"
+      when /freebsd|openbsd|netbsd/
+        "bsd"
+      else
+        "unknown"
+      end
+    end
+
+    def detect_host_arch
+      arch = RbConfig::CONFIG["host_cpu"].downcase
+      case arch
+      when /x86_64|amd64/
+        "x64"
+      when /i[3-6]86/
+        "x86"
+      when /arm64|aarch64/
+        "arm64"
+      when /arm/
+        "arm"
+      else
+        arch
+      end
+    end
+
+    def detect_cpu_count
+      require "etc"
+      Etc.nprocessors.to_s
+    rescue StandardError
+      "1"
+    end
+
+    def detect_user
+      ENV["USER"] || ENV["USERNAME"] || "unknown"
+    end
+
+    def detect_home_dir
+      ENV["HOME"] || ENV["USERPROFILE"] || Dir.pwd
+    end
+
+    def detect_temp_dir
+      ENV["TMPDIR"] || ENV["TMP"] || ENV["TEMP"] || "/tmp"
+    end
   end
 
   class TargetContext
@@ -277,10 +399,83 @@ module Erebrus
       @target.action(&block)
     end
 
+    def echo(message)
+      @target.action do |context|
+        puts expand_variables(message, context)
+      end
+    end
+
+    def sleep(seconds)
+      @target.action do |context|
+        s = expand_variables(seconds, context)
+        Kernel.sleep(s.to_f)
+      end
+    end
+
+    def move(source, destination)
+      @target.action do |context|
+        expanded_source = expand_variables(source, context)
+        expanded_dest = expand_variables(destination, context)
+        require "fileutils"
+        FileUtils.mv(expanded_source, expanded_dest)
+      end
+    end
+
+    def symlink(target, link_name)
+      @target.action do |context|
+        expanded_target = expand_variables(target, context)
+        expanded_link = expand_variables(link_name, context)
+        require "fileutils"
+        FileUtils.ln_s(expanded_target, expanded_link, force: true)
+      end
+    end
+
+    def write(file, content)
+      @target.action do |context|
+        expanded_file = expand_variables(file, context)
+        expanded_content = expand_variables(content, context)
+        File.write(expanded_file, expanded_content)
+      end
+    end
+
+    def append(file, content)
+      @target.action do |context|
+        expanded_file = expand_variables(file, context)
+        expanded_content = expand_variables(content, context)
+        File.open(expanded_file, "a") { |f| f.write(expanded_content) }
+      end
+    end
+
+    def with_env(vars = {})
+      @target.action do |context|
+        merged = vars.transform_keys(&:to_s).transform_values { |v| expand_variables(v, context).to_s }
+        backup = {}
+        merged.each do |k, v|
+          backup[k] = ENV[k]
+          ENV[k] = v
+        end
+        begin
+          yield(context) if block_given?
+        ensure
+          merged.each_key { |k| ENV[k] = backup[k] }
+        end
+      end
+    end
+
+    def run_set(name, command)
+      @target.action do |context|
+        expanded_command = expand_variables(command, context)
+        puts "Running (capture): #{expanded_command}"
+        result = `#{expanded_command}`
+        raise Error, "Command failed: #{expanded_command}" unless $?.success?
+
+        @engine&.set_variable(name, result.chomp)
+      end
+    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}`
@@ -297,8 +492,6 @@ module Erebrus
       @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]
@@ -312,7 +505,6 @@ module Erebrus
     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
@@ -321,7 +513,6 @@ module Erebrus
     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
@@ -330,7 +521,6 @@ module Erebrus
     def touch(path)
       @target.action do |context|
         expanded_path = expand_variables(path, context)
-        puts "Touching: #{expanded_path}"
         require "fileutils"
         FileUtils.touch(expanded_path)
       end
@@ -339,7 +529,6 @@ module Erebrus
     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
@@ -349,8 +538,6 @@ module Erebrus
       @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"
 
@@ -371,8 +558,6 @@ module Erebrus
         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)
 

data/lib/erebrus/target.rb

@@ -75,15 +75,8 @@ module Erebrus
 
       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
@@ -93,11 +86,7 @@ module Erebrus
 
         @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

data/lib/erebrus/version.rb

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

data/sig/erebrus/build_engine.rbs

@@ -0,0 +1,78 @@
+module Erebrus
+  class BuildEngine
+    attr_reader targets: Hash[String, Erebrus::Target]
+    attr_reader namespaces: Hash[String, Array[String]]
+    attr_reader variables: Hash[String, untyped]
+    attr_reader included_files: ::Set[String]
+
+    attr_accessor current_namespace: String?
+
+    def initialize: () -> void
+
+    def target: ((String | Symbol) name, description?: String?, namespace?: String?, ?{ () -> void }) -> Erebrus::Target
+    def namespace: ((String | Symbol) name) { () -> void } -> void
+    def include_buildfile: (String file_path, namespace?: String?) -> void
+
+    def set_variable: ((String | Symbol) name, untyped value) -> void
+    def get_variable: ((String | Symbol) name, untyped? default) -> untyped
+
+    def conditional: (untyped condition) { () -> void } -> void
+
+    def platform?: ((String | Symbol) name) -> bool
+    def file_exists?: (String path) -> bool
+    def directory_exists?: (String path) -> bool
+
+    def default: ((String | Symbol) target_name) -> void
+    def build: (? (String | Symbol) target_name, ?Hash[Symbol | String, untyped] context) -> void
+
+    def list_targets: (namespace?: String) -> void
+    def list_namespaces: () -> void
+
+    def watch_file: (String pattern) { (String) -> untyped } -> void
+    def check_file_changes: () -> void
+  end
+
+  class TargetContext
+    def initialize: (Erebrus::Target target, ?Erebrus::BuildEngine engine) -> void
+
+    def depends_on: (* (String | Symbol) deps) -> Erebrus::Target
+    def depends_on_files: (* String files) -> Erebrus::Target
+    def produces: (* String files) -> Erebrus::Target
+
+    def condition: () ?{ (Hash[Symbol | String, untyped]) -> bool } -> Erebrus::Target
+    def only_if: ((::Proc | Symbol | String | bool) condition) -> Erebrus::Target
+
+    def tag: (* (String | Symbol) tags) -> Erebrus::Target
+
+    def action: () { () -> untyped } -> Erebrus::Target
+               | () { (Hash[Symbol | String, untyped]) -> untyped } -> Erebrus::Target
+               | () -> Erebrus::Target
+
+    def run: (String command, Hash[Symbol, untyped]? options) -> Erebrus::Target
+    def copy: (String source, String destination, Hash[Symbol, untyped]? options) -> Erebrus::Target
+    def mkdir: (String path) -> Erebrus::Target
+    def remove: (String path) -> Erebrus::Target
+    def touch: (String path) -> Erebrus::Target
+    def chmod: (Integer mode, String path) -> Erebrus::Target
+    def download: (String url, String destination) -> Erebrus::Target
+    def template: (String template_file, String output_file, Hash[Symbol | String, untyped]? variables) -> Erebrus::Target
+    def parallel: (* (String | Symbol) targets) -> Erebrus::Target
+
+    def conditional: (untyped condition) { (Hash[Symbol | String, untyped]) -> untyped } -> Erebrus::Target
+    def platform: ((String | Symbol) name) { (Hash[Symbol | String, untyped]) -> untyped } -> Erebrus::Target
+    def file_exists: (String path) { (Hash[Symbol | String, untyped]) -> untyped } -> Erebrus::Target
+    def directory_exists: (String path) { (Hash[Symbol | String, untyped]) -> untyped } -> Erebrus::Target
+
+    def set_variable: ((String | Symbol) name, untyped value) -> Erebrus::Target
+    def get_variable: ((String | Symbol) name, untyped? default) -> untyped
+
+    def echo: (String message) -> Erebrus::Target
+    def sleep: ((Integer | Float | String) seconds) -> Erebrus::Target
+    def move: (String source, String destination) -> Erebrus::Target
+    def symlink: (String target, String link_name) -> Erebrus::Target
+    def write: (String file, String content) -> Erebrus::Target
+    def append: (String file, String content) -> Erebrus::Target
+    def with_env: (Hash[Symbol | String, untyped] vars) { (Hash[Symbol | String, untyped]) -> untyped } -> Erebrus::Target
+    def run_set: ((String | Symbol) name, String command) -> Erebrus::Target
+  end
+end

data/sig/erebrus/dsl.rbs

@@ -0,0 +1,37 @@
+module Erebrus
+  module DSL
+    def self.included: (untyped base) -> void
+
+    module ClassMethods
+      def build_engine: () -> Erebrus::BuildEngine
+
+      def target: ((String | Symbol) name, description?: String?, namespace?: String?, ?{ () -> void }) -> Erebrus::Target
+      def namespace: ((String | Symbol) name) { () -> void } -> void
+      def include_buildfile: (String file_path, namespace?: String?) -> void
+
+      def set_variable: ((String | Symbol) name, untyped value) -> void
+      def get_variable: ((String | Symbol) name, untyped? default) -> untyped
+
+      def conditional: (untyped condition) { () -> void } -> void
+      def platform?: ((String | Symbol) name) -> bool
+      def default: ((String | Symbol) target_name) -> void
+      def build: (? (String | Symbol) target_name, ?Hash[Symbol | String, untyped] context) -> void
+      def list_targets: (namespace?: String) -> void
+      def list_namespaces: () -> void
+    end
+
+    def target: ((String | Symbol) name, description?: String?, namespace?: String?, ?{ () -> void }) -> Erebrus::Target
+    def namespace: ((String | Symbol) name) { () -> void } -> void
+    def include_buildfile: (String file_path, namespace?: String?) -> void
+
+    def set_variable: ((String | Symbol) name, untyped value) -> void
+    def get_variable: ((String | Symbol) name, untyped? default) -> untyped
+
+    def conditional: (untyped condition) { () -> void } -> void
+    def platform?: ((String | Symbol) name) -> bool
+    def default: ((String | Symbol) target_name) -> void
+    def build: (? (String | Symbol) target_name, ?Hash[Symbol | String, untyped] context) -> void
+    def list_targets: (namespace?: String) -> void
+    def list_namespaces: () -> void
+  end
+end

data/sig/erebrus/target.rbs

@@ -0,0 +1,37 @@
+module Erebrus
+  class Target
+    attr_reader name: String
+    attr_reader dependencies: Array[String]
+    attr_reader description: String?
+    attr_reader conditions: Array[::Proc]
+    attr_reader file_dependencies: Array[String]
+    attr_reader outputs: Array[String]
+
+    attr_accessor executed: bool
+    attr_accessor namespace: String?
+    attr_accessor tags: Array[String]
+    attr_accessor priority: Integer
+
+    def initialize: ((String | Symbol) name, ?description: String?) -> void
+
+    def depends_on: (* (String | Symbol) deps) -> Erebrus::Target
+    def depends_on_files: (* String files) -> Erebrus::Target
+    def produces: (* String files) -> Erebrus::Target
+
+    def condition: () ?{ (Hash[Symbol | String, untyped]) -> bool } -> Erebrus::Target
+    def only_if: ((::Proc | Symbol | String | bool) condition) -> Erebrus::Target
+
+    def tag: (* (String | Symbol) tags) -> Erebrus::Target
+
+    def action: () { () -> untyped } -> Erebrus::Target
+               | () { (Hash[Symbol | String, untyped]) -> untyped } -> Erebrus::Target
+               | () -> Erebrus::Target
+
+    def needs_execution?: (?Hash[Symbol | String, untyped]) -> bool
+    def execute: (?Hash[Symbol | String, untyped]) -> void
+    def reset!: () -> void
+    def file_dependencies_changed?: () -> bool
+    def to_s: () -> String
+    def inspect: () -> String
+  end
+end

data/sig/erebrus.rbs

@@ -1,4 +1,23 @@
 module Erebrus
   VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  
+  class Error < ::StandardError
+  end
+
+  def self.target: ((String | Symbol) name, description?: String?, namespace?: String?, ?{ () -> void }) -> Erebrus::Target
+  def self.namespace: ((String | Symbol) name) { () -> void } -> void
+  def self.include_buildfile: (String file_path, namespace?: String?) -> void
+
+  def self.set_variable: ((String | Symbol) name, untyped value) -> void
+  def self.get_variable: ((String | Symbol) name, untyped? default) -> untyped
+
+  def self.conditional: (untyped condition) { () -> void } -> void
+  def self.platform?: ((String | Symbol) name) -> bool
+  def self.default: ((String | Symbol) target_name) -> void
+  def self.build: (? (String | Symbol) target_name, ?Hash[Symbol | String, untyped] context) -> void
+  def self.list_targets: (namespace?: String) -> void
+  def self.list_namespaces: () -> void
+
+  def self.load_buildfile: (String file_path) -> void
+  def self.reset!: () -> void
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: erebrus
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - jel9
@@ -34,13 +34,22 @@ files:
 - README.md
 - Rakefile
 - bin/erebrus
+- examples/.gitignore
 - examples/Buildfile
+- examples/include/hello.hpp
+- examples/src/hello.cpp
+- examples/src/main.cpp
+- examples/templates/app_config.tpl
+- examples/tests/test_main.cpp
 - lib/erebrus.rb
 - lib/erebrus/build_engine.rb
 - lib/erebrus/dsl.rb
 - lib/erebrus/target.rb
 - lib/erebrus/version.rb
 - sig/erebrus.rbs
+- sig/erebrus/build_engine.rbs
+- sig/erebrus/dsl.rbs
+- sig/erebrus/target.rbs
 homepage: https://github.com/daedalus-os/erebrus
 licenses: []
 metadata:
@@ -62,5 +71,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: Modern C/C++ build system like msbuild, with ruby instead of xml
+summary: Modern Ruby based build system like make.
 test_files: []