kompo 0.2.0 → 0.3.0

data/lib/kompo/tasks/install_ruby.rb

@@ -0,0 +1,427 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "open3"
+require "time"
+
+module Kompo
+  # Section to install static Ruby
+  # Switches between cache restore and building from source
+  # Required context:
+  #   - ruby_version: Ruby version to build (default: current RUBY_VERSION)
+  #   - kompo_cache: Cache directory for kompo (default: ~/.kompo/cache)
+  #   - clear_cache: If true, clear the Ruby build cache before building
+  class InstallRuby < Taski::Section
+    interfaces :ruby_path, :bundler_path, :ruby_install_dir, :ruby_version,
+      :ruby_major_minor, :ruby_build_path, :original_ruby_install_dir
+
+    def impl
+      # Skip cache if --no-cache is specified, or if cache doesn't exist
+      return FromSource if Taski.args[:no_cache]
+
+      cache_exists? ? FromCache : FromSource
+    end
+
+    # Ruby extensions to build statically
+    STATIC_EXTENSIONS = %w[
+      bigdecimal
+      cgi/escape
+      continuation
+      coverage
+      date
+      digest/bubblebabble
+      digest
+      digest/md5
+      digest/rmd160
+      digest/sha1
+      digest/sha2
+      etc
+      fcntl
+      fiddle
+      io/console
+      io/nonblock
+      io/wait
+      json
+      json/generator
+      json/parser
+      nkf
+      monitor
+      objspace
+      openssl
+      pathname
+      psych
+      pty
+      racc/cparse
+      rbconfig/sizeof
+      readline
+      ripper
+      socket
+      stringio
+      strscan
+      syslog
+      zlib
+    ].freeze
+
+    # Restore Ruby from cache
+    # Uses the work_dir path saved in metadata to ensure $LOAD_PATH matches
+    class FromCache < Taski::Task
+      def run
+        @ruby_version = Taski.args.fetch(:ruby_version, RUBY_VERSION)
+        @ruby_major_minor = ruby_major_and_minor(@ruby_version)
+
+        kompo_cache = Taski.args.fetch(:kompo_cache, File.expand_path("~/.kompo/cache"))
+        version_cache_dir = File.join(kompo_cache, @ruby_version)
+        cache_install_dir = File.join(version_cache_dir, "ruby")
+
+        # Use WorkDir.path which now automatically uses cached work_dir path
+        work_dir = WorkDir.path
+
+        @ruby_install_dir = File.join(work_dir, "_ruby")
+        @ruby_path = File.join(@ruby_install_dir, "bin", "ruby")
+        @bundler_path = File.join(@ruby_install_dir, "bin", "bundler")
+        @ruby_build_path = File.join(@ruby_install_dir, "_build")
+        @original_ruby_install_dir = @ruby_install_dir
+
+        group("Restoring Ruby #{@ruby_version} from cache to #{work_dir}") do
+          # Clean up existing files in case work_dir is reused
+          FileUtils.rm_rf(@ruby_install_dir) if Dir.exist?(@ruby_install_dir)
+
+          # _build directory is included in cache_install_dir
+          FileUtils.cp_r(cache_install_dir, @ruby_install_dir)
+
+          puts "Restored from: #{version_cache_dir}"
+        end
+
+        # Fix shebangs in bin scripts to point to the new Ruby path
+        fix_bin_shebangs(@ruby_install_dir, @ruby_path)
+
+        # Fix ruby.pc prefix to point to the new install directory
+        fix_ruby_pc(@ruby_install_dir)
+
+        puts "Ruby #{@ruby_version} restored from cache"
+        version_output, = Open3.capture2(@ruby_path, "--version", err: File::NULL)
+        puts "Ruby version: #{version_output.chomp}"
+      end
+
+      def clean
+        return unless @ruby_install_dir && Dir.exist?(@ruby_install_dir)
+
+        FileUtils.rm_rf(@ruby_install_dir)
+        puts "Cleaned up Ruby installation"
+      end
+
+      private
+
+      def ruby_major_and_minor(version)
+        parts = version.split(".")
+        "#{parts[0]}.#{parts[1]}"
+      end
+
+      # Fix shebangs in bin directory to point to the correct Ruby path
+      def fix_bin_shebangs(ruby_install_dir, ruby_path)
+        bin_dir = File.join(ruby_install_dir, "bin")
+        return unless Dir.exist?(bin_dir)
+
+        Dir.glob(File.join(bin_dir, "*")).each do |bin_file|
+          next if File.directory?(bin_file)
+          next if File.basename(bin_file) == "ruby"
+
+          content = File.read(bin_file)
+          next unless content.start_with?("#!")
+
+          # Replace old ruby shebang with new one
+          # Handle both direct paths and env-style shebangs, preserving trailing args
+          new_content = content.sub(/^#!.*\bruby\b(.*)$/, "#!#{ruby_path}\\1")
+          File.write(bin_file, new_content) if new_content != content
+        end
+      end
+
+      # Fix ruby.pc prefix to match the current install directory
+      # This is necessary when restoring from cache because the cached ruby.pc
+      # still has the original build directory as prefix
+      def fix_ruby_pc(ruby_install_dir)
+        ruby_pc_path = File.join(ruby_install_dir, "lib", "pkgconfig", "ruby.pc")
+        return unless File.exist?(ruby_pc_path)
+
+        content = File.read(ruby_pc_path)
+        new_content = content.sub(/^prefix=.*$/, "prefix=#{ruby_install_dir}")
+        File.write(ruby_pc_path, new_content) if new_content != content
+      end
+    end
+
+    # Build Ruby from source using ruby-build
+    # Ruby is built into work_dir with --prefix=work_dir/_ruby.
+    # After building, the result is cached with the work_dir path preserved in metadata.
+    # When using cache, the same work_dir path is recreated to ensure $LOAD_PATH matches.
+    class FromSource < Taski::Task
+      def run
+        ruby_build = RubyBuildPath.path
+
+        @ruby_version = Taski.args.fetch(:ruby_version, RUBY_VERSION)
+        @ruby_major_minor = ruby_major_and_minor(@ruby_version)
+
+        @kompo_cache = Taski.args.fetch(:kompo_cache, File.expand_path("~/.kompo/cache"))
+        @version_cache_dir = File.join(@kompo_cache, @ruby_version)
+
+        # Check if we have a valid cache
+        cache_metadata_path = File.join(@version_cache_dir, "metadata.json")
+        if cache_valid?(cache_metadata_path)
+          restore_from_cache(cache_metadata_path)
+        else
+          build_and_cache(ruby_build)
+        end
+
+        puts "Ruby installed at: #{@ruby_install_dir}"
+        version_output, = Open3.capture2(@ruby_path, "--version", err: File::NULL)
+        puts "Ruby version: #{version_output.chomp}"
+      end
+
+      def clean
+        return unless @ruby_install_dir && Dir.exist?(@ruby_install_dir)
+
+        FileUtils.rm_rf(@ruby_install_dir)
+        puts "Cleaned up Ruby installation"
+      end
+
+      private
+
+      def cache_valid?(metadata_path)
+        return false unless File.exist?(metadata_path)
+
+        metadata = JSON.parse(File.read(metadata_path))
+        cached_work_dir = metadata["work_dir"]
+        cache_install_dir = File.join(@version_cache_dir, "ruby")
+
+        cached_work_dir && Dir.exist?(cache_install_dir)
+      rescue JSON::ParserError
+        false
+      end
+
+      def restore_from_cache(_metadata_path)
+        # Use WorkDir.path which now automatically uses cached work_dir path
+        work_dir = WorkDir.path
+
+        @ruby_install_dir = File.join(work_dir, "_ruby")
+        @ruby_path = File.join(@ruby_install_dir, "bin", "ruby")
+        @bundler_path = File.join(@ruby_install_dir, "bin", "bundler")
+        @ruby_build_path = File.join(@ruby_install_dir, "_build")
+        @original_ruby_install_dir = @ruby_install_dir
+
+        cache_install_dir = File.join(@version_cache_dir, "ruby")
+
+        group("Restoring Ruby from cache to #{work_dir}") do
+          # Clean up existing files in case work_dir is reused
+          FileUtils.rm_rf(@ruby_install_dir) if Dir.exist?(@ruby_install_dir)
+
+          # _build directory is included in cache_install_dir
+          FileUtils.cp_r(cache_install_dir, @ruby_install_dir)
+        end
+
+        # Fix shebangs in bin scripts to point to the new Ruby path
+        fix_bin_shebangs(@ruby_install_dir, @ruby_path)
+
+        # Fix ruby.pc prefix to point to the new install directory
+        fix_ruby_pc(@ruby_install_dir)
+      end
+
+      def build_and_cache(ruby_build)
+        work_dir = WorkDir.path
+
+        # Build Ruby into work_dir with prefix pointing to work_dir
+        @ruby_install_dir = File.join(work_dir, "_ruby")
+        @ruby_path = File.join(@ruby_install_dir, "bin", "ruby")
+        @bundler_path = File.join(@ruby_install_dir, "bin", "bundler")
+        @ruby_build_path = File.join(@ruby_install_dir, "_build")
+        @original_ruby_install_dir = @ruby_install_dir
+
+        # Handle custom Ruby source
+        ruby_source_path = Taski.args[:ruby_source_path]
+        ruby_definition = prepare_ruby_source(ruby_source_path)
+
+        # Check if the Ruby version is available in ruby-build (only if not using custom source)
+        check_ruby_version_availability(ruby_build) unless ruby_source_path
+
+        configure_opts = build_configure_opts(@ruby_install_dir)
+
+        command = [
+          ruby_build,
+          "--verbose",
+          "--keep",
+          ruby_definition,
+          @ruby_install_dir
+        ]
+
+        group("Building Ruby #{@ruby_version} in #{work_dir}") do
+          FileUtils.mkdir_p(@version_cache_dir)
+          # Pass configuration via environment variables required by ruby-build
+          env = {
+            "RUBY_CONFIGURE_OPTS" => configure_opts,
+            "RUBY_BUILD_CACHE_PATH" => @version_cache_dir,
+            "RUBY_BUILD_BUILD_PATH" => @ruby_build_path
+          }
+          # Clear Bundler environment to prevent interference with ruby-build
+          # This is necessary because ruby-build's make install runs rbinstall.rb,
+          # which loads rubygems, which loads bundler if BUNDLE_GEMFILE is set.
+          Bundler.with_unbundled_env do
+            system(env, *command) or raise "Failed to build Ruby"
+          end
+        end
+
+        # Save to cache after successful build
+        save_to_cache(work_dir)
+      end
+
+      def save_to_cache(work_dir)
+        cache_install_dir = File.join(@version_cache_dir, "ruby")
+
+        group("Saving Ruby to cache") do
+          # Remove old cache if exists
+          FileUtils.rm_rf(cache_install_dir) if Dir.exist?(cache_install_dir)
+
+          # Copy to cache
+          # Note: _build directory is included in @ruby_install_dir
+          FileUtils.cp_r(@ruby_install_dir, cache_install_dir)
+
+          # Save metadata with work_dir path
+          metadata = {
+            "work_dir" => work_dir,
+            "ruby_version" => @ruby_version,
+            "created_at" => Time.now.iso8601
+          }
+          File.write(File.join(@version_cache_dir, "metadata.json"), JSON.pretty_generate(metadata))
+        end
+      end
+
+      # Prepare Ruby source for building
+      # @param source_path [String, nil] Path to Ruby source (tarball or directory)
+      # @return [String] ruby-build definition (version or source path)
+      def prepare_ruby_source(source_path)
+        return @ruby_version unless source_path
+
+        raise "Ruby source path does not exist: #{source_path}" unless File.exist?(source_path)
+
+        if File.directory?(source_path)
+          # Directory: use it directly as ruby-build definition
+          puts "Using Ruby source directory: #{source_path}"
+          source_path
+        elsif source_path.end_with?(".tar.gz", ".tgz")
+          # Extract version from tarball filename
+          tarball_version = extract_version_from_tarball(source_path)
+
+          # Check for version mismatch if --ruby-version was explicitly specified
+          user_specified_version = Taski.args[:ruby_version]
+          if user_specified_version && tarball_version && user_specified_version != tarball_version
+            raise "Version mismatch: --ruby-version=#{user_specified_version} but tarball is ruby-#{tarball_version}.tar.gz. " \
+                  "Please use matching versions or omit --ruby-version to use the tarball version."
+          end
+
+          # Use tarball version if available, otherwise fall back to @ruby_version
+          effective_version = tarball_version || @ruby_version
+          @ruby_version = effective_version
+          @ruby_major_minor = ruby_major_and_minor(effective_version)
+
+          # Update cache directory for new version
+          @version_cache_dir = File.join(@kompo_cache, effective_version)
+
+          # Tarball: copy to version cache directory with expected name for ruby-build
+          FileUtils.mkdir_p(@version_cache_dir)
+          target_tarball = File.join(@version_cache_dir, "ruby-#{effective_version}.tar.gz")
+          unless File.expand_path(source_path) == File.expand_path(target_tarball)
+            FileUtils.cp(source_path, target_tarball)
+            puts "Copied Ruby tarball to: #{target_tarball}"
+          end
+          puts "Using Ruby version from tarball: #{effective_version}"
+          effective_version
+        else
+          raise "Unsupported source format: #{source_path}. Expected .tar.gz file or directory."
+        end
+      end
+
+      # Extract Ruby version from tarball filename
+      # @param path [String] Path to tarball (e.g., /path/to/ruby-3.4.1.tar.gz)
+      # @return [String, nil] Version string or nil if not found
+      def extract_version_from_tarball(path)
+        filename = File.basename(path)
+        return unless filename =~ /^ruby-(\d+\.\d+\.\d+(?:-\w+)?)(?:\.tar)?\.(?:gz|tgz)$/
+
+        ::Regexp.last_match(1)
+      end
+
+      def build_configure_opts(install_dir)
+        [
+          "--prefix=#{install_dir}",
+          "--disable-install-doc",
+          "--disable-install-rdoc",
+          "--disable-install-capi",
+          "--with-static-linked-ext",
+          "--with-ruby-pc=ruby.pc",
+          "--with-ext=#{STATIC_EXTENSIONS.join(",")}",
+          "--disable-shared"
+        ].join(" ")
+      end
+
+      def check_ruby_version_availability(ruby_build)
+        output, status = Open3.capture2(ruby_build, "--definitions", err: File::NULL)
+        available_versions = status.success? ? output.split("\n").map(&:strip) : []
+
+        return if available_versions.include?(@ruby_version)
+
+        similar_versions = available_versions.select { |v| v.start_with?(@ruby_version.split(".")[0..1].join(".")) }
+        error_message = "Ruby #{@ruby_version} is not available in ruby-build.\n"
+        error_message += "Available similar versions: #{similar_versions.join(", ")}\n" unless similar_versions.empty?
+        error_message += "Try updating ruby-build or use --ruby-version to specify a different version."
+        raise error_message
+      end
+
+      def ruby_major_and_minor(version)
+        parts = version.split(".")
+        "#{parts[0]}.#{parts[1]}"
+      end
+
+      # Fix shebangs in bin directory to point to the correct Ruby path
+      def fix_bin_shebangs(ruby_install_dir, ruby_path)
+        bin_dir = File.join(ruby_install_dir, "bin")
+        return unless Dir.exist?(bin_dir)
+
+        Dir.glob(File.join(bin_dir, "*")).each do |bin_file|
+          next if File.directory?(bin_file)
+          next if File.basename(bin_file) == "ruby"
+
+          content = File.read(bin_file)
+          next unless content.start_with?("#!")
+
+          # Replace old ruby shebang with new one
+          # Handle both direct paths and env-style shebangs, preserving trailing args
+          new_content = content.sub(/^#!.*\bruby\b(.*)$/, "#!#{ruby_path}\\1")
+          File.write(bin_file, new_content) if new_content != content
+        end
+      end
+
+      # Fix ruby.pc prefix to match the current install directory
+      # This is necessary when restoring from cache because the cached ruby.pc
+      # still has the original build directory as prefix
+      def fix_ruby_pc(ruby_install_dir)
+        ruby_pc_path = File.join(ruby_install_dir, "lib", "pkgconfig", "ruby.pc")
+        return unless File.exist?(ruby_pc_path)
+
+        content = File.read(ruby_pc_path)
+        new_content = content.sub(/^prefix=.*$/, "prefix=#{ruby_install_dir}")
+        File.write(ruby_pc_path, new_content) if new_content != content
+      end
+    end
+
+    private
+
+    def cache_exists?
+      ruby_version = Taski.args.fetch(:ruby_version, RUBY_VERSION)
+      kompo_cache = Taski.args.fetch(:kompo_cache, File.expand_path("~/.kompo/cache"))
+      version_cache_dir = File.join(kompo_cache, ruby_version)
+
+      cache_install_dir = File.join(version_cache_dir, "ruby")
+      cache_metadata = File.join(version_cache_dir, "metadata.json")
+
+      Dir.exist?(cache_install_dir) && File.exist?(cache_metadata)
+    end
+  end
+end

data/lib/kompo/tasks/kompo_vfs_path.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative 'kompo_vfs_version_check'
+
+module Kompo
+  # Section to get the kompo-vfs library path.
+  # Priority:
+  #   1. Local directory (if specified via context[:local_kompo_vfs_path])
+  #   2. Homebrew (install if needed)
+  #   3. Source build (fallback if Homebrew doesn't support arch/os)
+  class KompoVfsPath < Taski::Section
+    interfaces :path
+
+    def impl
+      # Priority 1: Local directory if specified
+      return FromLocal if Taski.args[:local_kompo_vfs_path]
+
+      # # Priority 2: Homebrew if supported
+      return FromHomebrew if homebrew_supported?
+
+      # # Priority 3: Build from source
+      FromSource
+    end
+
+    # Build from local directory (requires Cargo)
+    class FromLocal < Taski::Task
+      def run
+        local_path = Taski.args[:local_kompo_vfs_path]
+        raise 'Local kompo-vfs path not specified' unless local_path
+        raise "Local kompo-vfs path does not exist: #{local_path}" unless Dir.exist?(local_path)
+
+        puts "Building kompo-vfs from local directory: #{local_path}"
+        cargo = CargoPath.path
+
+        raise 'Failed to build kompo-vfs' unless system(cargo, 'build', '--release', chdir: local_path)
+
+        @path = File.join(local_path, 'target', 'release')
+        puts "kompo-vfs library path: #{@path}"
+
+        KompoVfsVersionCheck.verify!(@path)
+      end
+    end
+
+    # Install via Homebrew (Section to handle installed vs not installed)
+    class FromHomebrew < Taski::Section
+      interfaces :path
+
+      def impl
+        kompo_vfs_installed? ? Installed : Install
+      end
+
+      # Use existing Homebrew installation of kompo-vfs
+      class Installed < Taski::Task
+        def run
+          brew = HomebrewPath.path
+          @path = "#{`#{brew} --prefix kompo-vfs`.chomp}/lib"
+
+          # Check if required library files exist (kompo-vfs >= 0.2.0 has libkompo_fs.a and libkompo_wrap.a)
+          required_libs = %w[libkompo_fs.a libkompo_wrap.a]
+          missing_libs = required_libs.reject { |lib| File.exist?(File.join(@path, lib)) }
+
+          unless missing_libs.empty?
+            installed_version = `#{brew} list --versions kompo-vfs`.chomp.split.last
+            raise "kompo-vfs #{installed_version} is outdated. Please run: brew upgrade kompo-vfs\n" \
+                  "Missing libraries: #{missing_libs.join(', ')}"
+          end
+
+          puts "kompo-vfs library path: #{@path}"
+
+          KompoVfsVersionCheck.verify!(@path)
+        end
+      end
+
+      # Install kompo-vfs via Homebrew
+      class Install < Taski::Task
+        def run
+          brew = HomebrewPath.path
+          puts 'Installing kompo-vfs via Homebrew...'
+          system(brew, 'tap', 'ahogappa/kompo') or raise 'Failed to tap ahogappa/kompo'
+          system(brew, 'install', 'kompo-vfs') or raise 'Failed to install kompo-vfs'
+
+          @path = "#{`#{brew} --prefix kompo-vfs`.chomp}/lib"
+          puts "kompo-vfs library path: #{@path}"
+
+          KompoVfsVersionCheck.verify!(@path)
+        end
+      end
+
+      private
+
+      def kompo_vfs_installed?
+        # Avoid calling HomebrewPath.path here to prevent duplicate dependency
+        brew = `which brew 2>/dev/null`.chomp
+        return false if brew.empty?
+
+        system("#{brew} list kompo-vfs > /dev/null 2>&1")
+      end
+    end
+
+    # Build from source (requires Cargo)
+    class FromSource < Taski::Task
+      REPO_URL = 'https://github.com/ahogappa/kompo-vfs'
+
+      def run
+        puts 'Building kompo-vfs from source...'
+        cargo = CargoPath.path
+
+        build_dir = File.expand_path('~/.kompo/kompo-vfs')
+        FileUtils.mkdir_p(File.dirname(build_dir))
+
+        if Dir.exist?(build_dir)
+          system('git', '-C', build_dir, 'pull', '--quiet')
+        else
+          system('git', 'clone', REPO_URL, build_dir) or raise 'Failed to clone kompo-vfs repository'
+        end
+
+        system(cargo, 'build', '--release', chdir: build_dir) or raise 'Failed to build kompo-vfs'
+
+        @path = File.join(build_dir, 'target', 'release')
+        puts "kompo-vfs library path: #{@path}"
+
+        KompoVfsVersionCheck.verify!(@path)
+      end
+    end
+
+    private
+
+    def homebrew_supported?
+      # Check if current arch/os combination is supported by Homebrew formula
+      arch = `uname -m`.chomp
+      os = `uname -s`.chomp
+
+      # Supported combinations (adjust based on actual formula support)
+      supported = [
+        %w[arm64 Darwin],
+        %w[x86_64 Darwin],
+        %w[x86_64 Linux]
+      ]
+
+      supported.include?([arch, os])
+    end
+  end
+end

data/lib/kompo/tasks/kompo_vfs_version_check.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative '../version'
+
+module Kompo
+  # Verifies that the installed kompo-vfs version meets minimum requirements.
+  # Checks the KOMPO_VFS_VERSION file in the library directory.
+  module KompoVfsVersionCheck
+    class IncompatibleVersionError < StandardError; end
+
+    VERSION_FILE = 'KOMPO_VFS_VERSION'
+
+    def self.verify!(lib_path)
+      actual_version = get_version(lib_path)
+      required_version = Kompo::KOMPO_VFS_MIN_VERSION
+
+      return if version_satisfies?(actual_version, required_version)
+
+      raise IncompatibleVersionError, build_error_message(actual_version, required_version)
+    end
+
+    def self.get_version(lib_path)
+      version_file = File.join(lib_path, VERSION_FILE)
+
+      raise IncompatibleVersionError, build_missing_file_message(version_file) unless File.exist?(version_file)
+
+      File.read(version_file).strip
+    end
+
+    def self.version_satisfies?(actual, required)
+      Gem::Version.new(actual) >= Gem::Version.new(required)
+    end
+
+    def self.build_error_message(actual_version, required_version)
+      <<~MSG.chomp
+        kompo-vfs version #{actual_version} is too old.
+        Required: >= #{required_version}
+
+        Please upgrade:
+          Homebrew: brew upgrade kompo-vfs
+          Source: cd ~/.kompo/kompo-vfs && git pull && cargo build --release
+      MSG
+    end
+
+    def self.build_missing_file_message(version_file)
+      <<~MSG.chomp
+        kompo-vfs version file not found at: #{version_file}
+        Your kompo-vfs installation may be outdated (< 0.5.0).
+
+        Please upgrade:
+          Homebrew: brew upgrade kompo-vfs
+          Source: cd ~/.kompo/kompo-vfs && git pull && cargo build --release
+      MSG
+    end
+  end
+end