konpeito 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a2c905a6cc383d9539c3d0c1377c4dc8b033636cf8c7b85987e6acb59e4c69c
-  data.tar.gz: 2799693d9a59c0f0b90b0d11bc43da17bd78278aa88b11d3fd0796dfbad5f39b
+  metadata.gz: 1fe9ef9f2b988dc2d9751cecb6f53c2828e1e0d412cecc897557d7988e967b48
+  data.tar.gz: 68b6e211a60e31b48b61858b62902229b0980e786147b2e4427688f169c0caea
 SHA512:
-  metadata.gz: 184994190193063c34ea651f672b04eeb9499e3d08da65cb3b09297ca321b2a0a645241f27fcf993871858ea17defbfdbe0674a4e0ced6298f1c4e595d36c700
-  data.tar.gz: d8689a1392633e4ed8c29756259e6196c3571c68c4148058013b962b09ee1168fec3b6d095f29f8ae2c5aa1262bde0efa2651d4265480507044b51e5d4182c21
+  metadata.gz: 9dbf1f9e6edffb5e9e91af5398620fa96218f2ddde0cddebfa31ab4b90a42c0206cc71d24a6e2035dfd34f3695b7ba5265aef606c91af1b3cdee430609f537de
+  data.tar.gz: 7e595a3ec330e9f359bd5dc412b7d3c9fe9e9a3bef0fde8632f7b35fbe4f9902b174a93a25b11a5ea1e5364983f4ec8d1a92ff3e78a0aa5ebeeaf015bf2dd821

data/lib/konpeito/cache/run_cache.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+require "fileutils"
+
+module Konpeito
+  module Cache
+    # Manages compilation cache for `konpeito run`.
+    # Content-addressed: cache key is SHA256 of all inputs.
+    class RunCache
+      MANIFEST_FILE = "run_manifest.json"
+      DEFAULT_MAX_ENTRIES = 20
+
+      attr_reader :cache_dir
+
+      def initialize(cache_dir: ".konpeito_cache/run")
+        @cache_dir = File.expand_path(cache_dir)
+        @manifest = nil
+        load_manifest
+      end
+
+      # Compute a cache key from all compilation inputs.
+      def compute_cache_key(source_files:, rbs_files:, options_hash:)
+        digest = Digest::SHA256.new
+        source_files.sort.each { |f| digest.update(Digest::SHA256.file(f).hexdigest) }
+        rbs_files.sort.each { |f| digest.update(Digest::SHA256.file(f).hexdigest) }
+        digest.update(options_hash.sort.map { |k, v| "#{k}=#{v}" }.join("|"))
+        digest.update(Konpeito::VERSION)
+        digest.hexdigest
+      end
+
+      # Look up a cached artifact. Returns the path if it exists, nil otherwise.
+      def lookup(cache_key, basename)
+        entry = @manifest["entries"][cache_key]
+        return nil unless entry
+
+        artifact = artifact_path(cache_key, basename)
+        return nil unless File.exist?(artifact)
+
+        # Update last_used_at
+        entry["last_used_at"] = Time.now.iso8601
+        save_manifest
+        artifact
+      end
+
+      # Register a compiled artifact in the manifest.
+      # The artifact should already exist at artifact_dir(cache_key)/basename.
+      def store(cache_key, basename)
+        artifact = artifact_path(cache_key, basename)
+        return nil unless File.exist?(artifact)
+
+        @manifest["entries"][cache_key] = {
+          "basename" => basename,
+          "created_at" => Time.now.iso8601,
+          "last_used_at" => Time.now.iso8601
+        }
+        save_manifest
+        cleanup!
+        artifact
+      end
+
+      # Directory for a given cache key's artifact.
+      def artifact_dir(cache_key)
+        File.join(@cache_dir, cache_key)
+      end
+
+      # Full path to the artifact file.
+      def artifact_path(cache_key, basename)
+        File.join(artifact_dir(cache_key), basename)
+      end
+
+      # Remove all cached entries.
+      def clean!
+        FileUtils.rm_rf(@cache_dir)
+        FileUtils.mkdir_p(@cache_dir)
+        @manifest = create_empty_manifest
+        save_manifest
+      end
+
+      # Evict oldest entries beyond max_entries.
+      def cleanup!(max_entries: DEFAULT_MAX_ENTRIES)
+        entries = @manifest["entries"]
+        return if entries.size <= max_entries
+
+        # Sort by last_used_at ascending (oldest first)
+        sorted = entries.sort_by { |_k, v| v["last_used_at"] || v["created_at"] || "" }
+        to_remove = sorted.first(entries.size - max_entries)
+
+        to_remove.each do |key, _|
+          dir = artifact_dir(key)
+          FileUtils.rm_rf(dir) if Dir.exist?(dir)
+          entries.delete(key)
+        end
+
+        save_manifest
+      end
+
+      private
+
+      def load_manifest
+        FileUtils.mkdir_p(@cache_dir)
+        manifest_path = File.join(@cache_dir, MANIFEST_FILE)
+
+        if File.exist?(manifest_path)
+          begin
+            @manifest = JSON.parse(File.read(manifest_path))
+            # Ensure entries key exists
+            @manifest["entries"] ||= {}
+          rescue JSON::ParserError
+            @manifest = create_empty_manifest
+          end
+        else
+          @manifest = create_empty_manifest
+        end
+      end
+
+      def save_manifest
+        manifest_path = File.join(@cache_dir, MANIFEST_FILE)
+        # Write to tmp file then rename for atomicity
+        tmp_path = "#{manifest_path}.tmp.#{Process.pid}"
+        File.write(tmp_path, JSON.pretty_generate(@manifest))
+        File.rename(tmp_path, manifest_path)
+      rescue StandardError
+        # Best effort — don't crash if manifest write fails
+        FileUtils.rm_f(tmp_path) if tmp_path
+      end
+
+      def create_empty_manifest
+        {
+          "version" => Konpeito::VERSION,
+          "entries" => {}
+        }
+      end
+    end
+  end
+end

