kompo 0.3.2 → 0.4.0

data/lib/kompo/tasks/packing.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'open3'
-require 'shellwords'
+require "open3"
+require "shellwords"
 
 module Kompo
   # Section to compile the final binary.
@@ -19,14 +19,14 @@ module Kompo
       private
 
       def get_ruby_cflags(ruby_install_dir)
-        ruby_pc = File.join(ruby_install_dir, 'lib', 'pkgconfig', 'ruby.pc')
-        output, = Open3.capture2('pkg-config', '--cflags', ruby_pc, err: File::NULL)
+        ruby_pc = File.join(ruby_install_dir, "lib", "pkgconfig", "ruby.pc")
+        output, = Open3.capture2("pkg-config", "--cflags", ruby_pc, err: File::NULL)
         Shellwords.split(output.chomp)
       end
 
       def get_ruby_mainlibs(ruby_install_dir)
-        ruby_pc = File.join(ruby_install_dir, 'lib', 'pkgconfig', 'ruby.pc')
-        output, = Open3.capture2('pkg-config', '--variable=MAINLIBS', ruby_pc, err: File::NULL)
+        ruby_pc = File.join(ruby_install_dir, "lib", "pkgconfig", "ruby.pc")
+        output, = Open3.capture2("pkg-config", "--variable=MAINLIBS", ruby_pc, err: File::NULL)
         output.chomp
       end
 
@@ -36,9 +36,9 @@ module Kompo
           content = File.read(makefile)
           ldflags = content.scan(/^ldflags\s+= (.*)/).flatten
           ldflags += content.scan(/^LDFLAGS\s+= (.*)/).flatten
-          ldflags.flat_map { |f| f.split(' ') }
+          ldflags.flat_map { |f| f.split(" ") }
         end
-        flags.uniq.select { |f| f.start_with?('-L') }
+        flags.uniq.select { |f| f.start_with?("-L") }
       end
 
       def get_libpath(work_dir, ruby_major_minor)
@@ -46,23 +46,28 @@ module Kompo
         makefiles.flat_map do |makefile|
           content = File.read(makefile)
           content.scan(/^LIBPATH = (.*)/).flatten
-        end.compact.flat_map { |p| p.split(' ') }.uniq
-                 .reject { |p| p.start_with?('-Wl,-rpath,') || !p.start_with?('-L/') }
+        end.compact.flat_map { |p| p.split(" ") }.uniq
+          .reject { |p| p.start_with?("-Wl,-rpath,") || !p.start_with?("-L/") }
       end
 
       def get_extlibs(ruby_build_path, ruby_version)
-        exts_mk_files = Dir.glob(File.join(ruby_build_path, "ruby-#{ruby_version}", 'ext', '**', 'exts.mk'))
-        exts_mk_files.flat_map do |file|
-          File.read(file).scan(/^EXTLIBS\s+= (.*)/).flatten
-        end.compact.flat_map { |l| l.split(' ') }.uniq
+        ruby_build_dir = File.join(ruby_build_path, "ruby-#{ruby_version}")
+
+        # Extract LIBS from ext/*/Makefile and .bundle/gems/*/ext/*/Makefile
+        makefiles = Dir.glob(File.join(ruby_build_dir, "{ext/*,.bundle/gems/*/ext/*}", "Makefile"))
+        makefiles.flat_map do |file|
+          # Read file, collapse line continuations, then match both "LIBS =" and "LIBS +="
+          content = File.read(file).gsub("\\\n", " ")
+          content.scan(/^LIBS\s*\+?=\s*(.*)/).flatten
+        end.compact.flat_map { |l| l.split }.uniq
       end
 
       def get_gem_libs(work_dir, ruby_major_minor)
         makefiles = Dir.glob("#{work_dir}/bundle/ruby/#{ruby_major_minor}.0/gems/*/ext/*/Makefile")
         makefiles.flat_map do |makefile|
           File.read(makefile).scan(/^LIBS = (.*)/).flatten
