kompo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5dbdc8dbc6a43df828ee1915e06cd8bd0e18830c4fadc2405f0d74f4f5c8ee63
+  data.tar.gz: 2a6f1cee640f70c3b4662373bc8d8c0a223ca58dfe041a3666b97561b7be2541
+SHA512:
+  metadata.gz: 8b22210acb628093c71f0094c8e55c9c06009ef1c223c18ce5c3edf99f08b0526a2b0fc40f68181132549927aa70e29c663eb8c56f02b5ffb63ca92b005828c5
+  data.tar.gz: cf8d83c95ebb2d4791aa7edcf7f0ce2553d21b835747ca02ebc001657edb2628ab87c530bde44d2ed288e65f0df77ab2ac8eba90e32fd5838c691b4b06d25f5f

data/.devcontainer/Dockerfile

@@ -0,0 +1,11 @@
+FROM mcr.microsoft.com/devcontainers/base:ubuntu
+# Install the xz-utils package
+RUN apt-get update && apt-get install -y clang
+RUN curl https://sh.rustup.rs -sSf | sh -s -- -y
+ENV PATH="/root/.cargo/bin:$PATH"
+RUN git clone https://github.com/ahogappa0613/kompo-vfs.git && \
+  cd kompo-vfs && \
+  sudo /root/.cargo/bin/cargo build --release && \
+  sudo cp target/release/kompo-cli /usr/local/bin && \
+  sudo cp target/release/libkompo.a /usr/local/lib
+

data/.devcontainer/devcontainer.json

@@ -0,0 +1,29 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/ubuntu
+{
+  "name": "Ubuntu",
+  // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
+  "build": {
+    // Path is relative to the devcontainer.json file.
+    "dockerfile": "Dockerfile"
+  },
+  "features": {
+    "ghcr.io/devcontainers/features/ruby:1": {},
+    // "ghcr.io/devcontainers/features/rust:1": {},
+  },
+  "containerEnv": {
+    // "PATH": "/usr/local/cargo/bin:${containerEnv:PATH}",
+    "KOMPO_CLI": "/usr/local/bin/kompo-cli",
+    "LIB_KOMPO_DIR": "/usr/local/lib",
+  },
+  // Features to add to the dev container. More info: https://containers.dev/features.
+  // "features": {},
+  // Use 'forwardPorts' to make a list of ports inside the container available locally.
+  // "forwardPorts": [],
+  // Use 'postCreateCommand' to run commands after the container is created.
+  // "postCreateCommand": "uname -a",
+  // Configure tool-specific properties.
+  // "customizations": {},
+  // Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+  // "remoteUser": "root"
+}

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in kompo.gemspec
+gemspec
+
+gem "rake", "~> 13.0"

data/Gemfile.lock

