ruby_workspace_manager 0.2.0

data/lib/rwm/task_cache.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "json"
+require "shellwords"
+
+module Rwm
+  class TaskCache
+    def initialize(workspace, graph)
+      @workspace = workspace
+      @graph = graph
+      @cache_dir = File.join(workspace.root, ".rwm", "cache")
+      @content_hashes = {}
+      @cache_declarations = {}
+    end
+
+    # Returns true if the task is declared cacheable in the package's Rakefile
+    def cacheable?(package, task)
+      declarations = cache_declarations(package)
+      declarations.key?(task)
+    end
+
+    # Returns true if the (package, task) pair is cached and inputs haven't changed.
+    # Also verifies declared outputs exist (if any).
+    def cached?(package, task)
+      stored = read_stored_hash(package, task)
+      return false unless stored
+      return false unless stored == content_hash(package)
+
+      # If outputs are declared, they must exist
+      decl = cache_declarations(package)[task]
+      if decl && decl["output"]
+        return false unless outputs_exist?(package, decl["output"])
+      end
+
+      true
+    end
+
+    # Store the current content hash after a successful task run
+    def store(package, task)
+      FileUtils.mkdir_p(@cache_dir)
+      path = cache_file(package, task)
+      File.write(path, content_hash(package))
+    end
+
+    # Check if declared output files/globs exist in the package directory
+    def outputs_exist?(package, output_pattern)
+      matches = Dir.glob(File.join(package.path, output_pattern))
+      !matches.empty?
+    end
+
+    # Compute a content hash for a package: SHA256 of all source files + dependency hashes
+    def content_hash(package)
+      return @content_hashes[package.name] if @content_hashes.key?(package.name)
+
+      digest = Digest::SHA256.new
+
+      # 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
+
+      # Include dependency content hashes (transitive invalidation)
+      @graph.dependencies(package.name).sort.each do |dep_name|
+        dep_pkg = @workspace.find_package(dep_name)
+        digest.update(content_hash(dep_pkg))
+      rescue PackageNotFoundError
+        next
+      end
+
+      @content_hashes[package.name] = digest.hexdigest
+    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)
+
+      output = `cd #{Shellwords.escape(package.path)} && bundle exec rake rwm:cache_config 2>/dev/null`
+      @cache_declarations[package.name] = if $?.success? && !output.strip.empty?
+                                             JSON.parse(output.strip)
+                                           else
+                                             {}
+                                           end
+    rescue JSON::ParserError
+      @cache_declarations[package.name] = {}
+    end
+
+    private
+
+    def source_files(package)
+      Dir.glob(File.join(package.path, "**", "*"))
+         .select { |f| File.file?(f) }
+         .reject do |f|
+           rel = f.delete_prefix("#{package.path}/")
+           rel.start_with?("tmp/") || rel.start_with?("vendor/") || rel.start_with?(".bundle/")
+         end
+         .sort
+    end
+
+    def cache_file(package, task)
+      File.join(@cache_dir, "#{package.name}-#{task}")
+    end
+
+    def read_stored_hash(package, task)
+      path = cache_file(package, task)
+      return nil unless File.exist?(path)
+
+      File.read(path).strip
+    end
+  end
+end