-        end.compact.flat_map { |l| l.split(' ') }.uniq
-                 .map { |l| l.start_with?('-l') ? l : "-l#{File.basename(l, '.a').delete_prefix('lib')}" }
+        end.compact.flat_map { |l| l.split(" ") }.uniq
+          .map { |l| l.start_with?("-l") ? l : "-l#{File.basename(l, ".a").delete_prefix("lib")}" }
       end
     end
 
@@ -84,8 +89,13 @@ module Kompo
 
         command = build_command(work_dir, deps, ext_paths, enc_files)
 
-        group('Compiling binary (macOS)') do
-          system(*command) or raise 'Failed to compile final binary'
+        if Taski.args[:dry_run]
+          Taski.message(Shellwords.join(command))
+          return
+        end
+
+        group("Compiling binary (macOS)") do
+          system(*command) or raise "Failed to compile final binary"
           puts "Binary size: #{File.size(@output_path) / 1024 / 1024} MB"
         end
 
@@ -98,8 +108,8 @@ module Kompo
         ruby_static_lib = "-lruby.#{deps.ruby_major_minor}-static"
 
         [
-          'clang',
-          '-O3',
+          "clang",
+          "-O3",
           get_ruby_cflags(deps.ruby_install_dir),
           # IMPORTANT: kompo_lib must come FIRST to override Homebrew-installed versions
           "-L#{deps.kompo_lib}",
@@ -110,19 +120,19 @@ module Kompo
           # Add library paths for dependencies (Homebrew on macOS)
           Shellwords.split(deps.deps_lib_paths),
           get_libpath(work_dir, deps.ruby_major_minor),
-          '-fstack-protector-strong',
-          '-Wl,-dead_strip', # Remove unused code/data
-          '-Wl,-no_deduplicate',  # Allow duplicate symbols from Ruby YJIT and kompo-vfs
-          '-Wl,-export_dynamic',  # Export symbols to dynamic symbol table
+          "-fstack-protector-strong",
+          "-Wl,-dead_strip", # Remove unused code/data
+          "-Wl,-no_deduplicate",  # Allow duplicate symbols from Ruby YJIT and kompo-vfs
+          "-Wl,-export_dynamic",  # Export symbols to dynamic symbol table
           deps.main_c,
           deps.fs_c,
           # Link kompo_wrap FIRST (before Ruby) to override libc symbols
-          '-lkompo_wrap',
+          "-lkompo_wrap",
           ext_paths,
           enc_files,
           ruby_static_lib,
           get_libs(deps.ruby_install_dir, work_dir, deps.ruby_build_path, deps.ruby_version, deps.ruby_major_minor),
-          '-o', @output_path
+          "-o", @output_path
         ].flatten
       end
 
@@ -131,20 +141,20 @@ module Kompo
         ruby_std_gem_libs = get_extlibs(ruby_build_path, ruby_version)
         gem_libs = get_gem_libs(work_dir, ruby_major_minor)
 
-        all_libs = [main_libs.split(' '), gem_libs, ruby_std_gem_libs].flatten
-                                                                      .select { |l| l.match?(/-l\w/) }.uniq
-                                                                      .reject { |l| l == '-ldl' } # macOS doesn't have libdl
+        all_libs = [main_libs.split(" "), gem_libs, ruby_std_gem_libs].flatten
+          .select { |l| l.match?(/-l\w/) }.uniq
+          .reject { |l| l == "-ldl" } # macOS doesn't have libdl
 
         # Separate system libs from other libs
         other_libs = all_libs.reject { |l| SYSTEM_LIBS.any? { |sys| l == "-l#{sys}" } }
 
         [
           other_libs,
-          '-lkompo_fs',
+          "-lkompo_fs",
           # System libraries
           SYSTEM_LIBS.map { |l| "-l#{l}" },
           # Frameworks
-          FRAMEWORKS.flat_map { |f| ['-framework', f] }
+          FRAMEWORKS.flat_map { |f| ["-framework", f] }
         ].flatten
       end
     end
@@ -165,8 +175,13 @@ module Kompo
 
         command = build_command(work_dir, deps, ext_paths, enc_files)
 
