rails-worktree 0.2.0 → 0.3.1

data/lib/worktree/commands/close.rb

@@ -2,20 +2,18 @@ require "fileutils"
 
 module RailsWorktree
   module Commands
+    # Drops the worktree-local databases recorded in .env.*.local, removes the
+    # checkout and deletes its branch.
     class Close
       def initialize(args)
         @worktree_name = args[0]
+        @named = !@worktree_name.nil?
         @main_worktree = get_main_worktree
         @current_dir = Dir.pwd
       end
 
       def run
         detect_worktree_name unless @worktree_name
-
-        @db_prefix = get_db_prefix
-        @dev_database_name = "#{@db_prefix}_#{@worktree_name}_development"
-        @test_database_name = "#{@db_prefix}_#{@worktree_name}_test"
-
         detect_paths
 
         puts "Closing worktree '#{@worktree_name}'..."
@@ -33,12 +31,10 @@ module RailsWorktree
 
         puts ""
         puts "✓ Worktree '#{@worktree_name}' closed successfully!"
-        puts "  Databases dropped: #{@dev_database_name}, #{@test_database_name}"
-        puts "  node_modules removed"
         puts "  Worktree removed from #{@worktree_path}"
-        puts "  Branch #{@worktree_name} deleted"
+        puts "  Branch #{@branch} deleted" if @branch_deleted
 
-        unless @in_main_repo
+        if @worktree_path == @current_dir
           puts ""
           puts "Run: cd #{@main_worktree}"
         end
@@ -53,88 +49,107 @@ module RailsWorktree
 
       def detect_worktree_name
         if @current_dir == @main_worktree
-          puts "Error: You must specify a worktree name when running from the main repository"
-          puts "Usage: worktree --close <worktree-name>"
-          puts "  or: cd to the worktree and run: worktree --close"
-          exit 1
+          raise Error, "Specify a worktree name when closing from the main repository: bin/worktree close NAME"
         else
           @worktree_name = File.basename(@current_dir)
           puts "Detected worktree name: #{@worktree_name}"
         end
       end
 
-      def get_db_prefix
-        # Try to get prefix from database.yml first
-        database_yml = File.join(@main_worktree, "config/database.yml")
-        if File.exist?(database_yml)
-          content = File.read(database_yml)
-          match = content.match(/database:\s*(\w+)_development/)
-          return match[1] if match
+      # Finds the checkout in git's worktree list by directory name or branch, so
+      # worktrees outside .worktrees/ (git worktree add, herdr, Claude Code) close too.
+      # An explicit name wins over the current directory, so closing another
+      # worktree from inside one leaves the current checkout alone.
+      def detect_paths
+        @in_main_repo = @current_dir == @main_worktree
+        entries = worktree_entries.reject { |entry| entry[:path] == @main_worktree }
+        entry = if @named
+          entries.find { |candidate| candidate[:path] == File.join(@main_worktree, ".worktrees", @worktree_name) } ||
+            entries.find { |candidate| File.basename(candidate[:path]) == @worktree_name || candidate[:branch] == @worktree_name }
+        else
+          entries.find { |candidate| candidate[:path] == @current_dir }
         end
+        raise Error, "No worktree named #{@worktree_name}; see git worktree list." if @named && !entry
 
-        # Fall back to using the Rails app name (directory name of main worktree)
-        File.basename(@main_worktree)
+        @worktree_path = entry ? entry[:path] : @current_dir
+        @branch = entry ? entry[:branch] : @worktree_name
       end
 