data/lib/konpeito/cache.rb

@@ -4,5 +4,6 @@ module Konpeito
   module Cache
     autoload :CacheManager, "konpeito/cache/cache_manager"
     autoload :DependencyGraph, "konpeito/cache/dependency_graph"
+    autoload :RunCache, "konpeito/cache/run_cache"
   end
 end

data/lib/konpeito/cli/completion_command.rb

@@ -102,7 +102,7 @@ module Konpeito
                       ;;
                   run)
                       if [[ "${cur}" == -* ]]; then
-                          COMPREPLY=( $(compgen -W "--target --classpath --rbs -I --require-path --inline -v --verbose --no-color -h --help" -- "${cur}") )
+                          COMPREPLY=( $(compgen -W "--target --classpath --rbs -I --require-path --inline --no-cache --clean-run-cache -v --verbose --no-color -h --help" -- "${cur}") )
                       else
                           COMPREPLY=( $(compgen -f -X '!*.rb' -- "${cur}") )
                       fi
@@ -191,6 +191,8 @@ module Konpeito
                           '-I[Add require search path]:path:_directories' \
                           '--require-path[Add require search path]:path:_directories' \
                           '--inline[Use inline RBS annotations]' \
+                          '--no-cache[Force recompilation]' \
+                          '--clean-run-cache[Clear run cache before building]' \
                           '-v[Verbose output]' \
                           '--verbose[Verbose output]' \
                           '--no-color[Disable colored output]' \
@@ -278,6 +280,9 @@ module Konpeito
           complete -c konpeito -n '__fish_seen_subcommand_from run' -l classpath -r -d 'JVM classpath'
           complete -c konpeito -n '__fish_seen_subcommand_from run' -l rbs -r -d 'RBS type definition file'
           complete -c konpeito -n '__fish_seen_subcommand_from run' -s I -l require-path -r -d 'Add require search path'
+          complete -c konpeito -n '__fish_seen_subcommand_from run' -l inline -d 'Use inline RBS annotations'
+          complete -c konpeito -n '__fish_seen_subcommand_from run' -l no-cache -d 'Force recompilation'
+          complete -c konpeito -n '__fish_seen_subcommand_from run' -l clean-run-cache -d 'Clear run cache'
           complete -c konpeito -n '__fish_seen_subcommand_from run' -s v -l verbose -d 'Verbose output'
           complete -c konpeito -n '__fish_seen_subcommand_from run' -l no-color -d 'Disable colored output'
           complete -c konpeito -n '__fish_seen_subcommand_from run' -F -d 'Ruby source file'

data/lib/konpeito/cli/run_command.rb

@@ -49,7 +49,9 @@ module Konpeito
           rbs_paths: config.rbs_paths.dup,
           require_paths: config.require_paths.dup,
           inline_rbs: false,
-          lib: false
+          lib: false,
+          no_cache: false,
+          clean_run_cache: false
         }
       end
 
@@ -74,6 +76,14 @@ module Konpeito
           options[:inline_rbs] = true
         end
 
+        opts.on("--no-cache", "Force recompilation (skip run cache)") do
+          options[:no_cache] = true
+        end
+
+        opts.on("--clean-run-cache", "Clear the run cache before building") do
+          options[:clean_run_cache] = true
+        end
+
         super
       end
 
@@ -82,7 +92,9 @@ module Konpeito
           Usage: konpeito run [options] [source.rb]
 
           Examples:
-            konpeito run src/main.rb                   Build and run (native)
+            konpeito run src/main.rb                   Build and run (native, cached)
+            konpeito run --no-cache src/main.rb        Force recompilation
+            konpeito run --clean-run-cache src/main.rb Clear cache, then build and run
             konpeito run --inline src/main.rb          Build and run with inline RBS
             konpeito run --target jvm src/main.rb      Build and run (JVM)
         BANNER
