ruby_workspace_manager 0.5.0 → 0.6.0

data/lib/rwm/affected_detector.rb

@@ -4,6 +4,19 @@ require "open3"
 
 module Rwm
   class AffectedDetector
+    IGNORED_ROOT_PATTERNS = [
+      "*.md",
+      "LICENSE*",
+      "CHANGELOG*",
+      ".github/**",
+      ".vscode/**",
+      ".idea/**",
+      "docs/**",
+      ".rwm/**",
+    ].freeze
+
+    IGNORE_FILE = "affected_ignore"
+
     attr_reader :workspace, :graph, :base_branch
 
     def initialize(workspace, graph, committed_only: false, base_branch: nil)
@@ -20,7 +33,10 @@ module Rwm
 
       # If root-level files changed (outside any package), all packages are affected
       root_files = changed_files.reject { |f| file_in_any_package?(f) }
-      unless root_files.empty?
+      significant_root_files = root_files.reject { |f| ignored_root_file?(f) }
+
+      unless significant_root_files.empty?
+        Rwm.debug("affected: significant root files changed: #{significant_root_files.join(', ')}")
         return workspace.packages
       end
 
@@ -111,5 +127,25 @@ module Rwm
         file.start_with?("#{rel_path}/")
       end
     end
+
+    def ignored_root_file?(file)
+      ignore_patterns.any? do |pattern|
+        File.fnmatch(pattern, file, File::FNM_DOTMATCH)
+      end
+    end
+
+    def ignore_patterns
+      patterns = IGNORED_ROOT_PATTERNS.dup
+      ignore_file = File.join(workspace.root, ".rwm", IGNORE_FILE)
+      if File.exist?(ignore_file)
+        File.readlines(ignore_file).each do |line|
+          line = line.strip
+          next if line.empty? || line.start_with?("#")
+
+          patterns << line
+        end
+      end
+      patterns
+    end
   end
 end

data/lib/rwm/cli.rb

@@ -51,9 +51,16 @@ module Rwm
       const_name = COMMANDS[command_name]
       command_class = const_name.split("::").reduce(Rwm) { |mod, name| mod.const_get(name) }
       command_class.new(@argv).run
+    rescue Interrupt
+      $stderr.puts "\nInterrupted."
+      130
     rescue Rwm::Error => e
       $stderr.puts "Error: #{e.message}"
       1
+    rescue StandardError => e
+      $stderr.puts "Error: #{e.message}"
+      Rwm.debug("#{e.class}: #{e.message}\n#{e.backtrace&.join("\n")}")
+      1
     end
 
     private

data/lib/rwm/commands/affected.rb

@@ -49,7 +49,7 @@ module Rwm
           end
         end
 
-        parser.order!(@argv)
+        parser.parse!(@argv)
       end
     end
   end

data/lib/rwm/commands/init.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "open3"
 require "optparse"
 
 module Rwm
@@ -11,6 +12,7 @@ module Rwm
 
         source "https://rubygems.org"
 
+        gem "rake"
         gem "ruby_workspace_manager"
       GEMFILE
 
@@ -30,7 +32,7 @@ module Rwm
       end
 
       def run
-        root = Dir.pwd
+        root = detect_git_root
 
         create_directories(root)
         create_gemfile(root)
@@ -52,6 +54,13 @@ module Rwm
 
       private
 
+      def detect_git_root
+        out, _, status = Open3.capture3("git", "rev-parse", "--show-toplevel")
+        raise Rwm::Error, "Not inside a git repository. Run `git init` first." unless status.success?
+
+        out.chomp
+      end
+
       def parse_options
         OptionParser.new do |opts|
           opts.on("--vscode", "Generate VSCode .code-workspace file") do

data/lib/rwm/commands/new.rb

@@ -1,12 +1,17 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "optparse"
 
 module Rwm
   module Commands
     class New
+      VALID_TEST_FRAMEWORKS = %w[rspec minitest none].freeze
+
       def initialize(argv)
         @argv = argv
+        @test_framework = "rspec"
+        parse_options
       end
 
       def run
@@ -52,35 +57,60 @@ module Rwm
         VscodeWorkspace.new(fresh_workspace.root).generate(fresh_workspace.packages)
       end
 
