kompo 0.1.4 → 0.3.0

data/lib/kompo.rb

@@ -1,356 +1,52 @@
 # frozen_string_literal: true
 
-require "tmpdir"
-require 'pathname'
-require 'optparse'
-require "fileutils"
-require 'forwardable'
-require_relative "kompo/version"
+require 'taski'
+require_relative 'kompo/version'
 
 module Kompo
-  class Error < StandardError; end
-
-  class Option
-    extend Forwardable
-    attr_accessor :entrypoint, :output, :gemfile, :stdlib, :dest_dir, :ruby_src_path, :cache_bundle_path, :ruby_version, :compress, :context, :args
-    delegate %i[on] => :@opt
-
-    def initialize(dir = Dir.getwd, opt = OptionParser.new)
-      @entrypoint = File.join(dir, 'main.rb')
-      @output = File.basename(dir)
-      @gemfile = File.exist?(File.join(Dir.pwd, 'Gemfile'))
-      @stdlib = true
-      @dest_dir = dir
-      @ruby_src_path = nil
-      @cache_bundle_path = nil
-      @ruby_version = "v#{RUBY_VERSION.gsub('.', '_')}"
-      @compress = false
-
-      @context = dir
-      @opt = opt
-    end
-
-    def build
-      @opt.parse!(ARGV)
-
-      @args = convert_absolute_path_for ARGV
-
-      self
-    end
-
-    private
-
-    def convert_absolute_path_for(args)
-      args.map do |arg|
-        if File.absolute_path?(arg)
-          arg
-        else
-          Pathname.new(File.join(context, arg)).cleanpath.to_s
-        end
-      end
-    end
-  end
-
-  class Tasks
-    extend Forwardable
-    attr_reader :task, :fs, :work_dir, :ruby_src_dir, :ruby_pc, :ruby_bin, :extinit_o, :encinit_o, :lib_ruby_static_dir, :bundle_setup, :bundle_ruby, :std_libs, :gem_libs
-
-    delegate %i[entrypoint output gemfile stdlib dest_dir ruby_src_path cache_bundle_path ruby_version compress context args] => :@option
-    delegate %i[komop_cli lib_kompo_dir] => :@fs
-
-    def initialize(option, dir)
-      @option = option
-      @ruby_src_dir = File.expand_path(ruby_src_path || File.join(dir, 'ruby'))
-      @work_dir = dir
-      @fs = Fs.new
-
-      @ruby_pc = File.join(ruby_src_path || File.join(dir, 'dest_dir', 'lib', 'pkgconfig'), 'ruby.pc')
-      @ruby_bin = File.join(ruby_src_path || File.join(dir, 'dest_dir', 'bin'), 'ruby')
-      @extinit_o = File.join(ruby_src_dir, 'ext', 'extinit.o')
-      @encinit_o = File.join(ruby_src_dir, 'enc', 'encinit.o')
-      @lib_ruby_static_dir = ruby_src_path || File.join(dir, 'dest_dir', 'lib')
-
-      @std_libs = []
-      @gem_libs = []
-    end
-
-    def valid?
-      raise "kompo-cli not found. Please install 'kompo-cli'." unless komop_cli
-      raise "libkompo_fs.a not found. Please install 'kompo-cli'." unless lib_kompo_dir
-      raise "Entrypoint not found: '#{entrypoint}'. Please specify the entry file path with '-e' or '--entrypoint' option." unless File.exist?(entrypoint)
-
-      true
-    end
-
-    def self.cd_work_dir(option)
-      Dir.mktmpdir do |dir|
-        task = new(option.build, dir)
-        task.valid?
-        FileUtils.cd(dir)
-
-        yield task
-      end
-    end
-
-    def clone_ruby_src
-      if ruby_src_path.nil?
-        command = ['git', '-C', "#{work_dir}", 'clone', '-b', "#{ruby_version}", '--single-branch', '--depth=1', 'https://github.com/ruby/ruby.git'].join(' ')
-        exec_command command, 'git clone ruby.git'
-
-        Dir.chdir(ruby_src_dir) do
-          exec_command (File.exist?("#{ruby_src_dir}/autogen.sh") ? './autogen.sh' : "autoconf"), 'autoxxx'
-
-          command = [
-            './configure',
-            "--prefix=#{work_dir}/dest_dir",
-            "--disable-install-doc",
-            "--disable-install-rdoc",
-            "--disable-install-capi",
-            "--with-static-linked-ext",
-            "--with-ruby-pc=ruby.pc",
-            "--with-ext=#{get_exts_dir}"
-          ].join(' ')
-          exec_command command, 'configure'
-
-          exec_command ['make', 'install'].join(' '), 'build target version ruby'
-        end
-      end
-    end
-
-    def get_from_ruby_pc(option)
-      command = [
-        'pkg-config',
-        "#{option}",
-        "#{ruby_pc}"
-      ].join(' ')
-
-      exec_command(command, 'pkg-config', true)
-    end
-
-    def bundle_install
-      if cache_bundle_path
-        FileUtils.cp_r(cache_bundle_path, work_dir)
-        @bundle_setup = File.join(cache_bundle_path, 'bundler', 'setup.rb')
-        @bundle_ruby = File.join(cache_bundle_path, 'ruby')
-      else
-        File.write('./bundler', File.read(`which bundle`.chomp).split("\n").tap { _1[0] = "#!#{ruby_bin}" }.join("\n"))
-        FileUtils.chmod(0755, './bundler')
-
-        command = [
-          './bundler',
-          'install',
-          '--standalone'
-        ].join(' ')
-
-        exec_command command, 'bundle install'
-
-        @bundle_setup = File.join(work_dir, 'bundle', 'bundler', 'setup.rb')
-        @bundle_ruby = File.join(work_dir, 'bundle', 'ruby')
-      end
-    end
-
-    def fs_cli
-      command = [
-        komop_cli,
-        context,
-        args.join(' '),
-        get_load_paths,
-        "--entrypoint=#{entrypoint}",
-      ].join(' ')
-
-      exec_command command, 'kompo-cli'
-    end
-
-    def make_main_c
-      require 'erb'
-
-      exts = []
-      if gemfile
-        Dir.glob(File.join(bundle_ruby, get_semantic_ruby_version, 'gems/**/extconf.rb')).each do |makefile_dir|
-          dir_name = File.dirname(makefile_dir)
-          makefile = File.join(dir_name, 'Makefile')
-          if File.exist?(cargo_toml = File.join(dir_name, 'Cargo.toml'))
-            command = [
-              'cargo',
-              'rustc',
-              '--release',
-              '--crate-type=staticlib',
-              '--target-dir',
-              'target',
-              "--manifest-path=#{cargo_toml}",
-            ].join(' ')
-            exec_command command, 'cargo build'
-            copy_targets = Dir.glob(File.join(dir_name, 'target/release/*.a'))
-          else
-            objs = File.read(makefile).scan(/OBJS = (.*\.o)/).join(' ')
-            command = ['make', '-C', dir_name, objs, '--always-make'].join(' ')
-            exec_command command, 'make'
-            copy_targets = objs.split(' ').map { File.join(dir_name, _1) }
-          end
-
-          dir = FileUtils.mkdir_p('exts/' + File.basename(dir_name)).first
-          FileUtils.cp(copy_targets, dir)
-          prefix = File.read(makefile).scan(/target_prefix = (.*)/).join.delete_prefix('/')
-          target_name = File.read(makefile).scan(/TARGET_NAME = (.*)/).join
-          exts << [File.join(prefix, "#{target_name}.so").delete_prefix('/'), "Init_#{target_name}"]
-        end
-      end
-
-      File.write("main.c", ERB.new(File.read(File.join(__dir__, 'main.c.erb'))).result(binding))
-    end
-
-    def packing
-      command = [
-        'gcc',
-        '-O3',
-        '-Wall',
-        'main.c',
-        Dir.glob('exts/**/*.o').join(' '),
-        'fs.o',
-        "#{lib_ruby_static_dir.nil? ? '' : '-L' + lib_ruby_static_dir}",
-        "#{lib_kompo_dir.nil? ? '' : '-L' + lib_kompo_dir}",
-        get_ruby_header,
-        get_exts,
-        '-lkompo',
-        '-lruby-static',
-        get_libs,
-        '-o',
-        output
-      ].join(' ')
-
-      exec_command command, 'Packing'
-    end
-
-    def copy_to_dest_dir
-      command = ['cp', '-f', output, dest_dir].join(' ')
-      exec_command command, 'Copy to dest dir'
-    end
-
-    private
-
-    def exec_command(command, info = nil, ret = false)
-      puts "exec: #{info}" if info
-      puts command
-      if ret
-        ret = `#{command}`.chomp
-        if $?.exited?
-          ret
-        else
-          raise "Failed to execute command: #{command}"
-        end
-      else
-        system command, exception: true
-      end
-    end
-
-    def get_exts
-      ["#{extinit_o}", "#{encinit_o}", *Dir.glob("#{ruby_src_dir}/ext/**/*.a"), *Dir.glob("#{ruby_src_dir}/enc/**/*.a")].join(' ')
-    end
-
-    def get_libs
-      main_lib = get_mainlibs
-      ext_libs = Dir.glob("#{ruby_src_dir}/ext/**/exts.mk").flat_map { File.read(_1).scan(/EXTLIBS = (.*)/) }.join(" ")
-      gem_libs = Dir.glob("bundle/ruby/#{get_semantic_ruby_version}/gems/*/ext/*/Makefile").flat_map{ File.read(_1).scan(/LIBS = (.*)/)}.join(" ")
-      dyn, static = eval("%W[#{main_lib} #{ext_libs} #{gem_libs}]").uniq
-                                                                   .partition { _1 == "-lpthread" || _1 == "-ldl" || _1 == "-lm" || _1 == "-lc" }
-      dyn.unshift "-Wl,-Bdynamic"
-      static.unshift "-Wl,-Bstatic"
-
-      static.join(" ") + " " + dyn.join(" ")
-    end
-
-    def get_ruby_header
-      get_from_ruby_pc('--cflags')
-    end
-
-    def get_semantic_ruby_version
-      get_from_ruby_pc('--variable=ruby_version')
-    end
-
-    def get_mainlibs
-      get_from_ruby_pc('--variable=MAINLIBS')
-    end
-
-    def get_load_paths
-      load_paths = []
-      if gemfile
-        load_paths += gem_libs
-      end
-
-      if stdlib
-        load_paths += std_libs
-      end
-
-      load_paths
-    end
-
-    def get_exts_dir
-      Dir.glob("#{ruby_src_dir}/**/extconf.rb")
-         .reject { _1 =~ /-test-/ }
-         .reject { _1 =~ /win32/ } # TODO
-         .map { File.dirname(_1) }
-         .map { _1.split("#{ruby_src_dir}/ext/")[1] }
-         .join(',')
-    end
-
-    def std_libs
-      return [] unless stdlib
-      return @std_libs unless @std_libs.empty?
-
-      command = ["#{ruby_bin}", '-e', "'puts $:'"].join(' ')
-
-      @std_libs = exec_command(command, 'Check std_libs', true).split("\n")
-    end
-
-    def gem_libs
-      return [] unless gemfile
-      return @gem_libs unless @gem_libs.empty?
-
-      FileUtils.cp_r(File.join(context, 'Gemfile'), work_dir)
-      FileUtils.cp_r(File.join(context, 'Gemfile.lock'), work_dir)
-
-      bundle_install
-
-      command = [
-        "#{ruby_bin}",
-        '-r',
-        "#{bundle_setup}",
-        '-e',
-        "'puts $:'"
-      ].join(' ')
-
-      @gem_libs = (exec_command(command, 'Check gem_libs', true).split("\n") - std_libs)
-    end
-  end
-
-  class Fs
-    attr_reader :komop_cli, :lib_kompo_dir
-
-    def initialize
-      @komop_cli = local_komop_cli || ENV['KOMPO_CLI']
-      @lib_kompo_dir = local_lib_kompo_dir || ENV['LIB_KOMPO_DIR']
-    end
-
-    def local_komop_cli
-      return nil if `which brew`.empty?
-
-      path = `brew --prefix kompo-vfs`.chomp + '/bin/kompo-cli'
-      if File.exist?(path)
-        path
-      else
-        nil
-      end
-    end
-
-    def local_lib_kompo_dir
-      return nil if `which brew`.empty?
-
-      path = `brew --prefix kompo-vfs`.chomp + '/lib'
-      if File.exist?(path)
-        path
-      else
-        nil
-      end
-    end
-  end
+  # 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'
+
+  # Utility classes
+  autoload :KompoIgnore, 'kompo/kompo_ignore'
+
+  # Struct to hold file data for embedding (used by MakeFsC)
+  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'
+
+  # Ruby installation
+  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'
+
+  # Final packing (Section: macOS uses clang, Linux uses gcc)
+  autoload :CollectDependencies, 'kompo/tasks/collect_dependencies'
+  autoload :Packing, 'kompo/tasks/packing'
+
+  # Homebrew path (macOS)
+  autoload :HomebrewPath, 'kompo/tasks/homebrew'
+
+  # Platform-specific dependencies (Section: macOS uses Homebrew, Linux checks via pkg-config)
+  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'
 end