-        group('Compiling binary (Linux)') do
-          system(*command) or raise 'Failed to compile final binary'
+        if Taski.args[:dry_run]
+          Taski.message(Shellwords.join(command))
+          return
+        end
+
+        group("Compiling binary (Linux)") do
+          system(*command) or raise "Failed to compile final binary"
           puts "Binary size: #{File.size(@output_path) / 1024 / 1024} MB"
         end
 
@@ -177,12 +192,12 @@ module Kompo
 
       def build_command(work_dir, deps, ext_paths, enc_files)
         # Linux uses libruby-static.a (not libruby.X.Y-static.a like macOS)
-        ruby_static_lib = '-lruby-static'
+        ruby_static_lib = "-lruby-static"
 
         [
-          'gcc',
-          '-O3',
-          '-no-pie', # Required: Rust std lib is not built with PIC
+          "gcc",
+          "-O3",
+          "-no-pie", # Required: Rust std lib is not built with PIC
           get_ruby_cflags(deps.ruby_install_dir),
           # IMPORTANT: kompo_lib must come FIRST to override system-installed versions
           "-L#{deps.kompo_lib}",
@@ -193,17 +208,17 @@ module Kompo
           # Add library paths for dependencies (from pkg-config)
           Shellwords.split(deps.deps_lib_paths),
           get_libpath(work_dir, deps.ruby_major_minor),
-          '-fstack-protector-strong',
-          '-rdynamic', '-Wl,-export-dynamic',
+          "-fstack-protector-strong",
+          "-rdynamic", "-Wl,-export-dynamic",
           deps.main_c,
           deps.fs_c,
-          '-Wl,-Bstatic',
-          '-Wl,--start-group',
+          "-Wl,-Bstatic",
+          "-Wl,--start-group",
           ext_paths,
           enc_files,
           ruby_static_lib,
           get_libs(deps.ruby_install_dir, work_dir, deps.ruby_build_path, deps.ruby_version, deps.ruby_major_minor),
-          '-o', @output_path
+          "-o", @output_path
         ].flatten
       end
 
@@ -214,22 +229,22 @@ module Kompo
 
         dyn_link_libs = DYN_LINK_LIBS.map { |l| "-l#{l}" }
 
-        all_libs = [main_libs.split(' '), gem_libs, ruby_std_gem_libs].flatten
-                                                                      .select { |l| l.match?(/-l\w/) }.uniq
+        all_libs = [main_libs.split(" "), gem_libs, ruby_std_gem_libs].flatten
+          .select { |l| l.match?(/-l\w/) }.uniq
 
         static_libs, dyn_libs = all_libs.partition { |l| !dyn_link_libs.include?(l) }
 
-        dyn_libs << '-lc'
-        dyn_libs.unshift('-Wl,-Bdynamic')
+        dyn_libs << "-lc"
+        dyn_libs.unshift("-Wl,-Bdynamic")
 
-        [static_libs, '-Wl,--end-group', '-lkompo_fs', '-lkompo_wrap', dyn_libs].flatten
+        [static_libs, "-Wl,--end-group", "-lkompo_fs", "-lkompo_wrap", dyn_libs].flatten
       end
     end
 
     private
 
     def macos?
-      RUBY_PLATFORM.include?('darwin')
+      RUBY_PLATFORM.include?("darwin")
     end
   end
 end

data/lib/kompo/tasks/ruby_build_path.rb

@@ -1,45 +1,72 @@
 # frozen_string_literal: true
 
-require 'open3'
+require "open3"
 
 module Kompo
   # Section to get the ruby-build path.
-  # Switches implementation based on whether ruby-build is already installed.
+  # Priority:
+  #   1. Existing ruby-build installation (via which)
+  #   2. macOS: Install via Homebrew
+  #   3. Linux: Install via git clone
   class RubyBuildPath < Taski::Section
     interfaces :path
 
     def impl
-      ruby_build_installed? ? Installed : Install
+      return Installed if ruby_build_installed?
+
+      if darwin?
+        check_homebrew_available!
+        return FromHomebrew
+      end
+
+      FromSource
     end
 
     # Use existing ruby-build installation
     class Installed < Taski::Task
       def run
