kompo 0.3.2 → 0.4.0

data/lib/kompo/tasks/cargo_path.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'open3'
+require "open3"
 
 module Kompo
   # Section to get the Cargo path.
@@ -16,15 +16,15 @@ module Kompo
     class Installed < Taski::Task
       def run
         # First check PATH, then fallback to default rustup location
-        cargo_in_path, = Open3.capture2('which', 'cargo', err: File::NULL)
+        cargo_in_path, = Open3.capture2("which", "cargo", err: File::NULL)
         cargo_in_path = cargo_in_path.chomp
         @path = if cargo_in_path.empty?
-                  File.expand_path('~/.cargo/bin/cargo')
-                else
-                  cargo_in_path
-                end
+          File.expand_path("~/.cargo/bin/cargo")
+        else
+          cargo_in_path
+        end
         puts "Cargo path: #{@path}"
-        version_output, = Open3.capture2e(@path, '--version')
+        version_output, = Open3.capture2e(@path, "--version")
         puts "Cargo version: #{version_output.chomp}"
       end
     end
@@ -32,14 +32,14 @@ module Kompo
     # Install Cargo via rustup and return the path
     class Install < Taski::Task
       def run
-        puts 'Cargo not found. Installing via rustup...'
+        puts "Cargo not found. Installing via rustup..."
         system("curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y")
 
-        @path = File.expand_path('~/.cargo/bin/cargo')
-        raise 'Failed to install Cargo' unless File.executable?(@path)
+        @path = File.expand_path("~/.cargo/bin/cargo")
+        raise "Failed to install Cargo" unless File.executable?(@path)
 
         puts "Cargo installed at: #{@path}"
-        version_output, = Open3.capture2e(@path, '--version')
+        version_output, = Open3.capture2e(@path, "--version")
         puts "Cargo version: #{version_output.chomp}"
       end
     end
@@ -48,11 +48,11 @@ module Kompo
 
     def cargo_installed?
       # Check if cargo is in PATH
-      cargo_in_path, = Open3.capture2('which', 'cargo', err: File::NULL)
+      cargo_in_path, = Open3.capture2("which", "cargo", err: File::NULL)
       return true unless cargo_in_path.chomp.empty?
 
       # Check default rustup installation location
-      home_cargo = File.expand_path('~/.cargo/bin/cargo')
+      home_cargo = File.expand_path("~/.cargo/bin/cargo")
       File.executable?(home_cargo)
     end
   end

data/lib/kompo/tasks/check_stdlibs.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'open3'
+require "open3"
 
 module Kompo
   # Get Ruby standard library paths from installed Ruby
@@ -12,7 +12,7 @@ module Kompo
       no_stdlib = Taski.args.fetch(:no_stdlib, false)
       if no_stdlib
         @paths = []
-        puts 'Skipping standard library (--no-stdlib)'
+        puts "Skipping standard library (--no-stdlib)"
         return
       end
 
@@ -24,9 +24,9 @@ module Kompo
       # Include the Ruby standard library root directory
       # This includes bundler and other default gems that are not in $:
       # Ruby uses "X.Y.0" format for lib/ruby paths (e.g., "3.4.0" not "3.4")
-      stdlib_root = File.join(ruby_install_dir, 'lib', 'ruby', "#{ruby_major_minor}.0")
+      stdlib_root = File.join(ruby_install_dir, "lib", "ruby", "#{ruby_major_minor}.0")
       # RubyGems needs gemspec files in specifications/ directory
-      gems_specs_root = File.join(ruby_install_dir, 'lib', 'ruby', 'gems', "#{ruby_major_minor}.0", 'specifications')
+      gems_specs_root = File.join(ruby_install_dir, "lib", "ruby", "gems", "#{ruby_major_minor}.0", "specifications")
 
       if Dir.exist?(stdlib_root)
         @paths = [stdlib_root, gems_specs_root].select { |p| Dir.exist?(p) }