data/lib/rwm/task_runner.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "open3"
+require "etc"
+
+module Rwm
+  class TaskRunner
+    Result = Struct.new(:package_name, :task, :success, :output, keyword_init: true)
+
+    attr_reader :results
+
+    def initialize(graph, packages: nil, buffered: false, concurrency: Etc.nprocessors)
+      @graph = graph
+      @packages = packages || graph.packages.values
+      @buffered = buffered
+      @concurrency = concurrency
+      @results = []
+      @mutex = Mutex.new
+    end
+
+    # Run a shell command in each package using DAG scheduling.
+    # Starts each package as soon as its dependencies complete.
+    # The command_proc receives a Package and returns [command, args] array.
+    def run_command(&command_proc)
+      package_names = @packages.map(&:name).to_set
+
+      pending = @packages.dup
+      completed = Set.new
+      skipped = Set.new
+      running = {}
+
+      mutex = Mutex.new
+      condition = ConditionVariable.new
+
+      until pending.empty? && running.empty?
+        mutex.synchronize do
+          ready = pending.select { |pkg| ready?(pkg, package_names, completed) }
+
+          ready.each do |pkg|
+            break if running.size >= @concurrency
+
+            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}"
+                      )
+                    end
+                  end
+                end
+                condition.broadcast
+              end
+            end
+          end
+
+          if running.any? && ready.empty?
+            condition.wait(mutex)
+          end
+        end
+      end
+
+      @results
+    end
+
+    # Run a rake task in each package
+    def run_task(task)
+      run_command do |pkg|
+        ["bundle", "exec", "rake", task]
+      end
+    end
+
+    def success?
+      @results.all?(&:success)
+    end
+
+    def failed_results
+      @results.select { |r| !r.success }
+    end
+
+    private
+
+    def ready?(pkg, run_set, completed)
+      @graph.dependencies(pkg.name).each do |dep|
+        next unless run_set.include?(dep)
+
+        return false unless completed.include?(dep)
+      end
+      true
+    end
+
+    def run_single(pkg, &command_proc)
+      cmd = command_proc.call(pkg)
+      prefix = "[#{pkg.name}]"
+
+      stdout, stderr, status = Open3.capture3(*cmd, chdir: pkg.path)
+      output = format_output(prefix, stdout, stderr)
+
+      if @buffered
+        print_buffered_output(pkg.name, output, status.success?)
+      else
+        print_output(output)
+      end
+
+      Result.new(
+        package_name: pkg.name,
+        task: cmd.join(" "),
+        success: status.success?,
+        output: output
+      )
+    end
+
+    def format_output(prefix, stdout, stderr)
+      lines = []
+      stdout.each_line { |line| lines << "#{prefix} #{line}" }
+      stderr.each_line { |line| lines << "#{prefix} #{line}" }
+      lines.join
+    end
+
+    def print_output(output)
+      @mutex.synchronize do
+        $stdout.print(output) unless output.empty?
+      end
+    end
+
+    def print_buffered_output(name, output, success)
+      @mutex.synchronize do
+        stream = success ? $stdout : $stderr
+        stream.puts "==> [#{name}]"
+        stream.print(output) unless output.empty?
+        stream.puts
+      end
+    end
+  end
+end

data/lib/rwm/version.rb

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

data/lib/rwm/vscode_workspace.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Rwm
+  class VscodeWorkspace
+    PRESERVE_KEYS = %w[settings extensions launch tasks].freeze
+
+    attr_reader :root
+
+    def initialize(root)
+      @root = root
+    end
+
+    def file_path
+      File.join(root, "#{File.basename(root)}.code-workspace")
+    end
+
+    def generate(packages)
+      existing = load_existing
+      folders = build_folders(packages)
+
+      data = { "folders" => folders }
+
+      PRESERVE_KEYS.each do |key|
+        data[key] = existing[key] if existing.key?(key)
+      end
+
+      data["settings"] ||= {}
+
+      File.write(file_path, JSON.pretty_generate(data) + "\n")
+    end
+
+    private
+
+    def build_folders(packages)
+      folders = [{ "path" => "." }]
+
+      libs = packages.select(&:lib?).sort_by(&:name)
+      apps = packages.select(&:app?).sort_by(&:name)
+
+      (libs + apps).each do |pkg|
+        folders << { "path" => pkg.relative_path(root) }
+      end
+
+      folders
+    end
+
+    def load_existing
+      return {} unless File.exist?(file_path)
+
+      JSON.parse(File.read(file_path))
+    rescue JSON::ParserError
+      {}
+    end
+  end
+end

