kompo 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 537e7d25e2bab44278b2dc1131784bac2b70683e1fde1f8d17e7c51e567bc792
-  data.tar.gz: b28ea160afb248b10e38c6916d3f4adbfc8768dad010e6e686984d514506ae54
+  metadata.gz: 77c057a8598fe8c02319c0635d2bf80cca3578f2606f676adae992dcf34afa68
+  data.tar.gz: 68dfc19d5b9484b5fabe79cd18f8f8bb11368fb0f788a7adc38a44d94aa7aa21
 SHA512:
-  metadata.gz: e2453a6bd240d833523d14661a1aaa132497e4a8da33278010102cfcf957cffc59218350188982683d8f99e4e73d29576d732a7babaa694c9c7081013cc2a046
-  data.tar.gz: ed33f8f19b2d11ab3366ae9b26aa4a036fa4bd83395b6d7240fe829e8eef7a5bcffef96fa4f4e87b2ffa28acab9de80f9771a060c85f08111f6c91ef972a66b9
+  metadata.gz: c1da9b9c3b8f2903977b3ab503822a52586e3cded7af5c96651a3e423efa3e324e99fd82462fcbeba23a9bda06b80a90fe66239be62230b5f39cb6001387ee09
+  data.tar.gz: 63f90fcac1d59773595e696378573e8a1bfbb1cea9581145b729bc7e842dc479a982f0589acdf2f1823b8a21448df4fd8a3c434868e0ba8c281d47d13daed164

data/CHANGELOG.md