+      def parse_options
+        OptionParser.new do |opts|
+          opts.on("--test=FRAMEWORK", VALID_TEST_FRAMEWORKS, "Test framework (#{VALID_TEST_FRAMEWORKS.join(', ')})") do |fw|
+            @test_framework = fw
+          end
+        end.parse!(@argv)
+      end
+
       def scaffold(pkg_path, name, type)
         source_dir = type == "lib" ? "lib" : "app"
         FileUtils.mkdir_p(File.join(pkg_path, source_dir, name))
-        FileUtils.mkdir_p(File.join(pkg_path, "spec"))
 
         write_gemfile(pkg_path, name)
         write_gemspec(pkg_path, name, type)
         write_rakefile(pkg_path, name)
         write_entry_file(pkg_path, name, type)
-        write_spec_helper(pkg_path)
+
+        case @test_framework
+        when "rspec"
+          FileUtils.mkdir_p(File.join(pkg_path, "spec"))
+          write_spec_helper(pkg_path)
+        when "minitest"
+          FileUtils.mkdir_p(File.join(pkg_path, "test"))
+          write_test_helper(pkg_path)
+        end
       end
 
       def write_gemfile(pkg_path, name)
-        File.write(File.join(pkg_path, "Gemfile"), <<~GEMFILE)
-          # frozen_string_literal: true
-
-          source "https://rubygems.org"
+        test_gem_line = case @test_framework
+                        when "rspec"    then '  gem "rspec"'
+                        when "minitest" then '  gem "minitest"'
+                        end
 
-          gemspec
-
-          group :development, :test do
-            gem "rake"
-            gem "rspec"
-            gem "ruby_workspace_manager"
-          end
+        lines = [
+          '# frozen_string_literal: true',
+          '',
+          'source "https://rubygems.org"',
+          '',
+          'gemspec',
+          '',
+          'group :development, :test do',
+          '  gem "rake"',
+        ]
+        lines << test_gem_line if test_gem_line
+        lines.concat([
+          '  gem "ruby_workspace_manager"',
+          'end',
+          '',
+          'require "rwm/gemfile"',
+          '# rwm_lib "some_dependency"',
+          '',
+        ])
 
-          require "rwm/gemfile"
-          # rwm_lib "some_dependency"
-        GEMFILE
+        File.write(File.join(pkg_path, "Gemfile"), lines.join("\n"))
       end
 
       def write_gemspec(pkg_path, name, type)
@@ -106,21 +136,44 @@ module Rwm
       end
 
       def write_rakefile(pkg_path, name)
-        File.write(File.join(pkg_path, "Rakefile"), <<~RAKEFILE)
-          # frozen_string_literal: true
+        lines = [
+          '# frozen_string_literal: true',
+          '',
+          'require "rwm/rake"',
+          '',
+        ]
 
-          require "rwm/rake"
+        case @test_framework
+        when "rspec"
+          lines.concat([
+            'cacheable_task :spec do',
+            '  sh "bundle exec rspec"',
+            'end',
+            '',
+          ])
+        when "minitest"
+          lines.concat([
+            'cacheable_task :test do',
+            '  sh "bundle exec ruby -Ilib:test -e \'Dir.glob(\"test/**/*_test.rb\").each { |f| require_relative f }\'"',
+            'end',
+            '',
+          ])
+        end
 
-          cacheable_task :spec do
-            sh "bundle exec rspec"
-          end
+        lines.concat([
+          "task :bootstrap do",
+          "  puts \"Add bootstrap steps for #{name} here.\"",
+          "end",
+          "",
+        ])
 
-          task :bootstrap do
-            puts "Add bootstrap steps for #{name} here."
-          end
+        if @test_framework != "none"
+          task_name = @test_framework == "rspec" ? ":spec" : ":test"
+          lines << "task default: #{task_name}"
+          lines << ""
+        end
 
-          task default: :spec
-        RAKEFILE
+        File.write(File.join(pkg_path, "Rakefile"), lines.join("\n"))
       end
 
       def write_entry_file(pkg_path, name, type)
@@ -145,6 +198,14 @@ module Rwm
         RUBY
       end
 
