ruby_workspace_manager 0.2.0

data/lib/rwm/commands/init.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "optparse"
+
+module Rwm
+  module Commands
+    class Init
+      GEMFILE_TEMPLATE = <<~GEMFILE
+        # frozen_string_literal: true
+
+        source "https://rubygems.org"
+
+        gem "ruby_workspace_manager"
+      GEMFILE
+
+      RAKEFILE_TEMPLATE = <<~RAKEFILE
+        # frozen_string_literal: true
+
+        task :bootstrap do
+          puts "Add your workspace-level bootstrap steps here."
+          puts "This task runs during `rwm bootstrap` — use it for binstubs, shared tooling, etc."
+        end
+      RAKEFILE
+
+      def initialize(argv)
+        @argv = argv
+        @vscode = false
+        parse_options
+      end
+
+      def run
+        root = Dir.pwd
+
+        create_directories(root)
+        create_gemfile(root)
+        create_rakefile(root)
+        update_gitignore(root)
+
+        if @vscode
+          generate_vscode_workspace(root)
+        end
+
+        puts "Workspace initialized. Running bootstrap..."
+        puts
+
+        # Call bootstrap as the last step
+        require "rwm/commands/bootstrap"
+        Commands::Bootstrap.new([]).run
+      end
+
+      private
+
+      def parse_options
+        OptionParser.new do |opts|
+          opts.on("--vscode", "Generate VSCode .code-workspace file") do
+            @vscode = true
+          end
+        end.parse!(@argv)
+      end
+
+      def create_directories(root)
+        %w[libs apps].each do |dir|
+          path = File.join(root, dir)
+          unless File.directory?(path)
+            FileUtils.mkdir_p(path)
+            puts "Created #{dir}/"
+          end
+        end
+      end
+
+      def create_gemfile(root)
+        path = File.join(root, "Gemfile")
+        return if File.exist?(path)
+
+        File.write(path, GEMFILE_TEMPLATE)
+        puts "Created Gemfile"
+      end
+
+      def create_rakefile(root)
+        path = File.join(root, "Rakefile")
+        return if File.exist?(path)
+
+        File.write(path, RAKEFILE_TEMPLATE)
+        puts "Created Rakefile"
+      end
+
+      def generate_vscode_workspace(root)
+        VscodeWorkspace.new(root).generate([])
+        puts "Created #{File.basename(root)}.code-workspace"
+      end
+
+      def update_gitignore(root)
+        path = File.join(root, ".gitignore")
+        entry = ".rwm/"
+
+        if File.exist?(path)
+          content = File.read(path)
+          return if content.lines.any? { |line| line.strip == entry }
+
+          File.open(path, "a") do |f|
+            f.puts unless content.end_with?("\n")
+            f.puts entry
+          end
+          puts "Added #{entry} to .gitignore"
+        else
+          File.write(path, "#{entry}\n")
+          puts "Created .gitignore"
+        end
+      end
+    end
+  end
+end

data/lib/rwm/commands/list.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Rwm
+  module Commands
+    class List
+      def initialize(argv)
+        @argv = argv
+      end
+
+      def run
+        workspace = Workspace.find
+        packages = workspace.packages
+
+        if packages.empty?
+          puts "No packages found."
+          return 0
+        end
+
+        graph = DependencyGraph.load(workspace)
+
+        # Calculate column widths
+        name_width = [packages.map { |p| p.name.length }.max, 4].max
+        type_width = 4
+        path_width = [packages.map { |p| p.relative_path(workspace.root).length }.max, 4].max
+
+        # Header
+        puts format("%-#{name_width}s  %-#{type_width}s  %-#{path_width}s  %s",
+                     "Name", "Type", "Path", "Dependencies")
+        puts format("%-#{name_width}s  %-#{type_width}s  %-#{path_width}s  %s",
+                     "-" * name_width, "-" * type_width, "-" * path_width, "-" * 12)
+
+        # Rows
+        packages.each do |pkg|
+          deps = graph.dependencies(pkg.name)
+          dep_str = deps.empty? ? "(none)" : deps.sort.join(", ")
+
+          puts format("%-#{name_width}s  %-#{type_width}s  %-#{path_width}s  %s",
+                       pkg.name, pkg.type, pkg.relative_path(workspace.root), dep_str)
+        end
+
+        0
+      end
+    end
+  end
+end

