ruby_workspace_manager 0.2.0

data/lib/rwm/dependency_graph.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require "tsort"
+require "json"
+require "fileutils"
+
+module Rwm
+  class DependencyGraph
+    include TSort
+
+    attr_reader :packages, :edges
+
+    def initialize
+      @packages = {}   # name => Package
+      @edges = {}      # name => [dep_name, ...]
+      @dependents = {} # name => [dependent_name, ...]
+    end
+
+    def add_package(package)
+      @packages[package.name] = package
+      @edges[package.name] ||= []
+      @dependents[package.name] ||= []
+    end
+
+    def add_edge(from_name, to_name)
+      @edges[from_name] ||= []
+      @edges[from_name] << to_name unless @edges[from_name].include?(to_name)
+      @dependents[to_name] ||= []
+      @dependents[to_name] << from_name unless @dependents[to_name].include?(from_name)
+    end
+
+    # Dependencies of a package (what it depends on)
+    def dependencies(name)
+      @edges[name] || []
+    end
+
+    # Direct dependents of a package (what depends on it)
+    def direct_dependents(name)
+      @dependents[name] || []
+    end
+
+    # Walk the graph to find all transitive dependents
+    def transitive_dependents(name)
+      visited = Set.new
+      queue = [name]
+
+      until queue.empty?
+        current = queue.shift
+        direct_dependents(current).each do |dep|
+          next if visited.include?(dep)
+
+          visited << dep
+          queue << dep
+        end
+      end
+
+      visited.to_a
+    end
+
+    # Topological sort (dependencies before dependents)
+    def topological_order
+      tsort
+    rescue TSort::Cyclic => e
+      raise CycleError, [e.message]
+    end
+
+    # Group packages into execution levels — packages at the same level
+    # have no interdependencies and can run in parallel
+    def execution_levels
+      return [] if @packages.empty?
+
+      remaining = @packages.keys.dup
+      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?
+
+        levels << level.sort
+        remaining -= level
+      end
+
+      levels
+    end
+
+    # Load graph from cached .rwm/graph.json, falling back to build.
+    # Auto-rebuilds when any package Gemfile is newer than the cache.
+    def self.load(workspace)
+      path = workspace.graph_path
+      unless File.exist?(path)
+        return build_and_save(workspace)
+      end
+
+      if stale?(path, workspace.packages)
+        return build_and_save(workspace)
+      end
+
+      data = JSON.parse(File.read(path))
+      graph = new
+
+      workspace.packages.each { |pkg| graph.add_package(pkg) }
+
+      data["edges"]&.each do |name, deps|
+        deps.each { |dep| graph.add_edge(name, dep) }
+      end
+
+      graph
+    end
+
+    def self.build_and_save(workspace)
+      graph = build(workspace)
+      graph.save(workspace.graph_path, workspace.root)
+      graph
+    end
+
+    def self.stale?(graph_path, packages)
+      graph_mtime = File.mtime(graph_path)
+      packages.any? { |pkg| File.mtime(pkg.gemfile_path) > graph_mtime }
+    end
+
+    private_class_method :stale?, :build_and_save
+
+    # Build graph from a workspace by parsing all Gemfiles
+    def self.build(workspace)
+      graph = new
+
+      workspace.packages.each { |pkg| graph.add_package(pkg) }
+
+      workspace.packages.each do |pkg|
+        deps = GemfileParser.parse(pkg.gemfile_path, workspace.packages)
+        deps.each { |dep| graph.add_edge(pkg.name, dep.name) }
+      end
+
+      graph
+    end
+
+    # Serialize to JSON for .rwm/graph.json
+    def to_json_data
+      {
+        "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 || "") }
+        end,
+        "edges" => @edges.transform_values(&:sort)
+      }
+    end
+
+    def save(path, workspace_root)
+      @workspace_root = workspace_root
+      dir = File.dirname(path)
+      FileUtils.mkdir_p(dir)
+      File.write(path, JSON.pretty_generate(to_json_data) + "\n")
+    end
+
+    def self.load_from_file(path)
+      data = JSON.parse(File.read(path))
+      graph = new
+
+      # We can't reconstruct full Package objects from JSON alone,
+      # but we can load the structure for validation
+      data["edges"]&.each do |name, deps|
+        graph.instance_variable_get(:@edges)[name] = deps
+        deps.each do |dep|
+          graph.instance_variable_get(:@dependents)[dep] ||= []
+          graph.instance_variable_get(:@dependents)[dep] << name
+        end
+      end
+
+      graph
+    end
+
+    def to_dot(workspace_root)
+      lines = []
+      lines << "digraph rwm {"
+      lines << "  rankdir=LR;"
+      lines << "  node [shape=box];"
+
+      @packages.each_value do |pkg|
+        lines << "  \"#{pkg.name}\" [label=\"#{pkg.name} (#{pkg.type})\"];"
+      end
+
+      @edges.each do |from, deps|
+        deps.each do |to|
+          lines << "  \"#{from}\" -> \"#{to}\";"
+        end
+      end
+
+      lines << "}"
+      lines.join("\n") + "\n"
+    end
+
+    def to_mermaid(workspace_root)
+      lines = []
+      lines << "graph LR"
+
+      @packages.each_value do |pkg|
+        lines << "  #{pkg.name}[\"#{pkg.name} (#{pkg.type})\"]"
+      end
+
+      @edges.each do |from, deps|
+        deps.each do |to|
+          lines << "  #{from} --> #{to}"
+        end
+      end
+
+      lines.join("\n") + "\n"
+    end
+
+    private
+
+    # TSort interface
+    def tsort_each_node(&block)
+      @packages.each_key(&block)
+    end
+
+    def tsort_each_child(node, &block)
+      (@edges[node] || []).each(&block)
+    end
+  end
+end