@@ -34,7 +34,7 @@ module Kompo
         puts "Including gem specifications: #{gems_specs_root}" if Dir.exist?(gems_specs_root)
       else
         # Fallback to $: paths if stdlib root doesn't exist
-        output, status = Open3.capture2(ruby, '-e', 'puts $:', err: File::NULL)
+        output, status = Open3.capture2(ruby, "-e", "puts $:", err: File::NULL)
         unless status.success?
           raise "Failed to get Ruby standard library paths: exit code #{status.exitstatus}, output: #{output}"
         end
@@ -42,7 +42,7 @@ module Kompo
         raw_paths = output.split("\n").reject(&:empty?)
 
         @paths = raw_paths.map do |path|
-          next nil unless path.start_with?('/')
+          next nil unless path.start_with?("/")
 
           if original_ruby_install_dir != ruby_install_dir && path.start_with?(original_ruby_install_dir)
             path.sub(original_ruby_install_dir, ruby_install_dir)

data/lib/kompo/tasks/collect_dependencies.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'fileutils'
+require "fileutils"
 
 module Kompo
   # Collect all dependencies for packing.
@@ -20,7 +20,7 @@ module Kompo
       project_dir = Taski.args.fetch(:project_dir, Taski.env.working_directory) || Taski.env.working_directory
       output_arg = Taski.args.fetch(:output_dir, Taski.env.working_directory) || Taski.env.working_directory
 
-      @deps = group('Collecting dependencies') do
+      @deps = group("Collecting dependencies") do
         collect_dependencies
       end
 
@@ -36,33 +36,31 @@ module Kompo
 
       @ext_paths = get_unique_ext_paths(@work_dir, @deps.ruby_build_path, @deps.ruby_version, @deps.exts_dir)
       @enc_files = [
-        File.join(@deps.ruby_build_path, "ruby-#{@deps.ruby_version}", 'enc/encinit.o'),
-        File.join(@deps.ruby_build_path, "ruby-#{@deps.ruby_version}", 'enc/libenc.a'),
-        File.join(@deps.ruby_build_path, "ruby-#{@deps.ruby_version}", 'enc/libtrans.a')
+        File.join(@deps.ruby_build_path, "ruby-#{@deps.ruby_version}", "enc/encinit.o"),
+        File.join(@deps.ruby_build_path, "ruby-#{@deps.ruby_version}", "enc/libenc.a"),
+        File.join(@deps.ruby_build_path, "ruby-#{@deps.ruby_version}", "enc/libtrans.a")
       ]
 
-      puts 'All dependencies collected for packing'
+      puts "All dependencies collected for packing"
     end
 
     private
 
     def collect_dependencies
-      # Install dependencies based on platform (Homebrew on macOS, pkg-config check on Linux)
-      InstallDeps.run
       deps_lib_paths = InstallDeps.lib_paths
 
       ruby_install_dir = InstallRuby.ruby_install_dir
       ruby_version = InstallRuby.ruby_version
       ruby_major_minor = InstallRuby.ruby_major_minor
       ruby_build_path = InstallRuby.ruby_build_path
-      ruby_lib = File.join(ruby_install_dir, 'lib')
+      ruby_lib = File.join(ruby_install_dir, "lib")
 
       kompo_lib = KompoVfsPath.path
       main_c = MakeMainC.path
       fs_c = MakeFsC.path
       exts_dir = BuildNativeGem.exts_dir
 
