kompo 0.2.0 → 0.3.1

data/lib/kompo/tasks/copy_gemfile.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Kompo
+  # Copy Gemfile, Gemfile.lock, and gemspec files to working directory if they exist
+  class CopyGemfile < Taski::Task
+    exports :gemfile_exists
+
+    def run
+      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')
+
+      @gemfile_exists = File.exist?(gemfile_path)
+      @copied_gemspecs = []
+
+      if @gemfile_exists
+        FileUtils.cp(gemfile_path, work_dir)
+        puts 'Copied: Gemfile'
+
+        if File.exist?(gemfile_lock_path)
+          FileUtils.cp(gemfile_lock_path, work_dir)
+          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'
+      end
+    end
+
+    def clean
+      return unless @gemfile_exists
+
+      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')
+
+      FileUtils.rm_f(gemfile)
+      FileUtils.rm_f(gemfile_lock)
+
+      # Clean up copied gemspec files
+      (@copied_gemspecs || []).each do |gemspec|
+        FileUtils.rm_f(gemspec)
+      end
+
+      puts 'Cleaned up Gemfile'
+    end
+
+    private
+
+    def copy_gemspec_if_needed(gemfile_path, project_dir, work_dir)
+      gemfile_content = File.read(gemfile_path)
+
+      # Check if Gemfile contains a gemspec directive
+      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.each do |gemspec_path|
+        dest_path = File.join(work_dir, File.basename(gemspec_path))
+        FileUtils.cp(gemspec_path, dest_path)
+        @copied_gemspecs << dest_path
+        puts "Copied: #{File.basename(gemspec_path)}"
+      end
+
+      if gemspec_files.empty?
+        warn 'Warning: Gemfile contains gemspec directive but no .gemspec files found'
+      end
+    end
+  end
+end

data/lib/kompo/tasks/copy_project_files.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Kompo
+  # Copy project files (entrypoint and additional files) to working directory
+  class CopyProjectFiles < Taski::Task
+    exports :entrypoint_path, :additional_paths
+
+    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')
+      files = Taski.args.fetch(:files, [])
+
+      # Copy entrypoint (preserve relative path structure)
+      src_entrypoint = File.expand_path(File.join(project_dir, entrypoint))
+      raise "Entrypoint not found: #{src_entrypoint}" unless File.exist?(src_entrypoint)
+
+      # Validate source is inside project_dir
+      real_project_dir = File.realpath(project_dir)
+      real_src = File.realpath(src_entrypoint)
+      unless real_src.start_with?(real_project_dir + File::SEPARATOR) || real_src == real_project_dir
+        raise "Entrypoint path escapes project directory: #{entrypoint}"
+      end
+
+      @entrypoint_path = File.join(work_dir, entrypoint)
+      FileUtils.mkdir_p(File.dirname(@entrypoint_path))
+      FileUtils.cp(src_entrypoint, @entrypoint_path)
+      puts "Copied entrypoint: #{entrypoint}"
+
+      # Copy additional files/directories
+      @additional_paths = []
+      files.each do |file|
+        src = File.expand_path(File.join(project_dir, file))
+        next unless File.exist?(src)
+
+        # Validate source is inside project_dir
+        real_src = File.realpath(src)
+        unless real_src.start_with?(real_project_dir + File::SEPARATOR) || real_src == real_project_dir
+          warn "Skipping path that escapes project directory: #{file}"
+          next
+        end
+
+        dest = File.join(work_dir, file)
+
+        # Validate destination is inside work_dir
+        real_work_dir = File.realpath(work_dir)
+        expanded_dest = File.expand_path(dest)
+        unless expanded_dest.start_with?(real_work_dir + File::SEPARATOR) || expanded_dest == real_work_dir
+          warn "Skipping path that would escape work directory: #{file}"
+          next
+        end
+
+        if File.directory?(src)
+          # Special handling for "." - copy directory contents directly to work_dir
+          if file == '.' || real_src == real_project_dir
+            copy_directory_contents(src, work_dir)
+            @additional_paths << work_dir
+          else
+            FileUtils.mkdir_p(dest)
+            FileUtils.cp_r(src, File.dirname(dest))
+            @additional_paths << dest
+          end
+        else
+          FileUtils.mkdir_p(File.dirname(dest))
+          FileUtils.cp(src, dest)
+          @additional_paths << dest
+        end
+        puts "Copied: #{file}"
+      end
+    end
+
+    def clean
+      work_dir = WorkDir.path
+      return unless work_dir && Dir.exist?(work_dir)
+
+      real_work_dir = File.realpath(work_dir)
+      files = Taski.args.fetch(:files, [])
+
+      # Clean up copied files (with path validation)
+      if @entrypoint_path
+        expanded_path = File.expand_path(@entrypoint_path)
+        FileUtils.rm_f(@entrypoint_path) if expanded_path.start_with?(real_work_dir + File::SEPARATOR)
+      end
+
+      files.each do |file|
+        path = File.join(work_dir, file)
+        expanded_path = File.expand_path(path)
+        # 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'
+    end
+
+    private
+
+    def copy_directory_contents(src_dir, dest_dir)
+      # Copy all files and directories from src_dir directly into dest_dir
+      Dir.each_child(src_dir) do |child|
+        src_path = File.join(src_dir, child)
+        dest_path = File.join(dest_dir, child)
+
+        if File.directory?(src_path)
+          FileUtils.cp_r(src_path, dest_path)
+        else
+          FileUtils.cp(src_path, dest_path)
+        end
+      end
+    end
+  end
+end