+      def write_test_helper(pkg_path)
+        File.write(File.join(pkg_path, "test", "test_helper.rb"), <<~RUBY)
+          # frozen_string_literal: true
+
+          require "minitest/autorun"
+        RUBY
+      end
+
       def camelize(name)
         name.split("_").map(&:capitalize).join
       end

data/lib/rwm/commands/run.rb

@@ -62,6 +62,7 @@ module Rwm
         # Auto-detect cacheable tasks unless --no-cache
         cache = TaskCache.new(workspace, graph) unless @no_cache
         if cache
+          cache.preload_declarations(runnable)
           cacheable, not_cacheable = runnable.partition { |pkg| cache.cacheable?(pkg, task) }
           cached, uncached = cacheable.partition { |pkg| cache.cached?(pkg, task) }
           cached.each { |pkg| puts "[#{pkg.name}] cached" }
@@ -90,35 +91,36 @@ module Rwm
         # Store cache for successful cacheable packages
         if cache
           runner.results.each do |result|
-            next unless result.success
-            next if result.skipped
+            next unless result.passed?
 
             pkg = workspace.find_package(result.package_name)
             cache.store(pkg, task) if cache.cacheable?(pkg, task)
           end
         end
 
-        passed, rest = runner.results.partition { |r| r.success && !r.skipped }
-        failed, skipped = rest.partition { |r| !r.success }
-        skipped_from_rest = runner.results.select(&:skipped)
+        passed = runner.results.count(&:passed?)
+        failed_results = runner.results.select { |r| r.failed? || r.errored? }
+        skipped = runner.results.count { |r| r.skipped? || r.dep_skipped? }
 
         total = runner.results.size
         parts = []
-        parts << "#{passed.size} passed" unless passed.empty?
-        parts << "#{failed.size} failed" unless failed.empty?
-        parts << "#{skipped_from_rest.size} skipped" unless skipped_from_rest.empty?
+        parts << "#{passed} passed" unless passed.zero?
+        parts << "#{failed_results.size} failed" unless failed_results.empty?
+        parts << "#{skipped} skipped" unless skipped.zero?
 
         puts
         puts "#{total} package(s): #{parts.join(", ")}."
 
-        Rwm.debug("passed: #{passed.map(&:package_name).join(", ")}") unless passed.empty?
-        Rwm.debug("skipped (no matching task): #{skipped_from_rest.map(&:package_name).join(", ")}") unless skipped_from_rest.empty?
+        passed_results = runner.results.select(&:passed?)
+        skipped_results = runner.results.select { |r| r.skipped? || r.dep_skipped? }
+        Rwm.debug("passed: #{passed_results.map(&:package_name).join(", ")}") unless passed_results.empty?
+        Rwm.debug("skipped (no matching task): #{skipped_results.map(&:package_name).join(", ")}") unless skipped_results.empty?
 
-        if failed.empty?
+        if failed_results.empty?
           0
         else
           $stderr.puts "Failed:"
-          failed.each { |r| $stderr.puts "  - #{r.package_name}" }
+          failed_results.each { |r| $stderr.puts "  - #{r.package_name}" }
           1
         end
       end
@@ -150,7 +152,7 @@ module Rwm
           end
         end
 
-        parser.order!(@argv)
+        parser.parse!(@argv)
       end
     end
   end

data/lib/rwm/dependency_graph.rb

@@ -70,17 +70,17 @@ module Rwm
       return [] if @packages.empty?
 
       remaining = @packages.keys.dup
+      placed = Set.new
       levels = []
 
       until remaining.empty?
-        # Find packages whose deps are all already placed in earlier levels
-        placed = levels.flatten
         level = remaining.select do |name|
           dependencies(name).all? { |dep| placed.include?(dep) }
         end
 
         raise CycleError, [["Unable to resolve execution levels — possible cycle"]] if level.empty?
 
+        level.each { |name| placed.add(name) }
         levels << level.sort
         remaining -= level
       end
@@ -103,7 +103,7 @@ module Rwm
       end
 
       Rwm.debug("graph: loading from cache at #{path}")
-      data = JSON.parse(File.read(path))
+      data = JSON.parse(read_locked(path))
       graph = new
 
       workspace.packages.each { |pkg| graph.add_package(pkg) }