-      def detect_paths
-        if @current_dir == @main_worktree
-          @in_main_repo = true
-          @worktree_path = File.join(@main_worktree, ".worktrees", @worktree_name)
-          @worktree_dir = @worktree_path
-        else
-          @in_main_repo = false
-          @worktree_path = @current_dir
-          @worktree_dir = "."
+      def worktree_entries
+        `git worktree list --porcelain`.split("\n\n").map do |block|
+          lines = block.lines.map(&:strip)
+          path = lines.find { |line| line.start_with?("worktree ") }&.delete_prefix("worktree ")
+          branch = lines.find { |line| line.start_with?("branch ") }&.delete_prefix("branch refs/heads/")
+          {path: path, branch: branch}
+        end
+      end
+
+      def config
+        @config ||= Config.load(File.exist?(File.join(@worktree_path, Config::FILE)) ? @worktree_path : @main_worktree)
+      end
+
+      # Databases named in the worktree's .env.development.local and .env.test.local.
+      # Without those files the checkout shares the main databases, which stay untouched.
+      def worktree_databases
+        Init::ENV_FILES.filter_map do |environment, file|
+          path = File.join(@worktree_path, file)
+          next unless File.file?(path)
+
+          variable = environment == "test" ? config.test_variable : config.development_variable
+          match = File.read(path).match(/^#{Regexp.escape(variable)}=(.+)$/)
+          [environment, variable, match[1].strip] if match
         end
       end
 
       def drop_databases
-        puts "Dropping databases..."
+        databases = worktree_databases
+        if databases.empty?
+          puts "No worktree-local databases in .env.development.local or .env.test.local; nothing to drop"
+          return
+        end
+        unless File.executable?(File.join(@worktree_path, "bin/rails"))
+          puts "Warning: bin/rails not found in worktree, skipping database drop"
+          return
+        end
 
         Dir.chdir(@worktree_path) do
-          if File.executable?("bin/rails")
-            system({ "DISABLE_DATABASE_ENVIRONMENT_CHECK" => "1" }, "bin/rails", "db:drop") ||
-              puts("Warning: Could not drop databases")
-          else
-            puts "Warning: bin/rails not found in worktree, skipping database drop"
+          databases.each do |environment, variable, database|
+            puts "Dropping #{database}..."
+            env = {"RAILS_ENV" => environment, variable => database, "DISABLE_DATABASE_ENVIRONMENT_CHECK" => "1"}
+            system(env, "bin/rails", "db:drop") || puts("Warning: could not drop #{database}")
           end
         end
       end
 
       def remove_node_modules
-        puts "Removing node_modules..."
+        node_modules_path = File.join(@worktree_path, "node_modules")
+        return unless File.exist?(node_modules_path) || File.symlink?(node_modules_path)
 
-        node_modules_path = File.join(@worktree_dir, "node_modules")
-        if Dir.exist?(node_modules_path)
-          FileUtils.rm_rf(node_modules_path)
-          puts "node_modules removed"
-        else
-          puts "No node_modules to remove"
-        end
+        puts "Removing node_modules..."
+        FileUtils.rm_rf(node_modules_path)
       end
 
       def remove_worktree
         puts "Removing worktree..."
-
-        if system("git worktree remove #{@worktree_path} --force 2>/dev/null")
+        if system(Context::GIT_ENVIRONMENT, "git", "worktree", "remove", "--force", @worktree_path, err: File::NULL)
           puts "Worktree removed successfully via git"
-        else
+        elsif Dir.exist?(@worktree_path)
           puts "Git worktree remove failed, deleting directory manually..."
-          if Dir.exist?(@worktree_path)
-            FileUtils.rm_rf(@worktree_path)
-            puts "Directory deleted: #{@worktree_path}"
-          end
+          FileUtils.rm_rf(@worktree_path)
+          puts "Directory deleted: #{@worktree_path}"
         end
       end
 
       def prune_worktrees
-        system("git worktree prune")
+        system("git", "worktree", "prune")
       end
 
       def delete_branch
-        puts "Deleting branch #{@worktree_name}..."
-        system("git branch -D #{@worktree_name} 2>/dev/null") ||
-          puts("Warning: Could not delete branch #{@worktree_name}")
+        return puts("No branch to delete (detached HEAD)") unless @branch
+
+        puts "Deleting branch #{@branch}..."
+        @branch_deleted = system("git", "branch", "-D", @branch, err: File::NULL)
+        puts("Warning: Could not delete branch #{@branch}") unless @branch_deleted
       end
     end
   end

data/lib/worktree/commands/create.rb

@@ -2,20 +2,19 @@ require "fileutils"
 
 module RailsWorktree
   module Commands
+    # Creates a worktree under .worktrees/ from an explicit base, then provisions it.
     class Create
-      def initialize(args, skip_seeds: false)
+      def initialize(args, level: nil, seed: false, force: false, skip_seeds: nil)
         @worktree_name = args[0]
         @base_branch = args[1]
-        @skip_seeds = skip_seeds
+        @level = level
+        @seed = seed
       end
 
       def run
-        unless @worktree_name
-          puts "Error: Worktree name is required"
-          exit 1
-        end
+        raise Error, "Worktree name is required: bin/worktree create NAME BASE" unless @worktree_name
+        raise Error, "Base branch required: bin/worktree create #{@worktree_name} BASE (for example origin/main)." unless @base_branch
 
-        raise Error, "Base branch required: bin/worktree #{@worktree_name} BASE (for example origin/main)." unless @base_branch
         context = Context.new
         Dir.chdir(context.root) { create }
       end
@@ -37,32 +36,18 @@ module RailsWorktree
         Installer.ignore_worktrees(Dir.pwd)
         FileUtils.mkdir_p(worktree_dir)
 
-        puts "Creating worktree '#{@worktree_name}' from branch '#{@base_branch}' at #{worktree_path}..."
-
+        puts "Creating worktree '#{@worktree_name}' from #{@base_branch} at #{worktree_path}..."
         unless system(Context::GIT_ENVIRONMENT, "git", "worktree", "add", "-b", @worktree_name, worktree_path, base_commit)
-          puts "Failed to create worktree"
-          exit 1
+          raise Error, "Failed to create worktree"
         end
 
-        puts ""
-        puts "✓ Worktree created at #{worktree_path}"
-        puts ""
-        puts "Initializing worktree..."
-
         Dir.chdir(worktree_path) do
-          created = Context.new
-          created.record(@base_branch, base_commit, @worktree_name)
-          created.verify
-          Installer.install(created.root, replace: true)
-          PushHook.install(created.root)
-          Init.new([@worktree_name], skip_seeds: @skip_seeds).run
+          Init.new([@worktree_name], level: @level, seed: @seed, base: @base_branch).run
         end
 
         puts ""
         puts "To switch to the new worktree:"
         puts "  cd #{absolute_path}"
-        puts ""
-        puts "To start the development server: bin/dev"
       end
     end
   end