data/lib/kompo/tasks/find_native_extensions.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Kompo
+  # Find native gem extensions that need to be built
+  # Exports:
+  #   - extensions: Array of hashes with extension info (dir_name, gem_ext_name, is_rust)
+  class FindNativeExtensions < Taski::Task
+    exports :extensions
+
+    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 all native extensions in installed gems
+      extconf_files = Dir.glob(File.join(bundle_ruby_dir, 'gems/**/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
+        # This catches gems like prism that are compiled into Ruby core
+        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
+
+        # 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'))
+        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')
+        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
+        }
+      end
+
+      puts "Found #{@extensions.size} native extensions to build"
+    end
+
+    private
+
+    # 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
+      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)
+      return Set.new unless status.success?
+
+      # Filter lines matching " T _?Init_" pattern and extract the symbol name
+      # macOS prefixes symbols with underscore, Linux does not
+      symbols = output.lines.select { |line| line.match?(/ T _?Init_/) }
+      symbols.map do |line|
+        # Third whitespace-separated field is the symbol name
+        symbol = line.split[2]
+        symbol&.delete_prefix('_')
+      end.compact.to_set
+    end
+  end
+end

data/lib/kompo/tasks/homebrew.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Kompo
+  # Section to get the Homebrew path.
+  # Switches implementation based on whether Homebrew is already installed.
+  class HomebrewPath < Taski::Section
+    interfaces :path
+
+    # Common Homebrew installation paths
+    COMMON_BREW_PATHS = ['/opt/homebrew/bin/brew', '/usr/local/bin/brew'].freeze
+
+    def impl
+      homebrew_installed? ? Installed : Install
+    end
+
+    # Use existing Homebrew installation
+    class Installed < Taski::Task
+      def run
+        # First check PATH
+        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
+        puts "Homebrew path: #{@path}"
+      end
+    end
+
+    # Install Homebrew
+    class Install < Taski::Task
+      MARKER_FILE = File.expand_path('~/.kompo_installed_homebrew')
+
+      def run
+        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)
+        @path = brew_in_path.chomp
+        if @path.empty?
+          # Check common installation paths
+          HomebrewPath::COMMON_BREW_PATHS.each do |p|
+            if File.executable?(p)
+              @path = p
+              break
+            end
+          end
+        end
+
+        raise 'Failed to install Homebrew' if @path.nil? || @path.empty?
+
+        # Mark that kompo installed Homebrew
+        File.write(MARKER_FILE, @path)
+        puts "Homebrew installed at: #{@path}"
+      end
+
+      def clean
+        # Only uninstall if kompo installed it
+        return unless File.exist?(MARKER_FILE)
+
+        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'
+      end
+    end
+
+    private
+
+    def homebrew_installed?
+      # Check if brew is in PATH
+      brew_in_path, = Open3.capture2('which', 'brew', err: File::NULL)
+      return true unless brew_in_path.chomp.empty?
+
+      # Check common installation paths
+      COMMON_BREW_PATHS.any? { |p| File.executable?(p) }
+    end
+  end
+end