-      puts 'Dependencies collected'
+      puts "Dependencies collected"
 
       Dependencies.new(
         ruby_install_dir: ruby_install_dir,
@@ -79,19 +77,29 @@ module Kompo
     end
 
     def get_unique_ext_paths(_work_dir, ruby_build_path, ruby_version, exts_dir)
+      ruby_build_dir = File.join(ruby_build_path, "ruby-#{ruby_version}")
+
       # Ruby standard extension .o files
-      paths = Dir.glob(File.join(ruby_build_path, "ruby-#{ruby_version}", 'ext', '**', '*.o'))
+      paths = Dir.glob(File.join(ruby_build_dir, "ext", "**", "*.o"))
+
+      # Ruby bundled gems .o files (Ruby 4.0+)
+      # Skip if --no-stdlib is specified (bundled gems are part of stdlib)
+      no_stdlib = Taski.args.fetch(:no_stdlib, false)
+      unless no_stdlib
+        bundled_gems_paths = Dir.glob(File.join(ruby_build_dir, ".bundle", "gems", "*", "ext", "**", "*.o"))
+        paths += bundled_gems_paths
+      end
 
       # Extract extension path (everything after /ext/) for deduplication
       # e.g., ".../ext/cgi/escape/escape.o" -> "cgi/escape/escape.o"
-      ruby_ext_keys = paths.map { |p| p.split('/ext/').last }
+      ruby_ext_keys = paths.map { |p| p.split("/ext/").last }
 
       # Gem extension .o files (excluding duplicates with Ruby std)
       if exts_dir && Dir.exist?(exts_dir)
         gem_ext_paths = Dir.glob("#{exts_dir}/**/*.o")
-                           .to_h { |p| [p.split('/ext/').last, p] }
-                           .except(*ruby_ext_keys)
-                           .values
+          .to_h { |p| [p.split("/ext/").last, p] }
+          .except(*ruby_ext_keys)
+          .values
         paths += gem_ext_paths
       end
 

data/lib/kompo/tasks/copy_gemfile.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'fileutils'
+require "fileutils"
 
 module Kompo
   # Copy Gemfile, Gemfile.lock, and gemspec files to working directory if they exist
@@ -11,25 +11,33 @@ module Kompo
       work_dir = WorkDir.path
       project_dir = Taski.args.fetch(:project_dir, Taski.env.working_directory) || Taski.env.working_directory
 
-      gemfile_path = File.join(project_dir, 'Gemfile')
-      gemfile_lock_path = File.join(project_dir, 'Gemfile.lock')
+      # Skip Gemfile processing if --no-gemfile is specified
+      if Taski.args[:no_gemfile]
+        puts "Skipping Gemfile (--no-gemfile specified)"
+        @gemfile_exists = false
+        @gemspec_paths = []
+        return
+      end
+
+      gemfile_path = File.join(project_dir, "Gemfile")
+      gemfile_lock_path = File.join(project_dir, "Gemfile.lock")
 
       @gemfile_exists = File.exist?(gemfile_path)
       @gemspec_paths = []
 
       if @gemfile_exists
         FileUtils.cp(gemfile_path, work_dir)
-        puts 'Copied: Gemfile'
+        puts "Copied: Gemfile"
 
         if File.exist?(gemfile_lock_path)
           FileUtils.cp(gemfile_lock_path, work_dir)
-          puts 'Copied: Gemfile.lock'
+          puts "Copied: Gemfile.lock"
         end
 
         # Copy gemspec files if Gemfile references gemspec
         copy_gemspec_if_needed(gemfile_path, project_dir, work_dir)
       else
-        puts 'No Gemfile found, skipping'
+        puts "No Gemfile found, skipping"
       end
     end
 
@@ -39,8 +47,8 @@ module Kompo
       work_dir = WorkDir.path
       return unless work_dir && Dir.exist?(work_dir)
 
-      gemfile = File.join(work_dir, 'Gemfile')
-      gemfile_lock = File.join(work_dir, 'Gemfile.lock')
+      gemfile = File.join(work_dir, "Gemfile")
+      gemfile_lock = File.join(work_dir, "Gemfile.lock")
 
       FileUtils.rm_f(gemfile)
       FileUtils.rm_f(gemfile_lock)
@@ -50,7 +58,7 @@ module Kompo
         FileUtils.rm_f(gemspec)
       end
 
-      puts 'Cleaned up Gemfile'
+      puts "Cleaned up Gemfile"
     end
 
     private
@@ -62,7 +70,7 @@ module Kompo
       return unless gemfile_content.match?(/^\s*gemspec\b/)
 
       # Copy all .gemspec files from project directory
-      gemspec_files = Dir.glob(File.join(project_dir, '*.gemspec'))
+      gemspec_files = Dir.glob(File.join(project_dir, "*.gemspec"))
       gemspec_files.each do |gemspec_path|
         dest_path = File.join(work_dir, File.basename(gemspec_path))
         FileUtils.cp(gemspec_path, dest_path)
@@ -71,7 +79,7 @@ module Kompo
       end
 
       if gemspec_files.empty?
-        warn 'Warning: Gemfile contains gemspec directive but no .gemspec files found'
+        warn "Warning: Gemfile contains gemspec directive but no .gemspec files found"
       end
     end
   end

data/lib/kompo/tasks/copy_project_files.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'fileutils'
+require "fileutils"
 
 module Kompo
   # Copy project files (entrypoint and additional files) to working directory
@@ -10,7 +10,7 @@ module Kompo
     def run
       work_dir = WorkDir.path
       project_dir = Taski.args.fetch(:project_dir, Taski.env.working_directory) || Taski.env.working_directory
-      entrypoint = Taski.args.fetch(:entrypoint, 'main.rb')
+      entrypoint = Taski.args.fetch(:entrypoint, "main.rb")
       files = Taski.args.fetch(:files, [])
 
       # Copy entrypoint (preserve relative path structure)
@@ -54,7 +54,7 @@ module Kompo
 
         if File.directory?(src)
           # Special handling for "." - copy directory contents directly to work_dir
-          if file == '.' || real_src == real_project_dir
+          if file == "." || real_src == real_project_dir
             copy_directory_contents(src, work_dir)
             @additional_paths << work_dir
           else
@@ -90,7 +90,7 @@ module Kompo
         # Only delete if path is inside work_dir
         FileUtils.rm_rf(path) if expanded_path.start_with?(real_work_dir + File::SEPARATOR) && File.exist?(path)
       end
-      puts 'Cleaned up project files'
+      puts "Cleaned up project files"
     end
 
     private

data/lib/kompo/tasks/find_native_extensions.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'open3'
+require "open3"
 
 module Kompo
   # Find native gem extensions that need to be built
@@ -12,22 +12,32 @@ module Kompo
     def run
       @extensions = []
 
-      # Skip if no Gemfile
-      unless CopyGemfile.gemfile_exists
-        puts 'No Gemfile, no native extensions to find'
-        return
-      end
-
       ruby_version = InstallRuby.ruby_version
       ruby_build_path = InstallRuby.ruby_build_path
       ruby_install_dir = InstallRuby.ruby_install_dir
-      bundle_ruby_dir = BundleInstall.bundle_ruby_dir
 
       # Get Init functions already defined in libruby-static
       builtin_init_funcs = get_builtin_init_functions(ruby_install_dir)
 
+      # Find bundled gems with native extensions (Ruby 4.0+)
+      # Skip if --no-stdlib is specified (bundled gems are part of stdlib)
+      no_stdlib = Taski.args.fetch(:no_stdlib, false)
+      unless no_stdlib
+        bundled_gems_dir = File.join(ruby_build_path, "ruby-#{ruby_version}", ".bundle", "gems")
+        find_bundled_gem_extensions(bundled_gems_dir, builtin_init_funcs)
+      end
+
+      # Skip user gems if no Gemfile
+      unless CopyGemfile.gemfile_exists
+        puts "No Gemfile, skipping user gem native extensions"
+        puts "Found #{@extensions.size} native extensions to build"
+        return
+      end
+
+      bundle_ruby_dir = BundleInstall.bundle_ruby_dir
+
       # Find all native extensions in installed gems
-      extconf_files = Dir.glob(File.join(bundle_ruby_dir, 'gems/**/extconf.rb'))
+      extconf_files = Dir.glob(File.join(bundle_ruby_dir, "gems/**/extconf.rb"))
 
       extconf_files.each do |extconf_path|
         dir_name = File.dirname(extconf_path)
@@ -42,21 +52,37 @@ module Kompo
         end
 
         # Skip if this extension is part of Ruby standard library
-        ruby_std_lib = dir_name.split('/').drop_while { |p| p != 'ext' }.join('/')
-        ruby_ext_objects = Dir.glob(File.join(ruby_build_path, "ruby-#{ruby_version}", 'ext', '**', '*.o'))
+        ruby_std_lib = dir_name.split("/").drop_while { |p| p != "ext" }.join("/")
+        ruby_ext_objects = Dir.glob(File.join(ruby_build_path, "ruby-#{ruby_version}", "ext", "**", "*.o"))
         if ruby_ext_objects.any? { |o| o.include?(ruby_std_lib) }
           puts "skip: #{gem_ext_name} is included in Ruby standard library"
           next
         end
 
-        cargo_toml = File.join(dir_name, 'Cargo.toml')
+        # Check if already added (e.g., as bundled gem)
+        # Prefer Gemfile versions over prebuilt bundled gems
+        existing = @extensions.find { |e| e[:gem_ext_name] == gem_ext_name }
+        if existing
+          if existing[:is_prebuilt]
+            # Replace prebuilt bundled gem with Gemfile version
+            puts "replacing: #{gem_ext_name} prebuilt bundled gem with Gemfile version"
+            @extensions.delete(existing)
+          else
+            # Already added as non-prebuilt, skip
+            puts "skip: #{gem_ext_name} is already added"
+            next
+          end
+        end
+
+        cargo_toml = File.join(dir_name, "Cargo.toml")
         is_rust = File.exist?(cargo_toml)
 
         @extensions << {
           dir_name: dir_name,
           gem_ext_name: gem_ext_name,
           is_rust: is_rust,
-          cargo_toml: is_rust ? cargo_toml : nil
+          cargo_toml: is_rust ? cargo_toml : nil,
+          is_prebuilt: false
         }
       end
 
@@ -65,15 +91,52 @@ module Kompo
 
     private
 
+    # Find native extensions in Ruby's bundled gems directory (Ruby 4.0+)
+    # These are pre-built during Ruby compilation
+    def find_bundled_gem_extensions(bundled_gems_dir, builtin_init_funcs)
+      return unless Dir.exist?(bundled_gems_dir)
+
+      extconf_files = Dir.glob(File.join(bundled_gems_dir, "**/extconf.rb"))
+
+      extconf_files.each do |extconf_path|
+        dir_name = File.dirname(extconf_path)
+        gem_ext_name = File.basename(dir_name)
+
+        # Skip if Init function is already defined in libruby-static
+        init_func = "Init_#{gem_ext_name}"
+        if builtin_init_funcs.include?(init_func)
+          puts "skip: #{gem_ext_name} is already built into Ruby (#{init_func} found in libruby-static)"
+          next
+        end
+
+        # Verify that .o files exist (pre-built)
+        # Search recursively since object files may be in subdirectories
+        o_files = Dir.glob(File.join(dir_name, "**", "*.o"))
+        if o_files.empty?
+          puts "skip: #{gem_ext_name} has no pre-built .o files"
+          next
+        end
+
+        puts "Found bundled gem extension: #{gem_ext_name} (pre-built)"
+        @extensions << {
+          dir_name: dir_name,
+          gem_ext_name: gem_ext_name,
+          is_rust: false,
+          cargo_toml: nil,
+          is_prebuilt: true
+        }
+      end
+    end
+
     # Extract Init_ function names from libruby-static using nm
     def get_builtin_init_functions(ruby_install_dir)
-      lib_dir = File.join(ruby_install_dir, 'lib')
-      static_lib = Dir.glob(File.join(lib_dir, 'libruby*-static.a')).first
+      lib_dir = File.join(ruby_install_dir, "lib")
+      static_lib = Dir.glob(File.join(lib_dir, "libruby*-static.a")).first
       return Set.new unless static_lib
 
       # Use nm to extract defined Init_ symbols (T = text/code section)
       # Use Open3.capture2 with array form to avoid shell injection
-      output, status = Open3.capture2('nm', static_lib, err: File::NULL)
+      output, status = Open3.capture2("nm", static_lib, err: File::NULL)
       return Set.new unless status.success?
 
       # Filter lines matching " T _?Init_" pattern and extract the symbol name
@@ -82,7 +145,7 @@ module Kompo
       symbols.map do |line|
         # Third whitespace-separated field is the symbol name
         symbol = line.split[2]
-        symbol&.delete_prefix('_')
+        symbol&.delete_prefix("_")
       end.compact.to_set
     end
   end

data/lib/kompo/tasks/homebrew.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'open3'
+require "open3"
 
 module Kompo
   # Section to get the Homebrew path.
@@ -9,7 +9,7 @@ module Kompo
     interfaces :path
 
     # Common Homebrew installation paths
-    COMMON_BREW_PATHS = ['/opt/homebrew/bin/brew', '/usr/local/bin/brew'].freeze
+    COMMON_BREW_PATHS = ["/opt/homebrew/bin/brew", "/usr/local/bin/brew"].freeze
 
     def impl
       homebrew_installed? ? Installed : Install
@@ -19,27 +19,27 @@ module Kompo
     class Installed < Taski::Task
       def run
         # First check PATH
-        brew_in_path, = Open3.capture2('which', 'brew', err: File::NULL)
+        brew_in_path, = Open3.capture2("which", "brew", err: File::NULL)
         brew_in_path = brew_in_path.chomp
         @path = if brew_in_path.empty?
-                  # Fallback to common installation paths
-                  HomebrewPath::COMMON_BREW_PATHS.find { |p| File.executable?(p) }
-                else
-                  brew_in_path
-                end
+          # Fallback to common installation paths
+          HomebrewPath::COMMON_BREW_PATHS.find { |p| File.executable?(p) }
+        else
+          brew_in_path
+        end
         puts "Homebrew path: #{@path}"
       end
     end
 
     # Install Homebrew
     class Install < Taski::Task
-      MARKER_FILE = File.expand_path('~/.kompo_installed_homebrew')
+      MARKER_FILE = File.expand_path("~/.kompo_installed_homebrew")
 
       def run
-        puts 'Homebrew not found. Installing...'
+        puts "Homebrew not found. Installing..."
         system('/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"')
 
-        brew_in_path, = Open3.capture2('which', 'brew', err: File::NULL)
+        brew_in_path, = Open3.capture2("which", "brew", err: File::NULL)
         @path = brew_in_path.chomp
         if @path.empty?
           # Check common installation paths
@@ -51,7 +51,7 @@ module Kompo
           end
         end
 
-        raise 'Failed to install Homebrew' if @path.nil? || @path.empty?
+        raise "Failed to install Homebrew" if @path.nil? || @path.empty?
 
         # Mark that kompo installed Homebrew
         File.write(MARKER_FILE, @path)
@@ -62,10 +62,10 @@ module Kompo
         # Only uninstall if kompo installed it
         return unless File.exist?(MARKER_FILE)
 
-        puts 'Uninstalling Homebrew (installed by kompo)...'
+        puts "Uninstalling Homebrew (installed by kompo)..."
         system('NONINTERACTIVE=1 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/uninstall.sh)"')
         File.delete(MARKER_FILE) if File.exist?(MARKER_FILE)
-        puts 'Homebrew uninstalled'
+        puts "Homebrew uninstalled"
       end
     end
 
@@ -73,7 +73,7 @@ module Kompo
 
     def homebrew_installed?
       # Check if brew is in PATH
-      brew_in_path, = Open3.capture2('which', 'brew', err: File::NULL)
+      brew_in_path, = Open3.capture2("which", "brew", err: File::NULL)
       return true unless brew_in_path.chomp.empty?
 
       # Check common installation paths