+
+# Load cache methods (module methods, not autoloadable)
+require_relative 'kompo/cache'

data/lib/main.c.erb

@@ -1,39 +1,58 @@
 #include <ruby.h>
-#include <string.h>
 
-extern char *get_kompo_patch(void);
 extern void ruby_init_ext(const char *name, void (*init)(void));
 extern void Init_kompo_fs(void);
-extern char *get_start_file_name(void);
-<% exts.each do |(_, func)| %>
+extern void kompo_fs_set_entrypoint_dir(const char *entrypoint_path);
+<% context.exts.each do |(_, func)| %>
 extern void <%= func %>(void);
 <% end %>
 void Init_gems(void)
 {
-  <% exts.each do |(so_path, func)| %>
-    ruby_init_ext("<%= so_path %>", <%= func %>);
+  <% context.exts.each do |(ext_path, func)| %>
+    ruby_init_ext("<%= ext_path %>.so", <%= func %>);
   <% end %>
 }
 
 int main(int argc, char **argv)
 {
-  int c = 3;
-
-  // HACK: argv[0] is rewritten and reused by setproctitle()
-  argv[1] = "-e";
-  argv[2] = get_kompo_patch();
+<% if context.has_gemfile %>
+  int c = argc + 3;
+  char *argv2[c];
+
+  argv2[0] = argv[0];
+  argv2[1] = (char *)"-r";
+  argv2[2] = (char *)"bundler/setup";
+  argv2[3] = (char *)"<%= context.work_dir_entrypoint %>";
+  for (int i = 1; i < argc; i++) {
+    argv2[i + 3] = argv[i];
+  }
+<% else %>
+  int c = argc + 1;
+  char *argv2[c];
+
+  argv2[0] = argv[0];
+  argv2[1] = (char *)"<%= context.work_dir_entrypoint %>";
+  for (int i = 1; i < argc; i++) {
+    argv2[i + 1] = argv[i];
+  }
+<% end %>
 
-  ruby_sysinit(&c, &argv);
+  char **argv2_ptr = argv2;
+  ruby_sysinit(&c, &argv2_ptr);
 
   RUBY_INIT_STACK;
   ruby_init();
 
   Init_kompo_fs();
+
+  const char *entrypoint = "<%= context.work_dir_entrypoint %>";
+  kompo_fs_set_entrypoint_dir(entrypoint);
+
   Init_gems();
 
-  void *node = ruby_options(c, argv);
+  void *node = ruby_options(c, argv2_ptr);
 
   // set $0
-  ruby_script(get_start_file_name());
+  ruby_script("<%= File.basename(context.project_dir) %>");
   return ruby_run_node(node);
 }