-        path_output, = Open3.capture2('which', 'ruby-build', err: File::NULL)
+        path_output, = Open3.capture2("which", "ruby-build", err: File::NULL)
         @path = path_output.chomp
         puts "ruby-build path: #{@path}"
-        version_output, = Open3.capture2(@path, '--version', err: File::NULL)
+        version_output, = Open3.capture2(@path, "--version", err: File::NULL)
         puts "ruby-build version: #{version_output.chomp}"
       end
     end
 
-    # Install ruby-build via git clone and return the path
-    class Install < Taski::Task
+    # Install ruby-build via Homebrew (macOS)
+    class FromHomebrew < Taski::Task
       def run
-        puts 'ruby-build not found. Installing via git...'
-        install_dir = File.expand_path('~/.ruby-build')
+        brew = HomebrewPath.path
+        puts "Installing ruby-build via Homebrew..."
+        system(brew, "install", "ruby-build") or raise "Failed to install ruby-build"
+
+        prefix_output, = Open3.capture2(brew, "--prefix", "ruby-build", err: File::NULL)
+        @path = prefix_output.chomp + "/bin/ruby-build"
+        raise "Failed to install ruby-build" unless File.executable?(@path)
+
+        puts "ruby-build path: #{@path}"
+        version_output, = Open3.capture2(@path, "--version", err: File::NULL)
+        puts "ruby-build version: #{version_output.chomp}"
+      end
+    end
+
+    # Install ruby-build via git clone (Linux)
+    class FromSource < Taski::Task
+      def run
+        puts "ruby-build not found. Installing via git..."
+        install_dir = File.expand_path("~/.ruby-build")
 
         if Dir.exist?(install_dir)
-          system('git', '-C', install_dir, 'pull', '--quiet')
+          system("git", "-C", install_dir, "pull", "--quiet")
         else
-          system('git', 'clone', 'https://github.com/rbenv/ruby-build.git', install_dir)
+          system("git", "clone", "https://github.com/rbenv/ruby-build.git", install_dir)
         end
 
-        @path = File.join(install_dir, 'bin', 'ruby-build')
-        raise 'Failed to install ruby-build' unless File.executable?(@path)
+        @path = File.join(install_dir, "bin", "ruby-build")
+        raise "Failed to install ruby-build" unless File.executable?(@path)
 
         puts "ruby-build installed at: #{@path}"
-        version_output, = Open3.capture2(@path, '--version', err: File::NULL)
+        version_output, = Open3.capture2(@path, "--version", err: File::NULL)
         puts "ruby-build version: #{version_output.chomp}"
       end
     end
@@ -47,8 +74,26 @@ module Kompo
     private
 
     def ruby_build_installed?
-      _, status = Open3.capture2('which', 'ruby-build', err: File::NULL)
+      _, status = Open3.capture2("which", "ruby-build", err: File::NULL)
       status.success?
     end
+
+    def darwin?
+      RUBY_PLATFORM.include?("darwin") || `uname -s`.chomp == "Darwin"
+    end
+
+    def check_homebrew_available!
+      # Check if brew is in PATH
+      brew_in_path, = Open3.capture2("which", "brew", err: File::NULL)
+      return unless brew_in_path.chomp.empty?
+
+      # Check common Homebrew installation paths (including ARM64 at /opt/homebrew)
+      return if HomebrewPath::COMMON_BREW_PATHS.any? { |p| File.executable?(p) }
+
+      raise <<~ERROR
+        Homebrew is required on macOS but not installed.
+        Please install Homebrew first: https://brew.sh
+      ERROR
+    end
   end
 end

data/lib/kompo/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Kompo
-  VERSION = '0.3.2'
-  KOMPO_VFS_MIN_VERSION = '0.5.0'
+  VERSION = "0.4.0"
+  KOMPO_VFS_MIN_VERSION = "0.5.1"
 end

data/lib/kompo.rb

@@ -1,52 +1,56 @@
 # frozen_string_literal: true
 