@@ -0,0 +1,20 @@
+PATH
+  remote: .
+  specs:
+    kompo (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (13.1.0)
+
+PLATFORMS
+  aarch64-linux
+  arm64-darwin-23
+
+DEPENDENCIES
+  kompo!
+  rake (~> 13.0)
+
+BUNDLED WITH
+   2.4.10

data/README.md

@@ -0,0 +1,47 @@
+# Kompo
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/kompo`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+
+## Usage
+
+### prerequisites
+Install [komp-vfs](https://github.com/ahogappa0613/kompo-vfs).
+
+#### Homebrew
+```sh
+$ brew tap ahogappa0613/kompo-vfs https://github.com/ahogappa0613/kompo-vfs.git
+$ brew install ahogappa0613/kompo-vfs/kompo-vfs
+```
+
+### Quick Start
+If you want to try it out, `cd` to the `sample/` directory and execute the following:
+```sh
+$ kompo
+```
+This will read the Gemfile in the directory and create an executable file with `main.rb` as the entry point in the same directory as `./sample` in the same directory.
+
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ahogappa0613/kompo.

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]

data/exe/kompo

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/kompo'
+require 'optparse'
+
+option = Kompo::Option.new
+
+option.on('-e VAL', '--entrypoint=VAL') { |v| option.entrypoint = v }
+option.on('-o VAL', '--output=VAL') { |v| option.output = v }
+option.on('--[no-]gemfile') { |v| option.gemfile = v }
+option.on('--[no-]stdlib') { |v| option.stdlib = v }
+option.on('--dest-dir=VAL') { |v| option.dest_dir = v }
+option.on('--ruby-src-path=VAL') { |v| option.ruby_src_path = v }
+option.on('--cache-bundle-path=VAL') { |v| option.cache_bundle_path = v }
+option.on('--ruby-version=VAL') { |v| option.ruby_version = v }
+# option.on('--compress') { |v| option.compress = v }
+
+Kompo::Tasks.cd_work_dir(option) do |task|
+  task.clone_ruby_src
+
+  task.fs_cli
+
+  task.make_main_c
+
+  task.packing
+
+  task.copy_to_dest_dir
+end
+
+puts 'info: Finish kompo!'
+
+require 'debug'
+ module Kernel
+   def require(path)
+     debugger
+   end
+   def autoload(const, file)
+     Object.autoload(const, file)
+   end
+ end
+
+ class Module
+   alias original_autoload autoload
+   def autoload(const_name, file)
+      original_autoload(const_name, file)
+   end
+  end
+autoload(:Hoge, 'make_main.rb')

data/lib/kompo/kompo_fs.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+
+class KompoFs
+  class << self
+    def get_start_file_script
+    end
+    def get_start_file_name
+    end
+    def get_load_paths
+    end
+    def get_file_from_fs
+    end
+  end
+end

data/lib/kompo/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Kompo
+  VERSION = "0.1.0"
+end

data/lib/kompo.rb

@@ -0,0 +1,354 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+require 'pathname'
+require 'optparse'
+require "fileutils"
+require 'forwardable'
+require_relative "kompo/version"
+
+module Kompo
+  class Error < StandardError; end
+
+  class Option
+    extend Forwardable
+    attr_accessor :entrypoint, :output_name, :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_name = File.basename(dir)
+      @gemfile = true
+      @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_name 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 = []
+      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
+
+      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',
+        'exts/**/*.o',
+        '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_name
+      ].join(' ')
+
+      exec_command command, 'Packing'
+    end
+
+    def copy_to_dest_dir
+      command = ['cp', '-f', output_name, 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
+end

data/lib/main.c.erb

@@ -0,0 +1,39 @@
+#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 <%= func %>(void);
+<% end %>
+void Init_gems(void)
+{
+  <% exts.each do |(so_path, func)| %>
+    ruby_init_ext("<%= so_path %>", <%= 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();
+
+  ruby_sysinit(&c, &argv);
+
+  RUBY_INIT_STACK;
+  ruby_init();
+
+  Init_kompo_fs();
+  Init_gems();
+
+  void *node = ruby_options(c, argv);
+
+  // set $0
+  ruby_script(get_start_file_name());
+  return ruby_run_node(node);
+}

data/sample/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem 'sinatra'
+gem 'sqlite3', force_ruby_platform: true
+gem 'puma'
+gem 'rackup'

data/sample/Gemfile.lock

@@ -0,0 +1,48 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    base64 (0.2.0)
+    mini_portile2 (2.8.5)
+    mustermann (3.0.0)
+      ruby2_keywords (~> 0.0.1)
+    nio4r (2.7.0)
+    puma (6.4.2)
+      nio4r (~> 2.0)
+    rack (3.0.9.1)
+    rack-protection (4.0.0)
+      base64 (>= 0.1.0)
+      rack (>= 3.0.0, < 4)
+    rack-session (2.0.0)
+      rack (>= 3.0.0)
+    rackup (2.1.0)
+      rack (>= 3)
+      webrick (~> 1.8)
+    ruby2_keywords (0.0.5)
+    sinatra (4.0.0)
+      mustermann (~> 3.0)
+      rack (>= 3.0.0, < 4)
+      rack-protection (= 4.0.0)
+      rack-session (>= 2.0.0, < 3)
+      tilt (~> 2.0)
+    sqlite3 (1.7.2)
+      mini_portile2 (~> 2.8.0)
+    tilt (2.3.0)
+    webrick (1.8.1)
+
+PLATFORMS
+  aarch64-linux
+  arm-linux
+  arm64-darwin
+  ruby
+  x86-linux
+  x86_64-darwin
+  x86_64-linux
+
+DEPENDENCIES
+  puma
+  rackup
+  sinatra
+  sqlite3
+
+BUNDLED WITH
+   2.5.3

data/sample/hello.rb

@@ -0,0 +1,3 @@
+module Hello
+  World = "Hello, World!"
+end

data/sample/main.rb

@@ -0,0 +1,33 @@
+require 'sqlite3'
+require 'sinatra'
+
+require_relative './hello'
+
+File.delete("sample.db") if File.exist?("sample.db")
+
+db = SQLite3::Database.new "sample.db"
+
+rows = db.execute <<-SQL
+  create table numbers (
+    name varchar(30),
+    val int
+  );
+SQL
+
+{
+  "one" => 1,
+  "two" => 2,
+}.each do |pair|
+  db.execute "insert into numbers values ( ?, ? )", pair
+end
+
+set :bind, '0.0.0.0'
+
+get '/' do
+  rows = db.execute 'select * from numbers;'
+  rows.to_s
+end
+
+get '/hello' do
+  Hello::World
+end

data/sig/kompo.rbs

@@ -0,0 +1,4 @@
+module Kompo
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: kompo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sho Hirano
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-04-01 00:00:00.000000000 Z
+dependencies: []
+description: Write a longer description or delete this line.
+email:
+- ahogappa@gmail.com
+executables:
+- kompo
+extensions: []
+extra_rdoc_files: []
+files:
+- ".devcontainer/Dockerfile"
+- ".devcontainer/devcontainer.json"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- exe/kompo
+- lib/kompo.rb
+- lib/kompo/kompo_fs.rb
+- lib/kompo/version.rb
+- lib/main.c.erb
+- sample/Gemfile
+- sample/Gemfile.lock
+- sample/hello.rb
+- sample/main.rb
+- sig/kompo.rbs
+homepage: https://github.com/ahogappa0613/kompo
+licenses: []
+metadata:
+  homepage_uri: https://github.com/ahogappa0613/kompo
+  source_code_uri: https://github.com/ahogappa0613/kompo
+  changelog_uri: https://github.com/ahogappa0613/kompo
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.11
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Write a short summary, because RubyGems requires one.
+test_files: []