@@ -126,7 +126,16 @@ module Rwm
       packages.any? { |pkg| File.mtime(pkg.gemfile_path) > graph_mtime }
     end
 
-    private_class_method :stale?, :build_and_save
+    def self.read_locked(path)
+      File.open(path, "r") do |f|
+        f.flock(File::LOCK_SH)
+        f.read
+      end
+    rescue Errno::ENOTSUP
+      File.read(path)
+    end
+
+    private_class_method :stale?, :build_and_save, :read_locked
 
     # Build graph from a workspace by parsing all Gemfiles
     def self.build(workspace)
@@ -158,7 +167,7 @@ module Rwm
       @workspace_root = workspace_root
       dir = File.dirname(path)
       FileUtils.mkdir_p(dir)
-      File.write(path, JSON.pretty_generate(to_json_data) + "\n")
+      write_locked(path, JSON.pretty_generate(to_json_data) + "\n")
     end
 
     def to_dot
@@ -200,6 +209,15 @@ module Rwm
 
     private
 
+    def write_locked(path, content)
+      File.open(path, File::CREAT | File::WRONLY | File::TRUNC) do |f|
+        f.flock(File::LOCK_EX)
+        f.write(content)
+      end
+    rescue Errno::ENOTSUP
+      File.write(path, content)
+    end
+
     # TSort interface
     def tsort_each_node(&block)
       @packages.each_key(&block)

data/lib/rwm/gemfile.rb

@@ -38,7 +38,7 @@ module Rwm
       return if @rwm_resolved.include?(name)
 
       @rwm_resolved.add(name)
-      Rwm.resolved_libs.add(name)
+      Rwm.resolved_libs.add(name) unless @rwm_scanning
 
       path = File.join(rwm_workspace_root, "libs", name)
       gem(name, **opts, path: path)
@@ -54,6 +54,7 @@ module Rwm
 
     def scan_transitive_deps(gemfile_path)
       sandbox = Bundler::Dsl.new
+      sandbox.instance_variable_set(:@rwm_scanning, true)
       sandbox.eval_gemfile(gemfile_path)
 
       libs_prefix = File.join(rwm_workspace_root, "libs") + "/"

data/lib/rwm/task_cache.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "digest"
+require "etc"
 require "fileutils"
 require "json"
 require "open3"
@@ -24,6 +25,7 @@ module Rwm
       @cache_dir = File.join(workspace.root, ".rwm", "cache")
       @content_hashes = {}
       @cache_declarations = {}
+      @declarations_mutex = Mutex.new
     end
 
     # Returns true if the task is declared cacheable in the package's Rakefile
@@ -98,19 +100,46 @@ module Rwm
       @content_hashes[package.name] = digest.hexdigest
     end
 
+    # Preload cache declarations for multiple packages in parallel.
+    # Warms the memoization hash so subsequent cacheable?/cached? calls are instant.
+    def preload_declarations(packages)
+      pending = packages.reject { |pkg| @cache_declarations.key?(pkg.name) }
+      return if pending.empty?
+
+      Rwm.debug("cache declarations: preloading #{pending.size} package(s) in parallel")
+      concurrency = [Etc.nprocessors, pending.size].min
+      threads = []
+
+      pending.each_slice((pending.size.to_f / concurrency).ceil) do |batch|
+        threads << Thread.new do
+          batch.each { |pkg| cache_declarations(pkg) }
+        end
+      end
+
+      threads.each(&:join)
+    end
+
     # Discover cacheable task declarations by running `bundle exec rake rwm:cache_config`
     def cache_declarations(package)
-      return @cache_declarations[package.name] if @cache_declarations.key?(package.name)
+      @declarations_mutex.synchronize do
+        return @cache_declarations[package.name] if @cache_declarations.key?(package.name)
+      end
 
       Rwm.debug("cache declarations: discovering for #{package.name}")
       output, _, status = Open3.capture3("bundle", "exec", "rake", "rwm:cache_config", chdir: package.path)
-      @cache_declarations[package.name] = if status.success? && !output.strip.empty?
-                                             JSON.parse(output.strip)
-                                           else
-                                             {}
-                                           end
+      result = if status.success? && !output.strip.empty?
+                 JSON.parse(output.strip)
+               else
+                 {}
+               end
+
+      @declarations_mutex.synchronize do
+        @cache_declarations[package.name] = result
+      end
     rescue JSON::ParserError
