kompo 0.2.0 → 0.3.0

data/lib/kompo/tasks/copy_project_files.rb

@@ -0,0 +1,89 @@
+# 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)
+          FileUtils.mkdir_p(dest)
+          FileUtils.cp_r(src, File.dirname(dest))
+        else
+          FileUtils.mkdir_p(File.dirname(dest))
+          FileUtils.cp(src, dest)
+        end
+        @additional_paths << dest
+        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
+  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

data/lib/kompo/tasks/install_deps.rb

@@ -0,0 +1,365 @@
+# frozen_string_literal: true
+
+require 'English'
+module Kompo
+  # Section to handle platform-specific dependencies.
+  # Switches implementation based on the current platform.
+  # Exports lib_paths for linker flags (e.g., "-L/usr/local/lib")
+  class InstallDeps < Taski::Section
+    interfaces :lib_paths
+
+    def impl
+      macos? ? ForMacOS : ForLinux
+    end
+
+    # macOS implementation - installs dependencies via Homebrew
+    class ForMacOS < Taski::Task
+      def run
+        # HomebrewPath.path triggers Homebrew installation if not present
+        @lib_paths = [
+          InstallGmp.lib_path,
+          InstallOpenssl.lib_path,
+          InstallReadline.lib_path,
+          InstallLibyaml.lib_path,
+          InstallZlib.lib_path,
+          InstallLibffi.lib_path
+        ].compact.join(' ')
+
+        puts 'All Homebrew dependencies installed'
+      end
+
+      # GMP library installation Section
+      class InstallGmp < Taski::Section
+        interfaces :lib_path
+
+        def impl
+          brew = HomebrewPath.path
+          system("#{brew} list #{BREW_NAME} > /dev/null 2>&1") ? Installed : Install
+        end
+
+        BREW_NAME = 'gmp'
+        MARKER_FILE = File.expand_path('~/.kompo_installed_gmp')
+
+        class Installed < Taski::Task
+          def run
+            brew = HomebrewPath.path
+            prefix = `#{brew} --prefix #{BREW_NAME} 2>/dev/null`.chomp
+            @lib_path = "-L#{prefix}/lib" if $CHILD_STATUS.success? && !prefix.empty?
+            puts "#{BREW_NAME} is already installed"
+          end
+        end
+
+        class Install < Taski::Task
+          def run
+            brew = HomebrewPath.path
+            puts "Installing #{BREW_NAME}..."
+            system("#{brew} install #{BREW_NAME}") or raise "Failed to install #{BREW_NAME}"
+            File.write(MARKER_FILE, 'installed')
+
+            prefix = `#{brew} --prefix #{BREW_NAME} 2>/dev/null`.chomp
+            @lib_path = "-L#{prefix}/lib" if $CHILD_STATUS.success? && !prefix.empty?
+          end
+
+          def clean
+            return unless File.exist?(MARKER_FILE)
+
+            brew = HomebrewPath.path
+            puts "Uninstalling #{BREW_NAME} (installed by kompo)..."
+            system("#{brew} uninstall #{BREW_NAME}")
+            File.delete(MARKER_FILE) if File.exist?(MARKER_FILE)
+          end
+        end
+      end
+
+      # OpenSSL library installation Section
+      class InstallOpenssl < Taski::Section
+        interfaces :lib_path
+
+        def impl
+          brew = HomebrewPath.path
+          system("#{brew} list #{BREW_NAME} > /dev/null 2>&1") ? Installed : Install
+        end
+
+        BREW_NAME = 'openssl@3'
+        MARKER_FILE = File.expand_path('~/.kompo_installed_openssl')
+
+        class Installed < Taski::Task
+          def run
+            brew = HomebrewPath.path
+            prefix = `#{brew} --prefix #{BREW_NAME} 2>/dev/null`.chomp
+            @lib_path = "-L#{prefix}/lib" if $CHILD_STATUS.success? && !prefix.empty?
+            puts "#{BREW_NAME} is already installed"
+          end
+        end
+
+        class Install < Taski::Task
+          def run
+            brew = HomebrewPath.path
+            puts "Installing #{BREW_NAME}..."
+            system("#{brew} install #{BREW_NAME}") or raise "Failed to install #{BREW_NAME}"
+            File.write(MARKER_FILE, 'installed')
+
+            prefix = `#{brew} --prefix #{BREW_NAME} 2>/dev/null`.chomp
+            @lib_path = "-L#{prefix}/lib" if $CHILD_STATUS.success? && !prefix.empty?
+          end
+
+          def clean
+            return unless File.exist?(MARKER_FILE)
+
+            brew = HomebrewPath.path
+            puts "Uninstalling #{BREW_NAME} (installed by kompo)..."
+            system("#{brew} uninstall #{BREW_NAME}")
+            File.delete(MARKER_FILE) if File.exist?(MARKER_FILE)
+          end
+        end
+      end
+
+      # Readline library installation Section
+      class InstallReadline < Taski::Section
+        interfaces :lib_path
+
+        def impl
+          brew = HomebrewPath.path
+          system("#{brew} list #{BREW_NAME} > /dev/null 2>&1") ? Installed : Install
+        end
+
+        BREW_NAME = 'readline'
+        MARKER_FILE = File.expand_path('~/.kompo_installed_readline')
+
+        class Installed < Taski::Task
+          def run
+            brew = HomebrewPath.path
+            prefix = `#{brew} --prefix #{BREW_NAME} 2>/dev/null`.chomp
+            @lib_path = "-L#{prefix}/lib" if $CHILD_STATUS.success? && !prefix.empty?
+            puts "#{BREW_NAME} is already installed"
+          end
+        end
+
+        class Install < Taski::Task
+          def run
+            brew = HomebrewPath.path
+            puts "Installing #{BREW_NAME}..."
+            system("#{brew} install #{BREW_NAME}") or raise "Failed to install #{BREW_NAME}"
+            File.write(MARKER_FILE, 'installed')
+
+            prefix = `#{brew} --prefix #{BREW_NAME} 2>/dev/null`.chomp
+            @lib_path = "-L#{prefix}/lib" if $CHILD_STATUS.success? && !prefix.empty?
+          end
+
+          def clean
+            return unless File.exist?(MARKER_FILE)
+
+            brew = HomebrewPath.path
+            puts "Uninstalling #{BREW_NAME} (installed by kompo)..."
+            system("#{brew} uninstall #{BREW_NAME}")
+            File.delete(MARKER_FILE) if File.exist?(MARKER_FILE)
+          end
+        end
+      end
+
+      # libyaml library installation Section
+      class InstallLibyaml < Taski::Section
+        interfaces :lib_path
+
+        def impl
+          brew = HomebrewPath.path
+          system("#{brew} list #{BREW_NAME} > /dev/null 2>&1") ? Installed : Install
+        end
+
+        BREW_NAME = 'libyaml'
+        MARKER_FILE = File.expand_path('~/.kompo_installed_libyaml')
+
+        class Installed < Taski::Task
+          def run
+            brew = HomebrewPath.path
+            prefix = `#{brew} --prefix #{BREW_NAME} 2>/dev/null`.chomp
+            @lib_path = "-L#{prefix}/lib" if $CHILD_STATUS.success? && !prefix.empty?
+            puts "#{BREW_NAME} is already installed"
+          end
+        end
+
+        class Install < Taski::Task
+          def run
+            brew = HomebrewPath.path
+            puts "Installing #{BREW_NAME}..."
+            system("#{brew} install #{BREW_NAME}") or raise "Failed to install #{BREW_NAME}"
+            File.write(MARKER_FILE, 'installed')
+
+            prefix = `#{brew} --prefix #{BREW_NAME} 2>/dev/null`.chomp
+            @lib_path = "-L#{prefix}/lib" if $CHILD_STATUS.success? && !prefix.empty?
+          end
+
+          def clean
+            return unless File.exist?(MARKER_FILE)
+
+            brew = HomebrewPath.path
+            puts "Uninstalling #{BREW_NAME} (installed by kompo)..."
+            system("#{brew} uninstall #{BREW_NAME}")
+            File.delete(MARKER_FILE) if File.exist?(MARKER_FILE)
+          end
+        end
+      end
+
+      # zlib library installation Section
+      class InstallZlib < Taski::Section
+        interfaces :lib_path
+
+        def impl
+          brew = HomebrewPath.path
+          system("#{brew} list #{BREW_NAME} > /dev/null 2>&1") ? Installed : Install
+        end
+
+        BREW_NAME = 'zlib'
+        MARKER_FILE = File.expand_path('~/.kompo_installed_zlib')
+
+        class Installed < Taski::Task
+          def run
+            brew = HomebrewPath.path
+            prefix = `#{brew} --prefix #{BREW_NAME} 2>/dev/null`.chomp
+            @lib_path = "-L#{prefix}/lib" if $CHILD_STATUS.success? && !prefix.empty?
+            puts "#{BREW_NAME} is already installed"
+          end
+        end
+
+        class Install < Taski::Task
+          def run
+            brew = HomebrewPath.path
+            puts "Installing #{BREW_NAME}..."
+            system("#{brew} install #{BREW_NAME}") or raise "Failed to install #{BREW_NAME}"
+            File.write(MARKER_FILE, 'installed')
+
+            prefix = `#{brew} --prefix #{BREW_NAME} 2>/dev/null`.chomp
+            @lib_path = "-L#{prefix}/lib" if $CHILD_STATUS.success? && !prefix.empty?
+          end
+
+          def clean
+            return unless File.exist?(MARKER_FILE)
+
+            brew = HomebrewPath.path
+            puts "Uninstalling #{BREW_NAME} (installed by kompo)..."
+            system("#{brew} uninstall #{BREW_NAME}")
+            File.delete(MARKER_FILE) if File.exist?(MARKER_FILE)
+          end
+        end
+      end
+
+      # libffi library installation Section
+      class InstallLibffi < Taski::Section
+        interfaces :lib_path
+
+        def impl
+          brew = HomebrewPath.path
+          system("#{brew} list #{BREW_NAME} > /dev/null 2>&1") ? Installed : Install
+        end
+
+        BREW_NAME = 'libffi'
+        MARKER_FILE = File.expand_path('~/.kompo_installed_libffi')
+
+        class Installed < Taski::Task
+          def run
+            brew = HomebrewPath.path
+            prefix = `#{brew} --prefix #{BREW_NAME} 2>/dev/null`.chomp
+            @lib_path = "-L#{prefix}/lib" if $CHILD_STATUS.success? && !prefix.empty?
+            puts "#{BREW_NAME} is already installed"
+          end
+        end
+
+        class Install < Taski::Task
+          def run
+            brew = HomebrewPath.path
+            puts "Installing #{BREW_NAME}..."
+            system("#{brew} install #{BREW_NAME}") or raise "Failed to install #{BREW_NAME}"
+            File.write(MARKER_FILE, 'installed')
+
+            prefix = `#{brew} --prefix #{BREW_NAME} 2>/dev/null`.chomp
+            @lib_path = "-L#{prefix}/lib" if $CHILD_STATUS.success? && !prefix.empty?
+          end
+
+          def clean
+            return unless File.exist?(MARKER_FILE)
+
+            brew = HomebrewPath.path
+            puts "Uninstalling #{BREW_NAME} (installed by kompo)..."
+            system("#{brew} uninstall #{BREW_NAME}")
+            File.delete(MARKER_FILE) if File.exist?(MARKER_FILE)
+          end
+        end
+      end
+    end
+
+    # Linux implementation - checks dependencies using pkg-config
+    class ForLinux < Taski::Task
+      def run
+        unless pkg_config_available?
+          puts '[WARNING] pkg-config not found. Skipping dependency check.'
+          puts 'Install pkg-config to enable automatic dependency verification.'
+          @lib_paths = ''
+          return
+        end
+
+        check_dependencies
+        @lib_paths = collect_lib_paths
+
+        puts 'All required development libraries are installed.'
+      end
+
+      REQUIRED_LIBS = {
+        'openssl' => { pkg_config: 'openssl', apt: 'libssl-dev', yum: 'openssl-devel' },
+        'readline' => { pkg_config: 'readline', apt: 'libreadline-dev', yum: 'readline-devel' },
+        'zlib' => { pkg_config: 'zlib', apt: 'zlib1g-dev', yum: 'zlib-devel' },
+        'libyaml' => { pkg_config: 'yaml-0.1', apt: 'libyaml-dev', yum: 'libyaml-devel' },
+        'libffi' => { pkg_config: 'libffi', apt: 'libffi-dev', yum: 'libffi-devel' }
+      }.freeze
+
+      private
+
+      def pkg_config_available?
+        system('which pkg-config > /dev/null 2>&1')
+      end
+
+      def check_dependencies
+        missing = REQUIRED_LIBS.reject do |_, info|
+          system("pkg-config --exists #{info[:pkg_config]} 2>/dev/null")
+        end
+
+        raise build_error_message(missing) unless missing.empty?
+      end
+
+      def collect_lib_paths
+        pkg_names = REQUIRED_LIBS.values.map { |info| info[:pkg_config] }
+        paths = pkg_names.flat_map do |pkg|
+          `pkg-config --libs-only-L #{pkg} 2>/dev/null`.chomp.split
+        end
+        paths.uniq.join(' ')
+      end
+
+      def build_error_message(missing)
+        lib_names = missing.keys.join(', ')
+        apt_packages = missing.values.map { |info| info[:apt] }.join(' ')
+        yum_packages = missing.values.map { |info| info[:yum] }.join(' ')
+
+        <<~MSG
+          Missing required development libraries: #{lib_names}
+
+          Please install them using your package manager:
+
+            Ubuntu/Debian:
+              sudo apt-get update
+              sudo apt-get install -y #{apt_packages}
+
+            RHEL/CentOS/Fedora:
+              sudo yum install -y #{yum_packages}
+              # or: sudo dnf install -y #{yum_packages}
+
+          After installing, run kompo again.
+        MSG
+      end
+    end
+
+    private
+
+    def macos?
+      RUBY_PLATFORM.include?('darwin')
+    end
+  end
+end