data/lib/rwm/commands/new.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Rwm
+  module Commands
+    class New
+      def initialize(argv)
+        @argv = argv
+      end
+
+      def run
+        type = @argv.shift
+        name = @argv.shift
+
+        unless %w[app lib].include?(type)
+          $stderr.puts "Usage: rwm new <app|lib> <name>"
+          return 1
+        end
+
+        unless name && name.match?(/\A[a-z][a-z0-9_]*\z/)
+          $stderr.puts "Package name must start with a lowercase letter and contain only lowercase letters, digits, and underscores."
+          return 1
+        end
+
+        workspace = Workspace.find
+        dir = type == "lib" ? "libs" : "apps"
+        pkg_path = File.join(workspace.root, dir, name)
+
+        raise PackageExistsError, name if File.directory?(pkg_path)
+
+        scaffold(pkg_path, name, type)
+        update_vscode_workspace(workspace)
+
+        puts "Created #{type} '#{name}' at #{dir}/#{name}/"
+        puts
+        puts "Next steps:"
+        puts "  cd #{dir}/#{name}"
+        puts "  bundle install"
+        puts "  rwm graph    # rebuild the dependency graph"
+        0
+      end
+
+      private
+
+      def update_vscode_workspace(workspace)
+        vscode = VscodeWorkspace.new(workspace.root)
+        return unless File.exist?(vscode.file_path)
+
+        # Use a fresh Workspace to pick up the newly scaffolded package
+        fresh_workspace = Workspace.find(workspace.root)
+        VscodeWorkspace.new(fresh_workspace.root).generate(fresh_workspace.packages)
+      end
+
+      def scaffold(pkg_path, name, type)
+        FileUtils.mkdir_p(File.join(pkg_path, "lib", 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_lib_entry(pkg_path, name)
+        write_spec_helper(pkg_path)
+      end
+
+      def write_gemfile(pkg_path, name)
+        File.write(File.join(pkg_path, "Gemfile"), <<~GEMFILE)
+          # frozen_string_literal: true
+
+          source "https://rubygems.org"
+
+          gemspec
+
+          group :development, :test do
+            gem "rake"
+            gem "rspec"
+            gem "ruby_workspace_manager"
+          end
+
+          require "rwm/gemfile"
+          # rwm_lib "some_dependency"
+        GEMFILE
+      end
+
+      def write_gemspec(pkg_path, name, type)
+        lines = [
+          '# frozen_string_literal: true',
+          '',
+          'Gem::Specification.new do |spec|',
+          "  spec.name = \"#{name}\"",
+          '  spec.version = "0.1.0"',
+          '  spec.authors = ["TODO: Your name"]',
+          "  spec.summary = \"TODO: Summary of #{name}\"",
+          '',
+        ]
+        lines << '  spec.files = Dir.glob("lib/**/*")' if type == "lib"
+        lines.concat([
+          '  spec.require_paths = ["lib"]',
+          '  spec.required_ruby_version = ">= 3.4.0"',
+          'end',
+          '',
+        ])
+        File.write(File.join(pkg_path, "#{name}.gemspec"), lines.join("\n"))
+      end
+
+      def write_rakefile(pkg_path, name)
+        File.write(File.join(pkg_path, "Rakefile"), <<~RAKEFILE)
+          # frozen_string_literal: true
+
+          require "rwm/rake"
+
+          cacheable_task :spec do
+            sh "bundle exec rspec"
+          end
+
+          task :bootstrap do
+            puts "Add bootstrap steps for #{name} here."
+          end
+
+          task default: :spec
+        RAKEFILE
+      end
+
+      def write_lib_entry(pkg_path, name)
+        File.write(File.join(pkg_path, "lib", "#{name}.rb"), <<~RUBY)
+          # frozen_string_literal: true
+
+          module #{camelize(name)}
+          end
+        RUBY
+      end
+
+      def write_spec_helper(pkg_path)
+        File.write(File.join(pkg_path, "spec", "spec_helper.rb"), <<~RUBY)
+          # frozen_string_literal: true
+
+          RSpec.configure do |config|
+            config.expect_with :rspec do |expectations|
+              expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+            end
+          end
+        RUBY
+      end
+
+      def camelize(name)
+        name.split("_").map(&:capitalize).join
+      end
+    end
+  end
+end

data/lib/rwm/commands/run.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Rwm
+  module Commands
+    class Run
+      def initialize(argv)
+        @argv = argv
+        @affected_only = false
+        @committed_only = false
+        @no_cache = false
+        @buffered = false
+        @concurrency = nil
+        parse_options
+      end
+
+      def run
+        task = @argv.shift
+
+        unless task
+          $stderr.puts "Usage: rwm run <task> [<package>] [--affected] [--no-cache] [--buffered] [--concurrency N]"
+          return 1
+        end
+
+        package_name = @argv.shift
+
+        workspace = Workspace.find
+        graph = DependencyGraph.load(workspace)
+
+        packages = if package_name
+                     pkg = workspace.find_package(package_name)
+                     unless pkg
+                       $stderr.puts "Unknown package: #{package_name}"
+                       return 1
+                     end
+                     [pkg]
+                   elsif @affected_only
+                     detector = AffectedDetector.new(workspace, graph, committed_only: @committed_only)
+                     affected = detector.affected_packages
+                     if affected.empty?
+                       puts "No affected packages. Nothing to run."
+                       return 0
+                     end
+                     puts "Running on #{affected.size} affected package(s)..."
+                     affected
+                   else
+                     workspace.packages
+                   end
+
+        if packages.empty?
+          puts "No packages found."
+          return 0
+        end
+
+        # Filter to packages that have the requested rake task
+        runnable = packages.select { |pkg| pkg.has_rake_task?(task) }
+        if runnable.empty?
+          puts "No packages with a `#{task}` rake task found."
+          return 0
+        end
+
+        # Auto-detect cacheable tasks unless --no-cache
+        cache = TaskCache.new(workspace, graph) unless @no_cache
+        if cache
+          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" }
+          runnable = uncached + not_cacheable
+        end
+
+        if runnable.empty?
+          puts "All packages cached. Nothing to run."
+          return 0
+        end
+
+        puts "Running `rake #{task}` across #{runnable.size} package(s)..."
+        puts
+
+        runner_opts = { packages: runnable, buffered: @buffered }
+        runner_opts[:concurrency] = @concurrency if @concurrency
+        runner = TaskRunner.new(graph, **runner_opts)
+        runner.run_task(task)
+
+        # Store cache for successful cacheable packages
+        if cache
+          runner.results.each do |result|
+            next unless result.success
+
+            pkg = workspace.find_package(result.package_name)
+            cache.store(pkg, task) if cache.cacheable?(pkg, task)
+          end
+        end
+
+        puts
+        if runner.success?
+          puts "All packages passed."
+          0
+        else
+          failed = runner.failed_results
+          $stderr.puts "#{failed.size} package(s) failed:"
+          failed.each { |r| $stderr.puts "  - #{r.package_name}" }
+          1
+        end
+      end
+
+      private
+
+      def parse_options
+        parser = OptionParser.new do |opts|
+          opts.on("--affected", "Only run on affected packages") do
+            @affected_only = true
+          end
+          opts.on("--committed", "Only consider committed changes (with --affected)") do
+            @committed_only = true
+          end
+          opts.on("--no-cache", "Bypass task caching even for cacheable tasks") do
+            @no_cache = true
+          end
+          opts.on("--buffered", "Buffer output per-package and print on completion") do
+            @buffered = true
+          end
+          opts.on("--concurrency N", Integer, "Max parallel workers (default: processor count)") do |n|
+            @concurrency = n
+          end
+        end
+
+        parser.order!(@argv)
+      end
+    end
+  end
+end

data/lib/rwm/convention_checker.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Rwm
+  class ConventionChecker
+    def initialize(graph)
+      @graph = graph
+    end
+
+    def check!
+      violations = []
+      violations.concat(check_no_lib_depends_on_app)
+      violations.concat(check_no_app_depends_on_app)
+      violations.concat(check_no_cycles)
+
+      raise ConventionError, violations unless violations.empty?
+
+      true
+    end
+
+    def check
+      check!
+      []
+    rescue ConventionError => e
+      e.violations
+    end
+
+    private
+
+    def check_no_lib_depends_on_app
+      violations = []
+
+      @graph.packages.each do |name, pkg|
+        next unless pkg.lib?
+
+        @graph.dependencies(name).each do |dep_name|
+          dep = @graph.packages[dep_name]
+          next unless dep&.app?
+
+          violations << "lib '#{name}' depends on app '#{dep_name}' — libs cannot depend on apps"
+        end
+      end
+
+      violations
+    end
+
+    def check_no_app_depends_on_app
+      violations = []
+
+      @graph.packages.each do |name, pkg|
+        next unless pkg.app?
+
+        @graph.dependencies(name).each do |dep_name|
+          dep = @graph.packages[dep_name]
+          next unless dep&.app?
+
+          violations << "app '#{name}' depends on app '#{dep_name}' — apps cannot depend on other apps"
+        end
+      end
+
+      violations
+    end
+
+    def check_no_cycles
+      @graph.topological_order
+      []
+    rescue CycleError => e
+      e.cycles.map { |c| "Dependency cycle: #{c}" }
+    end
+  end
+end