data/lib/rwm/errors.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Rwm
+  class Error < StandardError; end
+
+  class WorkspaceNotFoundError < Error
+    def initialize
+      super("Not a git repository. rwm uses the git root as the workspace root. Run `git init` first, then `rwm init`.")
+    end
+  end
+
+  class CycleError < Error
+    attr_reader :cycles
+
+    def initialize(cycles)
+      @cycles = cycles
+      super("Dependency cycle detected: #{cycles.map { |c| c.join(" → ") }.join(", ")}")
+    end
+  end
+
+  class ConventionError < Error
+    attr_reader :violations
+
+    def initialize(violations)
+      @violations = violations
+      super("Convention violations:\n#{violations.map { |v| "  - #{v}" }.join("\n")}")
+    end
+  end
+
+  class PackageNotFoundError < Error
+    def initialize(name)
+      super("Package not found: #{name}")
+    end
+  end
+
+  class PackageExistsError < Error
+    def initialize(name)
+      super("Package already exists: #{name}")
+    end
+  end
+
+  class BootstrapError < Error; end
+end

data/lib/rwm/gemfile.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Bundler DSL extension for rwm workspaces.
+#
+# Usage in a package Gemfile:
+#
+#   require "rwm/gemfile"
+#
+#   source "https://rubygems.org"
+#   gemspec
+#
+#   rwm_lib "auth"
+
+require "bundler"
+
+module Rwm
+  module GemfileDsl
+    def rwm_workspace_root
+      @rwm_workspace_root ||= `git rev-parse --show-toplevel 2>/dev/null`.strip.tap do |root|
+        raise "rwm: not inside a git repository" if root.empty?
+      end
+    end
+
+    def rwm_lib(name, **opts)
+      path = File.join(rwm_workspace_root, "libs", name.to_s)
+      gem(name.to_s, **opts, path: path)
+    end
+
+  end
+end
+
+Bundler::Dsl.prepend(Rwm::GemfileDsl)

data/lib/rwm/gemfile_parser.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "bundler"
+
+module Rwm
+  class GemfileParser
+    # Parse a Gemfile and extract path dependencies that match known packages
+    def self.parse(gemfile_path, known_packages)
+      new(gemfile_path, known_packages).parse
+    end
+
+    def initialize(gemfile_path, known_packages)
+      @gemfile_path = gemfile_path
+      @known_packages = known_packages
+      @package_by_path = index_packages_by_path
+    end
+
+    def parse
+      dsl = Bundler::Dsl.new
+      dsl.eval_gemfile(@gemfile_path)
+      deps = dsl.dependencies
+
+      gemfile_dir = File.expand_path(File.dirname(@gemfile_path))
+
+      deps.each_with_object([]) do |dep, result|
+        source = dep.source
+        next unless source.is_a?(Bundler::Source::Path)
+
+        # Resolve the path relative to the Gemfile's directory
+        dep_path = File.expand_path(source.path.to_s, gemfile_dir)
+
+        # Skip self-references (gemspec directive points to own directory)
+        next if dep_path == gemfile_dir
+
+        matched = @package_by_path[dep_path]
+        result << matched if matched
+      end
+    end
+
+    private
+
+    def index_packages_by_path
+      @known_packages.each_with_object({}) do |pkg, index|
+        index[pkg.path] = pkg
+      end
+    end
+  end
+end

data/lib/rwm/git_hooks.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Rwm
+  class GitHooks
+    PRE_PUSH_HOOK = <<~BASH
+      #!/bin/bash
+      bundle exec rwm check
+    BASH
+
+    POST_COMMIT_HOOK = <<~BASH
+      #!/bin/bash
+      # Only rebuild graph if a Gemfile changed in this commit
+      if git diff-tree --no-commit-id --name-only -r HEAD 2>/dev/null | grep -q 'Gemfile'; then
+        bundle exec rwm graph
+      fi
+    BASH
+
+    def initialize(workspace_root)
+      @root = workspace_root
+    end
+
+    def setup
+      hooks_dir = File.join(@root, ".git", "hooks")
+      return false unless File.directory?(File.join(@root, ".git"))
+
+      FileUtils.mkdir_p(hooks_dir)
+      install_hook(hooks_dir, "pre-push", PRE_PUSH_HOOK)
+      install_hook(hooks_dir, "post-commit", POST_COMMIT_HOOK)
+      true
+    end
+
+    private
+
+    def install_hook(hooks_dir, name, content)
+      path = File.join(hooks_dir, name)
+
+      if File.exist?(path)
+        existing = File.read(path)
+        return if existing.include?("bundle exec rwm")
+        # Append to existing hook
+        File.open(path, "a") do |f|
+          f.puts
+          f.puts "# rwm hooks"
+          f.puts content.lines.drop(1).join # skip shebang
+        end
+      else
+        File.write(path, content)
+      end
+
+      File.chmod(0o755, path)
+    end
+  end
+end

data/lib/rwm/overcommit.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Rwm
+  class Overcommit
+    RWM_HOOKS = {
+      "PrePush" => {
+        "CustomScript" => {
+          "enabled" => true
+        }
+      },
+      "PostCommit" => {
+        "CustomScript" => {
+          "enabled" => true
+        }
+      }
+    }.freeze
+
+    PRE_PUSH_SCRIPT = <<~BASH
+      #!/bin/bash
+      bundle exec rwm check
+    BASH
+
+    POST_COMMIT_SCRIPT = <<~BASH
+      #!/bin/bash
+      # Only rebuild graph if a Gemfile changed in this commit
+      if git diff-tree --no-commit-id --name-only -r HEAD 2>/dev/null | grep -q 'Gemfile'; then
+        bundle exec rwm graph
+      fi
+    BASH
+
+    def initialize(workspace_root)
+      @root = workspace_root
+    end
+
+    # Sets up overcommit: installs hooks, configures .overcommit.yml,
+    # creates hook scripts, and signs the config.
+    # Returns true if overcommit was installed successfully.
+    def setup
+      configure_hooks
+      create_hook_scripts
+      installed = install_hooks
+      sign_config if installed
+      installed
+    end
+
+    private
+
+    def install_hooks
+      system("bundle", "exec", "overcommit", "--install", chdir: @root,
+             out: File::NULL, err: File::NULL)
+    end
+
+    def sign_config
+      system("bundle", "exec", "overcommit", "--sign", chdir: @root,
+             out: File::NULL, err: File::NULL)
+    end
+
+    def configure_hooks
+      config_path = File.join(@root, ".overcommit.yml")
+
+      existing = if File.exist?(config_path)
+                   YAML.safe_load(File.read(config_path)) || {}
+                 else
+                   {}
+                 end
+
+      merged = deep_merge(existing, RWM_HOOKS)
+      File.write(config_path, YAML.dump(merged))
+    end
+
+    def create_hook_scripts
+      create_script("pre_push", "rwm_check", PRE_PUSH_SCRIPT)
+      create_script("post_commit", "rwm_graph", POST_COMMIT_SCRIPT)
+    end
+
+    def create_script(hook_dir, name, content)
+      dir = File.join(@root, ".git-hooks", hook_dir)
+      FileUtils.mkdir_p(dir)
+      path = File.join(dir, name)
+      File.write(path, content)
+      File.chmod(0o755, path)
+    end
+
+    def deep_merge(base, override)
+      result = base.dup
+      override.each do |key, value|
+        if result[key].is_a?(Hash) && value.is_a?(Hash)
+          result[key] = deep_merge(result[key], value)
+        else
+          result[key] = value
+        end
+      end
+      result
+    end
+  end
+end

data/lib/rwm/package.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "open3"
+
+module Rwm
+  class Package
+    attr_reader :name, :path, :type
+
+    def initialize(name:, path:, type:)
+      @name = name
+      @path = File.expand_path(path)
+      @type = type.to_sym
+    end
+
+    def lib?
+      type == :lib
+    end
+
+    def app?
+      type == :app
+    end
+
+    def has_rakefile?
+      File.exist?(File.join(path, "Rakefile"))
+    end
+
+    def has_rake_task?(task)
+      return false unless has_rakefile?
+
+      output, _, status = Open3.capture3("bundle", "exec", "rake", "-P", chdir: path)
+      return false unless status.success?
+
+      output.lines.any? { |line| line.strip == "rake #{task}" }
+    end
+
+    def gemfile_path
+      File.join(path, "Gemfile")
+    end
+
+    def gemspec_path
+      Dir.glob(File.join(path, "*.gemspec")).first
+    end
+
+    def relative_path(workspace_root)
+      Pathname.new(path).relative_path_from(Pathname.new(workspace_root)).to_s
+    end
+
+    def to_s
+      "#{name} (#{type})"
+    end
+
+    def ==(other)
+      other.is_a?(Package) && name == other.name && path == other.path
+    end
+    alias eql? ==
+
+    def hash
+      [name, path].hash
+    end
+  end
+end

data/lib/rwm/rake.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Rake DSL extension for rwm workspaces.
+#
+# Usage in a package Rakefile:
+#
+#   require "rwm/rake"
+#
+#   cacheable_task :spec do
+#     sh "bundle exec rspec"
+#   end
+#
+#   cacheable_task :build, output: "pkg/*.gem" do
+#     sh "gem build *.gemspec"
+#   end
+
+require "rake"
+require "json"
+
+module Rwm
+  module RakeCache
+    @declarations = {}
+
+    class << self
+      attr_reader :declarations
+
+      def register(task_name, output:)
+        @declarations[task_name.to_s] = { "output" => output }
+        ensure_cache_config_task
+      end
+
+      def reset!
+        @declarations = {}
+      end
+
+      def ensure_cache_config_task
+        return if Rake::Task.task_defined?("rwm:cache_config")
+
+        Rake::Task.define_task("rwm:cache_config") do
+          puts JSON.generate(Rwm::RakeCache.declarations)
+        end
+      end
+    end
+  end
+end
+
+# Top-level DSL method available in Rakefiles
+def cacheable_task(name, output: nil, &block)
+  Rwm::RakeCache.register(name, output: output)
+  Rake::Task.define_task(name, &block)
+end