data/rbs_collection.lock.yaml

@@ -0,0 +1,116 @@
+---
+path: ".gem_rbs_collection"
+gems:
+- name: ast
+  version: '2.4'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 2813b6be44d7617d5defa2aaecdbd4540ee1c418
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: async
+  version: '2.12'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 2813b6be44d7617d5defa2aaecdbd4540ee1c418
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: fileutils
+  version: '0'
+  source:
+    type: stdlib
+- name: json
+  version: '0'
+  source:
+    type: stdlib
+- name: logger
+  version: '0'
+  source:
+    type: stdlib
+- name: monitor
+  version: '0'
+  source:
+    type: stdlib
+- name: optparse
+  version: '0'
+  source:
+    type: stdlib
+- name: parallel
+  version: '1.20'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 2813b6be44d7617d5defa2aaecdbd4540ee1c418
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: parser
+  version: '3.2'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 2813b6be44d7617d5defa2aaecdbd4540ee1c418
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: pathname
+  version: '0'
+  source:
+    type: stdlib
+- name: prism
+  version: 1.4.0
+  source:
+    type: rubygems
+- name: rainbow
+  version: '3.0'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 2813b6be44d7617d5defa2aaecdbd4540ee1c418
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: rake
+  version: '13.0'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 2813b6be44d7617d5defa2aaecdbd4540ee1c418
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: rbs
+  version: 3.9.2
+  source:
+    type: rubygems
+- name: rdoc
+  version: '0'
+  source:
+    type: stdlib
+- name: regexp_parser
+  version: '2.8'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 2813b6be44d7617d5defa2aaecdbd4540ee1c418
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: rubocop
+  version: '1.57'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 2813b6be44d7617d5defa2aaecdbd4540ee1c418
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: rubocop-ast
+  version: '1.30'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 2813b6be44d7617d5defa2aaecdbd4540ee1c418
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: tsort
+  version: '0'
+  source:
+    type: stdlib
+gemfile_lock_path: Gemfile.lock

data/rbs_collection.yaml

@@ -0,0 +1,19 @@
+# Download sources
+sources:
+  - type: git
+    name: ruby/gem_rbs_collection
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    revision: main
+    repo_dir: gems
+
+# You can specify local directories as sources also.
+# - type: local
+#   path: path/to/your/local/repository
+
+# A directory to install the downloaded RBSs
+path: .gem_rbs_collection
+
+# gems:
+#   # If you want to avoid installing rbs files for gems, you can specify them here.
+#   - name: GEM_NAME
+#     ignore: true