@@ -108,14 +120,101 @@ module Konpeito
       end
 
       def run_native(source_file)
+        require "konpeito/cache"
+
+        basename = "#{File.basename(source_file, '.rb')}#{Platform.shared_lib_extension}"
+        run_cache = Cache::RunCache.new
+
+        if options[:clean_run_cache]
+          run_cache.clean!
+          emit("Cleaned", "run cache")
+        end
+
+        if options[:no_cache]
+          build_and_run_tmpdir(source_file, basename)
+          return
+        end
+
+        # Compute cache key once (runs DependencyResolver)
+        cache_key = compute_run_cache_key(source_file, run_cache)
+
+        # Try cache hit
+        if cache_key
+          artifact = run_cache.lookup(cache_key, basename)
+          if artifact
+            emit("Cached", source_file)
+            emit("Running", artifact)
+            run_without_bundler("ruby", "-r", artifact, "-e", "")
+            return
+          end
+        end
+
+        # Cache miss: build into cache dir
+        if cache_key
+          build_and_run_cached(source_file, run_cache, cache_key, basename)
+        else
+          build_and_run_tmpdir(source_file, basename)
+        end
+      end
+
+      def compute_run_cache_key(source_file, run_cache)
+        resolver = DependencyResolver.new(
+          base_paths: options[:require_paths],
+          verbose: false
+        )
+        resolver.resolve(source_file)
+
+        all_sources = resolver.resolved_files.keys
+        auto_rbs = resolver.rbs_paths
+        all_rbs = (options[:rbs_paths].map { |p| File.expand_path(p) } + auto_rbs).uniq
+        all_rbs = all_rbs.select { |f| File.exist?(f) }
+
+        options_hash = {
+          "inline_rbs" => options[:inline_rbs].to_s,
+          "target" => "native"
+        }
+
+        run_cache.compute_cache_key(
+          source_files: all_sources,
+          rbs_files: all_rbs,
+          options_hash: options_hash
+        )
+      rescue StandardError => e
+        puts_verbose("Cache key computation failed: #{e.message}")
+        nil
+      end
+
+      def build_and_run_cached(source_file, run_cache, cache_key, basename)
+        dir = run_cache.artifact_dir(cache_key)
+        FileUtils.mkdir_p(dir)
+        output_file = File.join(dir, basename)
+
+        build_args = build_native_args(source_file, output_file)
+        Commands::BuildCommand.new(build_args, config: config).run
+
+        run_cache.store(cache_key, basename)
+
+        emit("Running", output_file)
+        run_without_bundler("ruby", "-r", output_file, "-e", "")
+      end
+
+      def build_and_run_tmpdir(source_file, basename)
         require "tmpdir"
 
-        # Use a subdirectory to avoid conflicts, but keep the basename matching
-        # the Init_ function name (Ruby requires Init_<basename> to match the filename)
         @run_tmpdir = File.join(Dir.tmpdir, "konpeito_run_#{Process.pid}")
         FileUtils.mkdir_p(@run_tmpdir)
-        output_file = File.join(@run_tmpdir, "#{File.basename(source_file, '.rb')}#{Platform.shared_lib_extension}")
+        output_file = File.join(@run_tmpdir, basename)
+
+        build_args = build_native_args(source_file, output_file)
+        Commands::BuildCommand.new(build_args, config: config).run
+
+        emit("Running", output_file)
+        run_without_bundler("ruby", "-r", output_file, "-e", "")
+      ensure
+        FileUtils.rm_rf(@run_tmpdir) if @run_tmpdir && Dir.exist?(@run_tmpdir)
+      end
 
+      def build_native_args(source_file, output_file)
         build_args = ["-o", output_file]
         build_args << "-v" if options[:verbose]
         build_args << "--no-color" unless options[:color]
@@ -123,15 +222,7 @@ module Konpeito
         options[:rbs_paths].each { |p| build_args << "--rbs" << p }
         options[:require_paths].each { |p| build_args << "-I" << p }
         build_args << source_file
-
-        Commands::BuildCommand.new(build_args, config: config).run
-
-        emit("Running", output_file)
-        # Run without Bundler environment so the compiled extension can load
-        # any installed gem (not just those in the current Gemfile)
-        run_without_bundler("ruby", "-r", output_file, "-e", "")
-      ensure
-        FileUtils.rm_rf(@run_tmpdir) if @run_tmpdir && Dir.exist?(@run_tmpdir)
+        build_args
       end
 
       def build_classpath

data/lib/konpeito/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Konpeito
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: konpeito
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Yasushi Itoh
@@ -64,6 +64,7 @@ files:
 - lib/konpeito/cache.rb
 - lib/konpeito/cache/cache_manager.rb
 - lib/konpeito/cache/dependency_graph.rb
+- lib/konpeito/cache/run_cache.rb
 - lib/konpeito/cli.rb
 - lib/konpeito/cli/base_command.rb
 - lib/konpeito/cli/build_command.rb