-      @cache_declarations[package.name] = {}
+      @declarations_mutex.synchronize do
+        @cache_declarations[package.name] = {}
+      end
     end
 
     private

data/lib/rwm/task_runner.rb

@@ -5,9 +5,20 @@ require "etc"
 
 module Rwm
   class TaskRunner
-    Result = Struct.new(:package_name, :task, :success, :output, :skipped, keyword_init: true)
+    Result = Struct.new(:package_name, :task, :status, :output, keyword_init: true) do
+      def passed? = status == :passed
+      def failed? = status == :failed
+      def skipped? = status == :skipped
+      def dep_skipped? = status == :dep_skipped
+      def errored? = status == :errored
+      def success? = passed? || skipped?
+    end
 
-    NO_TASK_PATTERN = /Don't know how to build task/
+    NO_TASK_PATTERN = /
+      don.t\s+know\s+how\s+to\s+build\s+task
+      |
+      rake\s+--tasks
+    /ix
 
     attr_reader :results
 
@@ -60,28 +71,38 @@ module Rwm
 
             pending.delete(pkg)
             running[pkg.name] = Thread.new do
-              result = run_single(pkg, &command_proc)
-              mutex.synchronize do
-                @results << result
-                running.delete(pkg.name)
-                if result.success
-                  completed << pkg.name
-                else
-                  skip_names = @graph.transitive_dependents(pkg.name)
-                                     .select { |n| package_names.include?(n) }
-                  skip_names.each do |name|
-                    skip_pkg = pending.find { |p| p.name == name }
-                    if skip_pkg
-                      pending.delete(skip_pkg)
-                      skipped << name
-                      @results << Result.new(
-                        package_name: name, task: "skipped",
-                        success: false, output: "Skipped due to failed dependency: #{pkg.name}"
-                      )
+              begin
+                result = run_single(pkg, &command_proc)
+              rescue => e
+                result = Result.new(
+                  package_name: pkg.name, task: "error",
+                  status: :errored, output: "Error: #{e.class}: #{e.message}"
+                )
+              ensure
+                next unless result # thread was killed before completing
+
+                mutex.synchronize do
+                  @results << result
+                  running.delete(pkg.name)
+                  if result.success?
+                    completed << pkg.name
+                  else
+                    skip_names = @graph.transitive_dependents(pkg.name)
+                                       .select { |n| package_names.include?(n) }
+                    skip_names.each do |name|
+                      skip_pkg = pending.find { |p| p.name == name }
+                      if skip_pkg
+                        pending.delete(skip_pkg)
+                        skipped << name
+                        @results << Result.new(
+                          package_name: name, task: "skipped",
+                          status: :dep_skipped, output: "Skipped due to failed dependency: #{pkg.name}"
+                        )
+                      end
                     end
                   end
+                  condition.broadcast
                 end
-                condition.broadcast
               end
             end
           end
@@ -107,11 +128,11 @@ module Rwm
     end
 
     def success?
-      @results.all?(&:success)
+      @results.none? { |r| r.failed? || r.errored? }
     end
 
     def failed_results
-      @results.select { |r| !r.success }
+      @results.select { |r| r.failed? || r.errored? }
     end
 
     private
@@ -135,13 +156,12 @@ module Rwm
 
       # Detect "task not found" and treat as skipped, not failed
       if !status.success? && stderr.match?(NO_TASK_PATTERN)
-        Rwm.debug("#{pkg.name}: task not found, skipping")
+        Rwm.debug("#{pkg.name}: task not found (matched: #{stderr.lines.first&.chomp})")
         return Result.new(
           package_name: pkg.name,
           task: cmd.join(" "),
-          success: true,
-          output: "",
-          skipped: true
+          status: :skipped,
+          output: ""
         )
       end
 
@@ -154,7 +174,7 @@ module Rwm
       Result.new(
         package_name: pkg.name,
         task: cmd.join(" "),
-        success: status.success?,
+        status: status.success? ? :passed : :failed,
         output: output
       )
     end

data/lib/rwm/version.rb

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

metadata

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