ruby_workspace_manager 0.6.4 → 0.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38623d16221111f5899c657ecd424a14397cb4b33223ee7d8f95ebd766c61777
-  data.tar.gz: 99992c68cb96d2ce4a7414e2ec5ee0fe5aed244c5fbcf9e3d70887090c1c155b
+  metadata.gz: 115ec9332203fbf44622ec26f179450eb6dcabce1bb9ad7a523bd6cd470b7cdd
+  data.tar.gz: 4d0c0fc8898f786091a86634408b018a236bcfcb772589b30e917bc5d6ece7c0
 SHA512:
-  metadata.gz: 5f1651f55f29fe8cff0bbe731941e52baf5d173139cd62cd1c75ad80d99ae8008a2caf4ef3bea261a27fb8642d74006599eaa30919d1d16349678e4b1a08a927
-  data.tar.gz: f663aebaa0ddaabb9032a6809105eab4df406170eda4f1ed2b540340cebdb16150e9fed5f4df745ca711330b0cc431b156623d9d61e0bb9cb1a4b7ddd34150e4
+  metadata.gz: b0a671c6a7b4e2a66f6120f7a2c635e52e2c9715312fe2b576a298a89878be4ee66f38758e3cbeb1fd865e7c5083ffd10e936d1041fabc10125e807e218b7947
+  data.tar.gz: a787011658b8f986c0b2353fffc97938978113cfd9e549f6d6a8287034a5ae575456661507dde36a4a01e7fc05957bcedb8db381bdc4ef5acb2f925782d874a0

data/lib/rwm/affected_detector.rb

@@ -62,7 +62,7 @@ module Rwm
       _, _, status = Open3.capture3("git", "-C", workspace.root, "rev-parse", "--verify", "#{@base_branch}^{commit}")
       return if status.success?
 
-      raise Rwm::Error, "Base ref '#{@base_branch}' does not exist. Check the branch name or pass a valid --base ref."
+      raise Rwm::InvalidBaseRefError, @base_branch
     end
 
     def detect_base_branch

data/lib/rwm/commands/bootstrap.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "open3"
+
 module Rwm
   module Commands
     class Bootstrap
@@ -140,8 +142,8 @@ module Rwm
         return unless File.exist?(File.join(dir, "Gemfile"))
 
         puts "  bundle install..."
-        success = system("bundle", "install", chdir: dir)
-        unless success
+        _, _, status = Open3.capture3(Rwm.bundle_env(dir), "bundle", "install", chdir: dir)
+        unless status.success?
           raise BootstrapError, "bundle install failed in #{dir}"
         end
       end
@@ -150,13 +152,13 @@ module Rwm
         return unless File.exist?(File.join(dir, "Rakefile"))
 
         # Check if bootstrap task exists before running it
-        has_task = system("bundle", "exec", "rake", "-s", "-T", "bootstrap",
-                          chdir: dir, out: File::NULL, err: File::NULL)
-        return unless has_task
+        _, _, status = Open3.capture3(Rwm.bundle_env(dir), "bundle", "exec", "rake", "-s", "-T", "bootstrap",
+                                      chdir: dir)
+        return unless status.success?
 
         puts "  rake bootstrap..."
-        success = system("bundle", "exec", "rake", "bootstrap", chdir: dir)
-        unless success
+        _, _, status = Open3.capture3(Rwm.bundle_env(dir), "bundle", "exec", "rake", "bootstrap", chdir: dir)
+        unless status.success?
           raise BootstrapError, "rake bootstrap failed in #{dir}"
         end
       end

data/lib/rwm/dependency_graph.rb

@@ -187,22 +187,21 @@ module Rwm
     end
 
     # Serialize to JSON for .rwm/graph.json
-    def to_json_data
+    def to_json_data(workspace_root: "")
       {
         "version" => 1,
         "generated_at" => Time.now.iso8601,
         "packages" => @packages.transform_values do |pkg|
-          { "name" => pkg.name, "type" => pkg.type.to_s, "path" => pkg.relative_path(@workspace_root || "") }
+          { "name" => pkg.name, "type" => pkg.type.to_s, "path" => pkg.relative_path(workspace_root) }
         end,
         "edges" => @edges.transform_values(&:sort)
       }
     end
 
     def save(path, workspace_root)
-      @workspace_root = workspace_root
       dir = File.dirname(path)
       FileUtils.mkdir_p(dir)
-      write_locked(path, JSON.pretty_generate(to_json_data) + "\n")
+      write_locked(path, JSON.pretty_generate(to_json_data(workspace_root: workspace_root)) + "\n")
     end
 
     def to_dot

data/lib/rwm/errors.rb

@@ -40,4 +40,18 @@ module Rwm
   end
 
   class BootstrapError < Error; end
+
+  class InvalidBaseRefError < Error
+    def initialize(ref)
+      super("Base ref '#{ref}' does not exist. Check the branch name or pass a valid --base ref.")
+    end
+  end
+
+  class GemfileParseError < Error
+    def initialize(path, cause_message)
+      super("Failed to parse Gemfile at #{path}: #{cause_message}")
+    end
+  end
+
+  class CacheError < Error; end
 end