-require 'taski'
-require_relative 'kompo/version'
+require "taski"
+require_relative "kompo/version"
+
+# Use simple progress mode for cleaner output
+# See taski library for details: https://github.com/ahogappa/taski
+Taski.progress_mode = :simple
 
 module Kompo
   # Fixed path prefix for Ruby installation
   # Using a fixed path ensures that cached Ruby binaries work correctly,
   # since Ruby has hardcoded paths for standard library locations.
-  KOMPO_PREFIX = '/kompo'
+  KOMPO_PREFIX = "/kompo"
 
   # Utility classes
-  autoload :KompoIgnore, 'kompo/kompo_ignore'
+  autoload :KompoIgnore, "kompo/kompo_ignore"
 
   # Struct to hold file data for embedding (used by MakeFsC)
-  autoload :KompoFile, 'kompo/tasks/make_fs_c'
+  autoload :KompoFile, "kompo/tasks/make_fs_c"
 
   # Core tasks
-  autoload :WorkDir, 'kompo/tasks/work_dir'
-  autoload :CopyProjectFiles, 'kompo/tasks/copy_project_files'
-  autoload :CopyGemfile, 'kompo/tasks/copy_gemfile'
-  autoload :MakeMainC, 'kompo/tasks/make_main_c'
-  autoload :MakeFsC, 'kompo/tasks/make_fs_c'
+  autoload :WorkDir, "kompo/tasks/work_dir"
+  autoload :CopyProjectFiles, "kompo/tasks/copy_project_files"
+  autoload :CopyGemfile, "kompo/tasks/copy_gemfile"
+  autoload :MakeMainC, "kompo/tasks/make_main_c"
+  autoload :MakeFsC, "kompo/tasks/make_fs_c"
 
   # Ruby installation
-  autoload :InstallRuby, 'kompo/tasks/install_ruby'
-  autoload :CheckStdlibs, 'kompo/tasks/check_stdlibs'
+  autoload :InstallRuby, "kompo/tasks/install_ruby"
+  autoload :CheckStdlibs, "kompo/tasks/check_stdlibs"
 
   # Bundle and gem tasks
-  autoload :BundleInstall, 'kompo/tasks/bundle_install'
-  autoload :FindNativeExtensions, 'kompo/tasks/find_native_extensions'
-  autoload :BuildNativeGem, 'kompo/tasks/build_native_gem'
+  autoload :BundleInstall, "kompo/tasks/bundle_install"
+  autoload :FindNativeExtensions, "kompo/tasks/find_native_extensions"
+  autoload :BuildNativeGem, "kompo/tasks/build_native_gem"
 
   # Final packing (Section: macOS uses clang, Linux uses gcc)
-  autoload :CollectDependencies, 'kompo/tasks/collect_dependencies'
-  autoload :Packing, 'kompo/tasks/packing'
+  autoload :CollectDependencies, "kompo/tasks/collect_dependencies"
+  autoload :Packing, "kompo/tasks/packing"
 
   # Homebrew path (macOS)
-  autoload :HomebrewPath, 'kompo/tasks/homebrew'
+  autoload :HomebrewPath, "kompo/tasks/homebrew"
 
   # Platform-specific dependencies (Section: macOS uses Homebrew, Linux checks via pkg-config)
-  autoload :InstallDeps, 'kompo/tasks/install_deps'
+  autoload :InstallDeps, "kompo/tasks/install_deps"
 
   # External tool paths
-  autoload :KompoVfsPath, 'kompo/tasks/kompo_vfs_path'
-  autoload :KompoVfsVersionCheck, 'kompo/tasks/kompo_vfs_version_check'
-  autoload :RubyBuildPath, 'kompo/tasks/ruby_build_path'
-  autoload :CargoPath, 'kompo/tasks/cargo_path'
+  autoload :KompoVfsPath, "kompo/tasks/kompo_vfs_path"
+  autoload :KompoVfsVersionCheck, "kompo/tasks/kompo_vfs_version_check"
+  autoload :RubyBuildPath, "kompo/tasks/ruby_build_path"
+  autoload :CargoPath, "kompo/tasks/cargo_path"
 end
 
 # Load cache methods (module methods, not autoloadable)
-require_relative 'kompo/cache'
+require_relative "kompo/cache"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kompo
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Sho Hirano