@@ -7,6 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.0] - 2025-01-26
+
+### Added
+- `--dry-run` option to show compile command without executing [#17](https://github.com/ahogappa/kompo/pull/17)
+- `--no-gemfile` option to skip Gemfile processing [#13](https://github.com/ahogappa/kompo/pull/13)
+- `.kompoignore` files support for ignoring specific files in VFS [#20](https://github.com/ahogappa/kompo/pull/20)
+- Duplicate file detection in VFS embedding [#15](https://github.com/ahogappa/kompo/pull/15)
+- standardrb lint check to CI [#14](https://github.com/ahogappa/kompo/pull/14)
+
+### Changed
+- Set default progress mode to simple [#16](https://github.com/ahogappa/kompo/pull/16)
+- Bump kompo-vfs minimum version to 0.5.1 [#23](https://github.com/ahogappa/kompo/pull/23)
+- Use Taski.message instead of puts for dry-run output [#21](https://github.com/ahogappa/kompo/pull/21)
+- Remove redundant compile command label from dry-run output [#22](https://github.com/ahogappa/kompo/pull/22)
+- Update README to match actual implementation
+
+### Fixed
+- Extract LIBS from Makefiles including bundled gems [#19](https://github.com/ahogappa/kompo/pull/19)
+- Support bundled gems native extensions for Ruby 4.0+ [#12](https://github.com/ahogappa/kompo/pull/12)
+
 ## [0.3.2] - 2025-01-25
 
 ### Fixed

data/Gemfile

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in kompo.gemspec
 gemspec
 
-gem 'rake', '~> 13.0'
-gem 'taski', '~> 0.8.0'
+gem "rake", "~> 13.0"
+gem "taski", "~> 0.8.0"
 
 group :development, :test do
-  gem 'debug'
-  gem 'minitest'
-  gem 'simplecov', require: false
-  gem 'standard'
+  gem "debug"
+  gem "minitest"
+  gem "simplecov", require: false
+  gem "standard"
 end

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kompo (0.3.2)
+    kompo (0.4.0)
       async
       mini_portile2
       pathspec
@@ -103,7 +103,7 @@ GEM
       lint_roller (~> 1.1)
       rubocop-performance (~> 1.26.0)
     stringio (3.2.0)
-    taski (0.8.0)
+    taski (0.8.3)
       prism (~> 1.4)
       tsort
     traces (0.18.2)

data/README.md

@@ -33,21 +33,36 @@ $ gem install kompo
 
 ## Usage
 
-### prerequisites
-Install [kompo-vfs](https://github.com/ahogappa/kompo-vfs).
+### Prerequisites
+
+Kompo requires [kompo-vfs](https://github.com/ahogappa/kompo-vfs).
+
+#### macOS (Homebrew required)
+
+On macOS, [Homebrew](https://brew.sh) is required to install kompo-vfs:
 
-#### Homebrew
 ```sh
 $ brew tap ahogappa/kompo-vfs https://github.com/ahogappa/kompo-vfs.git
 $ brew install ahogappa/kompo-vfs/kompo-vfs
 ```
 
-### Building
-To build komp-vfs, you need to have cargo installation.
+#### Linux
+
+On Linux, kompo-vfs is automatically built from source. You need to have Cargo (Rust) installed:
+
+```sh
+$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+```
+
+#### For Development
+
+If you want to use a local build of kompo-vfs, build it manually and use the `--local-vfs-path` option:
+
 ```sh
 $ git clone https://github.com/ahogappa/kompo-vfs.git
 $ cd kompo-vfs
 $ cargo build --release
+$ kompo --local-vfs-path=/path/to/kompo-vfs ...
 ```
 
 ## Options
@@ -62,10 +77,13 @@ Options:
         --ruby-source=PATH       Path to Ruby source tarball or directory
         --no-cache               Build Ruby from source, ignoring cache
         --no-stdlib              Exclude Ruby standard library from binary
+        --no-gemfile             Skip Gemfile processing (no bundle install)
         --local-vfs-path=PATH    Path to local kompo-vfs for development
         --clean[=VERSION]        Clean cache (current version by default, or specify VERSION, or "all")
+        --dry-run                Show final compile command without executing it
     -t, --tree                   Show task dependency tree and exit
-    -h, --help                   Show help message
+    -v, --version                Show version
+    -h, --help                   Show this help message
 
 Files:
     Additional files and directories to include in the binary
@@ -81,9 +99,12 @@ Files:
 | `--ruby-source` | Use a local Ruby source instead of downloading. Useful for custom Ruby builds. |
 | `--no-cache` | Force a fresh Ruby build, ignoring any cached version. |
 | `--no-stdlib` | Reduce binary size by excluding Ruby standard library. Only use if your app doesn't need stdlib. |
+| `--no-gemfile` | Skip Gemfile processing and bundle install. Useful when your project doesn't use Bundler. |
 | `--local-vfs-path` | Use a local kompo-vfs build instead of Homebrew installation. Useful for development. |
 | `--clean` | Remove cached Ruby builds. Use `--clean=all` to remove all versions. |
+| `--dry-run` | Show the final compile command without executing it. Useful for debugging build issues. |
 | `-t, --tree` | Display the task dependency graph and exit without building. |
+| `-v, --version` | Display the kompo version and exit. |
 
 ### Examples
 
@@ -137,14 +158,18 @@ node_modules/   # Ignore node_modules
 - Patterns are matched against paths relative to the project root
 - Comments and empty lines are ignored
 
-## examples
+## Samples
+
+Sample applications demonstrating various use cases are available in the [samples](./samples) directory:
 
-* hello
-  * simple hello world script.
-* sinatra_and_sqlite
-  * simple sinatra app with sqlite3.
-* rails
-  * simple Rails 7.1 application.
+* [hello](./samples/hello)
+  * Simple hello world script.
+* [native_gems](./samples/native_gems)
+  * Demonstrates native extension gems (nokogiri, sqlite3, and msgpack).
+* [sinatra_and_sqlite](./samples/sinatra_and_sqlite)
+  * Simple Sinatra app with SQLite3.
+* [rails](./samples/rails/sample)
+  * Simple Rails application.
 
 ## Development
 

data/Rakefile

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require 'bundler/gem_tasks'
-require 'rake/testtask'
+require "bundler/gem_tasks"
+require "rake/testtask"
 
 Rake::TestTask.new(:test) do |t|
-  t.libs << 'test'
-  t.libs << 'lib'
-  t.test_files = FileList['test/**/*_test.rb']
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
 end
 
-require 'standard/rake'
+require "standard/rake"
 
 task default: %i[test standard]

data/exe/kompo

@@ -1,45 +1,47 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require 'optparse'
-require_relative '../lib/kompo'
+require "optparse"
+require_relative "../lib/kompo"
 
 args = {}
 opt = OptionParser.new do |o|
-  o.banner = 'Usage: kompo [options] [files...]'
-  o.separator ''
-  o.separator 'Options:'
+  o.banner = "Usage: kompo [options] [files...]"
+  o.separator ""
+  o.separator "Options:"
 
-  o.on('-e', '--entrypoint=FILE', 'Entry point file (default: main.rb)') { |v| args[:entrypoint] = v }
-  o.on('-o', '--output=DIR', 'Output directory for the binary') { |v| args[:output_dir] = File.expand_path(v) }
-  o.on('--ruby-version=VERSION', "Ruby version to use (default: #{RUBY_VERSION})") { |v| args[:ruby_version] = v }
-  o.on('--ruby-source=PATH', 'Path to Ruby source tarball or directory') do |v|
+  o.on("-e", "--entrypoint=FILE", "Entry point file (default: main.rb)") { |v| args[:entrypoint] = v }
+  o.on("-o", "--output=DIR", "Output directory for the binary") { |v| args[:output_dir] = File.expand_path(v) }
+  o.on("--ruby-version=VERSION", "Ruby version to use (default: #{RUBY_VERSION})") { |v| args[:ruby_version] = v }
+  o.on("--ruby-source=PATH", "Path to Ruby source tarball or directory") do |v|
     args[:ruby_source_path] = File.expand_path(v)
   end
-  o.on('--no-cache', 'Build Ruby from source, ignoring cache') { |_v| args[:no_cache] = true }
-  o.on('--no-stdlib', 'Exclude Ruby standard library from binary') { |_v| args[:no_stdlib] = true }
-  o.on('--local-vfs-path=PATH', 'Path to local kompo-vfs for development') do |v|
+  o.on("--no-cache", "Build Ruby from source, ignoring cache") { |_v| args[:no_cache] = true }
+  o.on("--no-stdlib", "Exclude Ruby standard library from binary") { |_v| args[:no_stdlib] = true }
+  o.on("--no-gemfile", "Skip Gemfile processing (no bundle install)") { |_v| args[:no_gemfile] = true }
+  o.on("--local-vfs-path=PATH", "Path to local kompo-vfs for development") do |v|
     args[:local_kompo_vfs_path] = File.expand_path(v)
   end
-  o.on('--clean[=VERSION]', 'Clean cache (current Ruby version by default, or specify VERSION, or "all")') do |v|
+  o.on("--clean[=VERSION]", 'Clean cache (current Ruby version by default, or specify VERSION, or "all")') do |v|
     args[:clean_cache] = v.nil? ? RUBY_VERSION : v
   end
-  o.on('-t', '--tree', 'Show task dependency tree and exit') do
+  o.on("--dry-run", "Show final compile command without executing it") { |_v| args[:dry_run] = true }
+  o.on("-t", "--tree", "Show task dependency tree and exit") do
     puts Kompo::Packing.tree
     exit(0)
   end
-  o.on('-v', '--version', 'Show version') do
+  o.on("-v", "--version", "Show version") do
     puts "kompo #{Kompo::VERSION}"
     exit(0)
   end
-  o.on('-h', '--help', 'Show this help message') do
+  o.on("-h", "--help", "Show this help message") do
     puts o
     exit(0)
   end
 
-  o.separator ''
-  o.separator 'Files:'
-  o.separator '  Additional files and directories to include in the binary'
+  o.separator ""
+  o.separator "Files:"
+  o.separator "  Additional files and directories to include in the binary"
 end
 opt.parse!(ARGV)
 args[:files] = ARGV

data/lib/kompo/cache.rb

@@ -1,19 +1,19 @@
 # frozen_string_literal: true
 
-require 'fileutils'
+require "fileutils"
 
 module Kompo
   # Clean the cache for specified Ruby version
   # @param version [String] Ruby version to clean, or "all" to clean all caches
   def self.clean_cache(version)
-    kompo_cache = File.expand_path('~/.kompo/cache')
+    kompo_cache = File.expand_path("~/.kompo/cache")
 
     unless Dir.exist?(kompo_cache)
       puts "Cache directory does not exist: #{kompo_cache}"
       return
     end
 
-    if version == 'all'
+    if version == "all"
       clean_all_caches(kompo_cache)
     else
       clean_version_cache(kompo_cache, version)
@@ -22,7 +22,7 @@ module Kompo
 
   # Clean all caches in the cache directory
   def self.clean_all_caches(kompo_cache)
-    entries = Dir.glob(File.join(kompo_cache, '*'))
+    entries = Dir.glob(File.join(kompo_cache, "*"))
     if entries.empty?
       puts "No caches found in #{kompo_cache}"
       return
@@ -33,7 +33,7 @@ module Kompo
       puts "Removed: #{entry}"
     end
 
-    puts 'All caches cleaned successfully'
+    puts "All caches cleaned successfully"
   end
   private_class_method :clean_all_caches
 
@@ -52,8 +52,8 @@ module Kompo
     real_version_cache = File.realpath(version_cache_dir)
 
     unless real_version_cache.start_with?(real_kompo_cache + File::SEPARATOR) ||
-           real_version_cache == real_kompo_cache
-      puts 'Error: Invalid cache path detected (possible path traversal)'
+        real_version_cache == real_kompo_cache
+      puts "Error: Invalid cache path detected (possible path traversal)"
       return
     end
 

data/lib/kompo/kompo_ignore.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require 'pathspec'
+require "pathspec"
 
 module Kompo
   # Handler for .kompoignore file
   # Uses pathspec gem for gitignore-compatible pattern matching
   class KompoIgnore
-    FILENAME = '.kompoignore'
+    FILENAME = ".kompoignore"
 
     def initialize(project_dir)
       @project_dir = project_dir

data/lib/kompo/tasks/build_native_gem.rb

@@ -43,18 +43,40 @@ module Kompo
     def build_extension(ext, work_dir)
       dir_name = ext[:dir_name]
       gem_ext_name = ext[:gem_ext_name]
-      ext_type = ext[:is_rust] ? "Rust" : "C"
 
-      group("Building #{gem_ext_name} (#{ext_type})") do
-        if ext[:is_rust]
-          build_rust_extension(dir_name, ext[:cargo_toml], gem_ext_name, work_dir)
-        else
-          build_c_extension(dir_name, gem_ext_name, work_dir)
+      if ext[:is_prebuilt]
+        # Pre-built bundled gems only need registration for ruby_init_ext()
+        group("Registering #{gem_ext_name} (pre-built bundled gem)") do
+          register_prebuilt_extension(dir_name, gem_ext_name)
+          puts "Registered: #{gem_ext_name}"
         end
+      else
+        ext_type = ext[:is_rust] ? "Rust" : "C"
+        group("Building #{gem_ext_name} (#{ext_type})") do
+          if ext[:is_rust]
+            build_rust_extension(dir_name, ext[:cargo_toml], gem_ext_name, work_dir)
+          else
+            build_c_extension(dir_name, gem_ext_name, work_dir)
+          end
+
+          register_extension(dir_name, gem_ext_name)
+          puts "Built: #{gem_ext_name}"
+        end
+      end
+    end
+
+    # Register pre-built bundled gem extension for ruby_init_ext()
+    # These extensions are already compiled during Ruby build
+    def register_prebuilt_extension(dir_name, gem_ext_name)
+      makefile_path = File.join(dir_name, "Makefile")
 
-        register_extension(dir_name, gem_ext_name)
-        puts "Built: #{gem_ext_name}"
+      unless File.exist?(makefile_path)
+        raise "Cannot register pre-built extension #{gem_ext_name}: Makefile not found in #{dir_name}"
       end
+
+      makefile_content = File.read(makefile_path)
+      prefix, target_name = parse_makefile_metadata(makefile_content, gem_ext_name)
+      add_extension_entry(prefix, target_name)
     end
 
     def register_extension(dir_name, gem_ext_name)
@@ -63,8 +85,7 @@ module Kompo
       if File.exist?(makefile_path)
         # C extension: parse Makefile
         makefile_content = File.read(makefile_path)
-        prefix = makefile_content.scan(/target_prefix = (.*)/).flatten.first&.delete_prefix("/") || ""
-        target_name = makefile_content.scan(/TARGET_NAME = (.*)/).flatten.first || gem_ext_name
+        prefix, target_name = parse_makefile_metadata(makefile_content, gem_ext_name)
       else
         # Rust extension: parse Cargo.toml
         cargo_toml_path = File.join(dir_name, "Cargo.toml")
@@ -82,9 +103,7 @@ module Kompo
         end
       end
 
-      # Path for ruby_init_ext must match require path (without file extension)
-      ext_path = File.join(prefix, target_name).delete_prefix("/")
-      @exts << [ext_path, "Init_#{target_name}"]
+      add_extension_entry(prefix, target_name)
     end
 
     # Parse Cargo.toml to extract target name
@@ -118,6 +137,21 @@ module Kompo
       lib_name || package_name
     end
 
+    # Parse Makefile to extract target_prefix and TARGET_NAME
+    # Returns [prefix, target_name] where prefix is empty string if not specified
+    def parse_makefile_metadata(makefile_content, fallback_name)
+      prefix = makefile_content.scan(/target_prefix = (.*)/).flatten.first&.delete_prefix("/") || ""
+      target_name = makefile_content.scan(/TARGET_NAME = (.*)/).flatten.first || fallback_name
+      [prefix, target_name]
+    end
+
+    # Add extension entry to @exts for ruby_init_ext()
+    # ext_path must match the require path (without file extension)
+    def add_extension_entry(prefix, target_name)
+      ext_path = File.join(prefix, target_name).delete_prefix("/")
+      @exts << [ext_path, "Init_#{target_name}"]
+    end
+
     def build_rust_extension(dir_name, cargo_toml, gem_ext_name, work_dir)
       cargo = CargoPath.path
 
@@ -162,8 +196,7 @@ module Kompo
 
       # Get full extension path (prefix/target_name) for proper directory structure
       # This ensures erb/escape and cgi/escape are stored in different directories
-      prefix = makefile_content.scan(/target_prefix = (.*)/).flatten.first&.delete_prefix("/") || ""
-      target_name = makefile_content.scan(/TARGET_NAME = (.*)/).flatten.first || gem_ext_name
+      prefix, target_name = parse_makefile_metadata(makefile_content, gem_ext_name)
       ext_path = File.join(prefix, target_name).delete_prefix("/")
       dest_ext_dir = File.join(work_dir, "ext", ext_path)
 

data/lib/kompo/tasks/bundle_install.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require 'fileutils'
-require 'digest'
-require 'json'
-require 'bundler'
+require "fileutils"
+require "digest"
+require "json"
+require "bundler"
 
 module Kompo
   # Shared helpers for bundle cache operations
@@ -19,7 +19,7 @@ module Kompo
 
     def compute_gemfile_lock_hash
       work_dir = WorkDir.path
-      gemfile_lock_path = File.join(work_dir, 'Gemfile.lock')
+      gemfile_lock_path = File.join(work_dir, "Gemfile.lock")
       return nil unless File.exist?(gemfile_lock_path)
 
       content = File.read(gemfile_lock_path)
@@ -53,10 +53,10 @@ module Kompo
         work_dir = WorkDir.path
         ruby_major_minor = InstallRuby.ruby_major_minor
 
-        @bundle_ruby_dir = File.join(work_dir, 'bundle', 'ruby', "#{ruby_major_minor}.0")
-        @bundler_config_path = File.join(work_dir, '.bundle', 'config')
+        @bundle_ruby_dir = File.join(work_dir, "bundle", "ruby", "#{ruby_major_minor}.0")
+        @bundler_config_path = File.join(work_dir, ".bundle", "config")
 
-        kompo_cache = Taski.args.fetch(:kompo_cache, File.expand_path('~/.kompo/cache'))
+        kompo_cache = Taski.args.fetch(:kompo_cache, File.expand_path("~/.kompo/cache"))
         ruby_version = InstallRuby.ruby_version
         version_cache_dir = File.join(kompo_cache, ruby_version)
 
@@ -65,19 +65,19 @@ module Kompo
 
         cache_dir = File.join(version_cache_dir, bundle_cache_name)
 
-        group('Restoring bundle from cache') do
+        group("Restoring bundle from cache") do
           # Clean up existing files in case work_dir is reused
-          FileUtils.rm_rf(File.join(work_dir, 'bundle')) if Dir.exist?(File.join(work_dir, 'bundle'))
-          FileUtils.rm_rf(File.join(work_dir, '.bundle')) if Dir.exist?(File.join(work_dir, '.bundle'))
+          FileUtils.rm_rf(File.join(work_dir, "bundle")) if Dir.exist?(File.join(work_dir, "bundle"))
+          FileUtils.rm_rf(File.join(work_dir, ".bundle")) if Dir.exist?(File.join(work_dir, ".bundle"))
 
           # Copy from cache
-          FileUtils.cp_r(File.join(cache_dir, 'bundle'), File.join(work_dir, 'bundle'))
-          FileUtils.cp_r(File.join(cache_dir, '.bundle'), File.join(work_dir, '.bundle'))
+          FileUtils.cp_r(File.join(cache_dir, "bundle"), File.join(work_dir, "bundle"))
+          FileUtils.cp_r(File.join(cache_dir, ".bundle"), File.join(work_dir, ".bundle"))
 
           puts "Restored from: #{cache_dir}"
         end
 
-        puts 'Bundle restored from cache'
+        puts "Bundle restored from cache"
       end
 
       def clean
@@ -89,7 +89,7 @@ module Kompo
 
           FileUtils.rm_rf(path) if File.exist?(path)
         end
-        puts 'Cleaned up bundle installation'
+        puts "Cleaned up bundle installation"
       end
     end
 
@@ -102,33 +102,33 @@ module Kompo
         bundler = InstallRuby.bundler_path
         ruby_major_minor = InstallRuby.ruby_major_minor
 
-        @bundle_ruby_dir = File.join(work_dir, 'bundle', 'ruby', "#{ruby_major_minor}.0")
-        @bundler_config_path = File.join(work_dir, '.bundle', 'config')
+        @bundle_ruby_dir = File.join(work_dir, "bundle", "ruby", "#{ruby_major_minor}.0")
+        @bundler_config_path = File.join(work_dir, ".bundle", "config")
 
-        puts 'Running bundle install --path bundle...'
-        gemfile_path = File.join(work_dir, 'Gemfile')
+        puts "Running bundle install --path bundle..."
+        gemfile_path = File.join(work_dir, "Gemfile")
 
         # Clear Bundler environment and specify Gemfile path explicitly
         Bundler.with_unbundled_env do
           ruby = InstallRuby.ruby_path
-          env = { 'BUNDLE_GEMFILE' => gemfile_path }
+          env = {"BUNDLE_GEMFILE" => gemfile_path}
 
           # Suppress clang 18+ warning that causes mkmf try_cppflags to fail
           # This flag is clang-specific and not recognized by GCC
           if clang_compiler?
-            env['CFLAGS'] = '-Wno-default-const-init-field-unsafe'
-            env['CPPFLAGS'] = '-Wno-default-const-init-field-unsafe'
+            env["CFLAGS"] = "-Wno-default-const-init-field-unsafe"
+            env["CPPFLAGS"] = "-Wno-default-const-init-field-unsafe"
           end
 
           # Set BUNDLE_PATH to "bundle" - standard Bundler reads .bundle/config
           # and finds gems in {BUNDLE_PATH}/ruby/X.X.X/gems/
           # Use ruby to execute bundler to avoid shebang issues
-          system({ 'BUNDLE_GEMFILE' => gemfile_path }, ruby, bundler, 'config', 'set', '--local', 'path',
-                 'bundle') or raise 'Failed to set bundle path'
-          system(env, ruby, bundler, 'install') or raise 'Failed to run bundle install'
+          system({"BUNDLE_GEMFILE" => gemfile_path}, ruby, bundler, "config", "set", "--local", "path",
+            "bundle") or raise "Failed to set bundle path"
+          system(env, ruby, bundler, "install") or raise "Failed to run bundle install"
         end
 
-        puts 'Bundle installed successfully'
+        puts "Bundle installed successfully"
 
         # Save to cache
         save_to_cache(work_dir)
@@ -143,18 +143,18 @@ module Kompo
 
           FileUtils.rm_rf(path) if File.exist?(path)
         end
-        puts 'Cleaned up bundle installation'
+        puts "Cleaned up bundle installation"
       end
 
       private
 
       def clang_compiler?
         output = `cc --version 2>&1`
-        output.include?('clang')
+        output.include?("clang")
       rescue Errno::ENOENT => e
         warn "cc command not found: #{e.message}"
         false
-      rescue StandardError => e
+      rescue => e
         warn "Error checking compiler: #{e.message}"
         false
       end
@@ -163,27 +163,27 @@ module Kompo
         bundle_cache_name = compute_bundle_cache_name
         return unless bundle_cache_name
 
-        kompo_cache = Taski.args.fetch(:kompo_cache, File.expand_path('~/.kompo/cache'))
+        kompo_cache = Taski.args.fetch(:kompo_cache, File.expand_path("~/.kompo/cache"))
         ruby_version = InstallRuby.ruby_version
         version_cache_dir = File.join(kompo_cache, ruby_version)
         cache_dir = File.join(version_cache_dir, bundle_cache_name)
 
-        group('Saving bundle to cache') do
+        group("Saving bundle to cache") do
           # Remove old cache if exists
           FileUtils.rm_rf(cache_dir) if Dir.exist?(cache_dir)
           FileUtils.mkdir_p(cache_dir)
 
           # Copy to cache
-          FileUtils.cp_r(File.join(work_dir, 'bundle'), File.join(cache_dir, 'bundle'))
-          FileUtils.cp_r(File.join(work_dir, '.bundle'), File.join(cache_dir, '.bundle'))
+          FileUtils.cp_r(File.join(work_dir, "bundle"), File.join(cache_dir, "bundle"))
+          FileUtils.cp_r(File.join(work_dir, ".bundle"), File.join(cache_dir, ".bundle"))
 
           # Save metadata
           metadata = {
-            'ruby_version' => ruby_version,
-            'gemfile_lock_hash' => compute_gemfile_lock_hash,
-            'created_at' => Time.now.iso8601
+            "ruby_version" => ruby_version,
+            "gemfile_lock_hash" => compute_gemfile_lock_hash,
+            "created_at" => Time.now.iso8601
           }
-          File.write(File.join(cache_dir, 'metadata.json'), JSON.pretty_generate(metadata))
+          File.write(File.join(cache_dir, "metadata.json"), JSON.pretty_generate(metadata))
 
           puts "Saved to: #{cache_dir}"
         end
@@ -193,7 +193,7 @@ module Kompo
     # Skip bundle install when no Gemfile
     class Skip < Taski::Task
       def run
-        puts 'No Gemfile, skipping bundle install'
+        puts "No Gemfile, skipping bundle install"
         @bundle_ruby_dir = nil
         @bundler_config_path = nil
       end
@@ -209,14 +209,14 @@ module Kompo
       bundle_cache_name = compute_bundle_cache_name
       return false unless bundle_cache_name
 
-      kompo_cache = Taski.args.fetch(:kompo_cache, File.expand_path('~/.kompo/cache'))
+      kompo_cache = Taski.args.fetch(:kompo_cache, File.expand_path("~/.kompo/cache"))
       ruby_version = InstallRuby.ruby_version
       version_cache_dir = File.join(kompo_cache, ruby_version)
       cache_dir = File.join(version_cache_dir, bundle_cache_name)
 
-      cache_bundle_dir = File.join(cache_dir, 'bundle')
-      cache_bundle_config = File.join(cache_dir, '.bundle')
-      cache_metadata = File.join(cache_dir, 'metadata.json')
+      cache_bundle_dir = File.join(cache_dir, "bundle")
+      cache_bundle_config = File.join(cache_dir, ".bundle")
+      cache_metadata = File.join(cache_dir, "metadata.json")
 
       Dir.exist?(cache_bundle_dir) && Dir.exist?(cache_bundle_config) && File.exist?(cache_metadata)
     end