data/lib/rwm/gemfile_parser.rb

@@ -17,7 +17,11 @@ module Rwm
 
     def parse
       dsl = Bundler::Dsl.new
-      dsl.eval_gemfile(@gemfile_path)
+      begin
+        dsl.eval_gemfile(@gemfile_path)
+      rescue Bundler::GemfileError, SyntaxError => e
+        raise Rwm::GemfileParseError.new(@gemfile_path, e.message)
+      end
       deps = dsl.dependencies
 
       gemfile_dir = File.expand_path(File.dirname(@gemfile_path))

data/lib/rwm/task_cache.rb

@@ -8,6 +8,11 @@ require "open3"
 
 module Rwm
   class TaskCache
+    # Salt: bump when the hashing scheme changes (file ordering, what gets
+    # included, normalisation rules) so existing caches become misses rather
+    # than wrong hits.
+    CACHE_HASH_VERSION = "v1"
+
     def self.clean(workspace, package_name: nil)
       cache_dir = File.join(workspace.root, ".rwm", "cache")
       return unless Dir.exist?(cache_dir)
@@ -77,33 +82,27 @@ module Rwm
       !matches.empty?
     end
 
-    # Compute a content hash for a package: SHA256 of all source files + dependency hashes
+    # Compute a content hash for a package: SHA256 of all source files + dependency hashes.
+    # Walks `package` and its transitive deps in topological order (deps before dependents)
+    # so each dep's hash is memoised before any package that depends on it is hashed —
+    # avoids the unbounded recursion of the natural recursive formulation on deep chains.
     def content_hash(package)
-      @content_hash_mutex.synchronize do
-        return @content_hashes[package.name] if @content_hashes.key?(package.name)
-      end
+      cached = read_memoised_hash(package.name)
+      return cached if cached
 
-      digest = Digest::SHA256.new
+      needed = @graph.transitive_dependencies(package.name).to_set
+      needed << package.name
 
-      # Hash all source files in the package (sorted for determinism)
-      source_files(package).each do |file|
-        rel_path = file.delete_prefix("#{package.path}/")
-        digest.update(rel_path)
-        digest.update(File.read(file))
-      end
+      @graph.topological_order.each do |name|
+        next unless needed.include?(name)
+        next if read_memoised_hash(name)
 
-      # Include dependency content hashes (transitive invalidation).
-      # If a dependency is missing, let it raise — a stale graph should
-      # not silently produce incorrect cache hits.
-      @graph.dependencies(package.name).sort.each do |dep_name|
-        dep_pkg = @workspace.find_package(dep_name)
-        digest.update(content_hash(dep_pkg))
+        pkg = name == package.name ? package : @workspace.find_package(name)
+        computed = compute_single_package_hash(pkg)
+        @content_hash_mutex.synchronize { @content_hashes[pkg.name] ||= computed }
       end
 
-      computed = digest.hexdigest
-      @content_hash_mutex.synchronize do
-        @content_hashes[package.name] = computed
-      end
+      read_memoised_hash(package.name)
     end
 
     # Preload cache declarations for multiple packages in parallel.
@@ -150,6 +149,39 @@ module Rwm
 
     private
 
+    def read_memoised_hash(name)
+      @content_hash_mutex.synchronize { @content_hashes[name] }
+    end
+
+    def compute_single_package_hash(package)
+      digest = Digest::SHA256.new
+      digest.update(CACHE_HASH_VERSION)
+
+      # Hash all source files in the package (sorted for determinism).
+      # Stream in 64 KiB chunks so multi-MB files don't load whole into memory.
+      source_files(package).each do |file|
+        rel_path = file.delete_prefix("#{package.path}/")
+        digest.update(rel_path)
+        File.open(file, "rb") do |f|
+          while (chunk = f.read(64 * 1024))
+            digest.update(chunk)
+          end
+        end
+      end
+
+      # Dep hashes are guaranteed memoised by the topological iteration in #content_hash.
+      # A nil here means the graph and the in-memory state disagree — surface it
+      # as a typed cache error rather than a generic TypeError from digest.update(nil).
+      @graph.dependencies(package.name).sort.each do |dep_name|
+        dep_hash = read_memoised_hash(dep_name)
+        raise Rwm::CacheError, "Missing memoised hash for dep '#{dep_name}' of '#{package.name}' (stale dep graph?)" if dep_hash.nil?
+
+        digest.update(dep_hash)
+      end
+
+      digest.hexdigest
+    end
+
     def source_files(package)
       # Tracked files + untracked-but-not-ignored files (null-delimited for safe filenames)
       output, _, status = Open3.capture3(

data/lib/rwm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rwm
-  VERSION = "0.6.4"
+  VERSION = "0.6.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_workspace_manager
 version: !ruby/object:Gem::Version
-  version: 0.6.4
+  version: 0.6.5
 platform: ruby
 authors:
 - Siddharth Bhatt