data/lib/rwm/workspace.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Rwm
+  class Workspace
+    RWM_DIR = ".rwm"
+    PACKAGE_DIRS = %w[libs apps].freeze
+    GRAPH_FILE = "graph.json"
+
+    attr_reader :root
+
+    def initialize(root)
+      @root = root
+    end
+
+    # Find the workspace root via git
+    def self.find(start_dir = Dir.pwd)
+      dir = File.expand_path(start_dir)
+      git_root = `git -C #{dir} rev-parse --show-toplevel 2>/dev/null`.chomp
+
+      raise WorkspaceNotFoundError if git_root.empty?
+
+      new(git_root)
+    end
+
+    def rwm_dir
+      File.join(root, RWM_DIR)
+    end
+
+    def graph_path
+      File.join(rwm_dir, GRAPH_FILE)
+    end
+
+    def libs_dir
+      File.join(root, "libs")
+    end
+
+    def apps_dir
+      File.join(root, "apps")
+    end
+
+    # Discover all packages by scanning libs/ and apps/ for directories with a Gemfile
+    def packages
+      @packages ||= discover_packages
+    end
+
+    def find_package(name)
+      packages.find { |p| p.name == name } || raise(PackageNotFoundError, name)
+    end
+
+    private
+
+    def discover_packages
+      pkgs = []
+
+      PACKAGE_DIRS.each do |dir_name|
+        base = File.join(root, dir_name)
+        next unless File.directory?(base)
+
+        type = dir_name == "libs" ? :lib : :app
+
+        Dir.children(base).sort.each do |name|
+          pkg_path = File.join(base, name)
+          next unless File.directory?(pkg_path)
+          next unless File.exist?(File.join(pkg_path, "Gemfile"))
+
+          pkgs << Package.new(name: name, path: pkg_path, type: type)
+        end
+      end
+
+      pkgs
+    end
+  end
+end

data/lib/rwm.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "rwm/version"
+require_relative "rwm/errors"
+
+module Rwm
+  autoload :Workspace,         "rwm/workspace"
+  autoload :Package,           "rwm/package"
+  autoload :GemfileParser,     "rwm/gemfile_parser"
+  autoload :DependencyGraph,   "rwm/dependency_graph"
+  autoload :ConventionChecker, "rwm/convention_checker"
+  autoload :TaskRunner,        "rwm/task_runner"
+  autoload :AffectedDetector,  "rwm/affected_detector"
+  autoload :TaskCache,         "rwm/task_cache"
+  autoload :GitHooks,          "rwm/git_hooks"
+  autoload :Overcommit,        "rwm/overcommit"
+  autoload :VscodeWorkspace,   "rwm/vscode_workspace"
+  autoload :CLI,               "rwm/cli"
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: ruby_workspace_manager
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Siddharth Bhatt
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Convention-over-configuration monorepo tool for Ruby. Manages dependency
+  graphs, runs tasks in parallel, detects affected packages, and enforces structural
+  conventions.
+executables:
+- rwm
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- bin/rwm
+- lib/rwm.rb
+- lib/rwm/affected_detector.rb
+- lib/rwm/cli.rb
+- lib/rwm/commands/affected.rb
+- lib/rwm/commands/bootstrap.rb
+- lib/rwm/commands/check.rb
+- lib/rwm/commands/graph.rb
+- lib/rwm/commands/info.rb
+- lib/rwm/commands/init.rb
+- lib/rwm/commands/list.rb
+- lib/rwm/commands/new.rb
+- lib/rwm/commands/run.rb
+- lib/rwm/convention_checker.rb
+- lib/rwm/dependency_graph.rb
+- lib/rwm/errors.rb
+- lib/rwm/gemfile.rb
+- lib/rwm/gemfile_parser.rb
+- lib/rwm/git_hooks.rb
+- lib/rwm/overcommit.rb
+- lib/rwm/package.rb
+- lib/rwm/rake.rb
+- lib/rwm/task_cache.rb
+- lib/rwm/task_runner.rb
+- lib/rwm/version.rb
+- lib/rwm/vscode_workspace.rb
+- lib/rwm/workspace.rb
+homepage: https://github.com/sidbhatt11/ruby-workspace-manager
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/sidbhatt11/ruby-workspace-manager
+  source_code_uri: https://github.com/sidbhatt11/ruby-workspace-manager
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Ruby Workspace Manager — an Nx-like monorepo tool for Ruby
+test_files: []