rails-worktrees 0.1.0

data/lib/rails/worktrees/database_config_updater.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Rails
+  module Worktrees
+    # Safely patches common database.yml layouts for worktree suffixes.
+    class DatabaseConfigUpdater
+      Result = Struct.new(:content, :changed, :messages) do
+        def changed?
+          changed
+        end
+      end
+
+      SUFFIX_TEMPLATE = "<%= ENV.fetch('WORKTREE_DATABASE_SUFFIX', '') %>"
+      SUPPORTED_ENVIRONMENTS = %w[development test].freeze
+      DATABASE_LINE_PATTERN = /\A(\s*database:\s*)(.+?)(\s*(?:#.*)?\n?)\z/
+      SECTION_PATTERN = /\A([A-Za-z0-9_]+):(?:\s|$)/
+
+      def initialize(content:)
+        @content = content
+      end
+
+      def call
+        state = { found: Hash.new(0), patched: 0, unsupported: [], environment: nil }
+        lines = @content.lines.map.with_index { |line, index| patch_line(line, index, state) }
+
+        Result.new(
+          lines.join,
+          state[:patched].positive?,
+          build_messages(state[:found], state[:patched], state[:unsupported])
+        )
+      end
+
+      private
+
+      def patch_line(line, index, state)
+        state[:environment] = next_environment_for(line, state[:environment])
+        return line unless state[:environment]
+
+        match = line.match(DATABASE_LINE_PATTERN)
+        return line unless match
+
+        state[:found][state[:environment]] += 1
+        apply_patch(match, index, state)
+      end
+
+      def apply_patch(match, index, state)
+        patched_value = patch_database_value(match[2].strip, state[:environment])
+
+        if patched_value
+          state[:patched] += 1 unless patched_value == match[2].strip
+          "#{match[1]}#{patched_value}#{match[3]}"
+        else
+          state[:unsupported] << { environment: state[:environment], line: index + 1, value: match[2].strip }
+          match.string
+        end
+      end
+
+      def next_environment_for(line, current_environment)
+        section_name = top_level_section_name(line)
+        return current_environment unless section_name
+        return section_name if SUPPORTED_ENVIRONMENTS.include?(section_name)
+
+        nil
+      end
+
+      def top_level_section_name(line)
+        return unless line.lstrip == line
+
+        match = line.match(SECTION_PATTERN)
+        match && match[1]
+      end
+
+      def patch_database_value(value, environment)
+        return value if value.include?('WORKTREE_DATABASE_SUFFIX')
+        return if value.include?('<%')
+
+        quote = value[/\A['"]/]
+        raw_value = quote ? value.delete_prefix(quote).delete_suffix(quote) : value
+        patched = patch_segmented_database_name(raw_value, environment) ||
+                  patch_database_file_path(raw_value, environment)
+        return unless patched
+
+        quote ? "#{quote}#{patched}#{quote}" : patched
+      end
+
+      def patch_segmented_database_name(raw_value, environment)
+        return unless raw_value.match?(/\A[\w-]+\z/)
+
+        segments = raw_value.split('_')
+        environment_index = segments.index(environment)
+        return unless environment_index
+
+        segments[environment_index] = "#{segments[environment_index]}#{SUFFIX_TEMPLATE}"
+        segments.join('_')
+      end
+
+      def patch_database_file_path(raw_value, environment)
+        match = raw_value.match(
+          /\A(?<prefix>.*?)(?<environment>development|test)(?<tail>(?:[_-][\w-]+)*)(?<extension>\.[A-Za-z0-9.]+)\z/
+        )
+        return unless match
+        return unless match[:environment] == environment
+
+        [match[:prefix], match[:environment], SUFFIX_TEMPLATE, match[:tail], match[:extension]].join
+      end
+
+      def build_messages(found_entries, patched_entries, unsupported_entries)
+        messages = [status_message(found_entries, patched_entries, unsupported_entries)].compact
+        return messages if unsupported_entries.empty?
+
+        line_numbers = unsupported_entries.map { |entry| entry[:line] }.join(', ')
+        messages << "Could not safely rewrite config/database.yml on line(s) #{line_numbers}. " \
+                    "Add #{SUFFIX_TEMPLATE} to the development/test database name(s) manually."
+      end
+
+      def status_message(found_entries, patched_entries, unsupported_entries)
+        total = found_entries.values.sum
+        if patched_entries.positive?
+          noun = patched_entries == 1 ? 'entry' : 'entries'
+          "Updated #{patched_entries} development/test database #{noun} to include WORKTREE_DATABASE_SUFFIX."
+        elsif total.positive? && unsupported_entries.empty?
+          'Development/test database names already include WORKTREE_DATABASE_SUFFIX.'
+        elsif total.zero?
+          'No development/test database entries matched a supported auto-update layout.'
+        end
+      end
+    end
+  end
+end

data/lib/rails/worktrees/env_bootstrapper.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'zlib'
+
+module Rails
+  module Worktrees
+    # Creates or updates a worktree-local .env with deterministic defaults.
+    # rubocop:disable Metrics/ClassLength
+    class EnvBootstrapper
+      Result = Struct.new(:changed, :env_path, :messages) do
+        def changed? = changed
+
+        attr_accessor :values
+      end
+
+      ENV_FILE_NAME = '.env'
+
+      def initialize(target_dir:, worktree_name:, configuration:)
+        @target_dir = target_dir
+        @worktree_name = worktree_name
+        @configuration = configuration
+      end
+
+      def call(dry_run: false)
+        return disabled_result unless @configuration.bootstrap_env
+
+        lines = existing_env_lines
+        write_missing_updates(lines, resolved_values(lines), dry_run: dry_run)
+      end
+
+      def preview = result(false, [], resolved_values(existing_env_lines))
+
+      private
+
+      def disabled_result = result(false, [], {})
+
+      def unchanged_result(values, dry_run: false)
+        message = if dry_run
+                    "Would not change #{display_path(env_path)}; it already defines " \
+                      'DEV_PORT and WORKTREE_DATABASE_SUFFIX'
+                  else
+                    "#{display_path(env_path)} already defines DEV_PORT and WORKTREE_DATABASE_SUFFIX"
+                  end
+        result(false, [message], values)
+      end
+
+      def existing_env_lines = File.exist?(env_path) ? File.readlines(env_path, chomp: true) : []
+
+      def resolved_values(lines)
+        {
+          'DEV_PORT' => (env_value(lines, 'DEV_PORT') || allocate_dev_port).to_s,
+          'WORKTREE_DATABASE_SUFFIX' => env_value(lines, 'WORKTREE_DATABASE_SUFFIX') ||
+            format_worktree_database_suffix(@worktree_name)
+        }
+      end
+
+      def write_missing_updates(existing_lines, values, dry_run: false)
+        updates = missing_updates(existing_lines, values)
+        return unchanged_result(values, dry_run: dry_run) if updates.empty?
+        return dry_run_bootstrap_result(values, updates) if dry_run
+
+        File.write(env_path, with_missing_entries(existing_lines, updates))
+        result(true, ["Bootstrapped #{display_path(env_path)} (#{formatted_updates(updates)})"], values)
+      end
+
+      def missing_updates(lines, values)
+        values.each_with_object({}) do |(key, value), updates|
+          updates[key] = value unless env_value(lines, key)
+        end
+      end
+
+      def result(changed, messages, values)
+        Result.new(changed, env_path, messages).tap do |bootstrap_result|
+          bootstrap_result.values = values
+        end
+      end
+
+      def env_path = @env_path ||= File.join(@target_dir, ENV_FILE_NAME)
+
+      def with_missing_entries(lines, updates)
+        output = lines.dup
+        output << '' if output.any? && !output.last.empty?
+        updates.each { |key, value| output << "#{key}=#{value}" }
+        "#{output.join("\n")}\n"
+      end
+
+      def env_value(lines, key)
+        line = lines.reverse.find { |entry| entry.start_with?("#{key}=") }
+        value = line&.split('=', 2)&.last
+        value unless value&.empty?
+      end
+
+      def allocate_dev_port
+        ports = configured_port_range.to_a
+        raise ArgumentError, 'dev_port_range must contain at least one port' if ports.empty?
+
+        claimed_ports = claimed_peer_ports
+        candidate_ports(ports).find { |port| !claimed_ports.include?(port) } ||
+          raise(ArgumentError, "No available DEV_PORT values remain in #{configured_port_range}")
+      end
+
+      def dry_run_bootstrap_result(values, updates)
+        result(false, ["Would bootstrap #{display_path(env_path)} (#{formatted_updates(updates)})"], values)
+      end
+
+      def candidate_ports(ports)
+        start_index = Zlib.crc32(@worktree_name) % ports.length
+        ports.rotate(start_index)
+      end
+
+      def claimed_peer_ports
+        Dir.glob(File.join(peers_root, '*')).filter_map do |path|
+          next unless File.directory?(path)
+          next if File.expand_path(path) == File.expand_path(@target_dir)
+
+          port = env_value(peer_env_lines(path), 'DEV_PORT')
+          next unless port&.match?(/\A\d+\z/)
+
+          port.to_i
+        end.to_set
+      end
+
+      def peer_env_lines(path)
+        env_file = File.join(path, ENV_FILE_NAME)
+        File.exist?(env_file) ? File.readlines(env_file, chomp: true) : []
+      end
+
+      def peers_root = File.dirname(@target_dir)
+
+      def configured_port_range = @configuration.dev_port_range
+
+      def format_worktree_database_suffix(value)
+        suffix = value.downcase.gsub(/[^a-z0-9]+/, '_').gsub(/\A_+|_+\z/, '').squeeze('_')
+        suffix = suffix[0, @configuration.worktree_database_suffix_max_length]
+        suffix = suffix.to_s.sub(/_+\z/, '')
+        suffix = 'worktree' if suffix.empty?
+        "_#{suffix}"
+      end
+
+      def formatted_updates(updates) = updates.map { |key, value| "#{key}=#{value}" }.join(', ')
+
+      def display_path(path)
+        target_path = Pathname.new(path)
+        root_path = Pathname.new(@target_dir)
+        target_path.relative_path_from(root_path).to_s
+      rescue ArgumentError
+        path
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/rails/worktrees/names/cities.txt

@@ -0,0 +1,96 @@
+# One worktree name per line. Keep names shell-safe: lowercase, hyphenated, no spaces.
+amsterdam
+athens
+auckland
+bangkok
+barcelona
+beijing
+beirut
+belgrade
+berlin
+bogota
+boston
+bratislava
+brisbane
+brussels
+bucharest
+budapest
+busan
+cairo
+calgary
+cape-town
+casablanca
+chicago
+copenhagen
+dakar
+delhi
+dubai
+dublin
+edinburgh
+florence
+geneva
+helsinki
+hong-kong
+honolulu
+istanbul
+jakarta
+johannesburg
+kyoto
+lagos
+lima
+lisbon
+ljubljana
+london
+luxor
+madrid
+manila
+marrakesh
+melbourne
+mexico-city
+miami
+milan
+montreal
+mumbai
+munich
+nairobi
+naples
+osaka
+oslo
+ottawa
+palermo
+paris
+perth
+porto
+prague
+quebec-city
+reykjavik
+riga
+rio-de-janeiro
+rome
+rotterdam
+salzburg
+santiago
+sao-paulo
+seattle
+seoul
+shanghai
+singapore
+sofia
+stockholm
+sydney
+taipei
+tallinn
+tbilisi
+tokyo
+toronto
+turin
+uppsala
+utrecht
+valencia
+vancouver
+venice
+vienna
+vilnius
+warsaw
+wellington
+zurich

data/lib/rails/worktrees/railtie.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Rails
+  module Worktrees
+    class Railtie < ::Rails::Railtie
+    end
+  end
+end

data/lib/rails/worktrees/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rails
+  module Worktrees
+    VERSION = '0.1.0'
+  end
+end

data/lib/rails/worktrees.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'worktrees/version'
+require_relative 'worktrees/configuration'
+require_relative 'worktrees/env_bootstrapper'
+require_relative 'worktrees/command'
+require_relative 'worktrees/cli'
+require_relative 'worktrees/database_config_updater'
+
+module Rails
+  # Rails-specific git worktree helpers and installer support.
+  module Worktrees
+    class Error < StandardError; end
+
+    class << self
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield(configuration)
+        configuration
+      end
+
+      def reset_configuration!
+        @configuration = Configuration.new
+      end
+    end
+  end
+end
+
+require_relative 'worktrees/railtie' if defined?(Rails::Railtie)

data/mise.toml

@@ -0,0 +1,5 @@
+[tools]
+ruby = "3.4.8"
+
+[env]
+_.path = ["{{cwd}}/bin"]

data/release-please-config.json

@@ -0,0 +1,12 @@
+{
+  "include-component-in-tag": false,
+  "packages": {
+    ".": {
+      "initial-version": "0.1.0",
+      "release-type": "ruby",
+      "package-name": "rails-worktrees",
+      "version-file": "lib/rails/worktrees/version.rb",
+      "changelog-path": "CHANGELOG.md"
+    }
+  }
+}

data/sig/rails/worktrees.rbs

@@ -0,0 +1,23 @@
+module Rails
+  module Worktrees
+    VERSION: String
+
+    class Error < StandardError
+    end
+
+    class Configuration
+      attr_accessor bootstrap_env: bool
+      attr_accessor workspace_root: String?
+      attr_accessor branch_prefix: String
+      attr_accessor dev_port_range: ::Range[Integer]
+      attr_accessor name_sources_path: String
+      attr_accessor used_names_file: String
+      attr_accessor legacy_used_names_files: Array[String]
+      attr_accessor worktree_database_suffix_max_length: Integer
+    end
+
+    def self.configuration: () -> Configuration
+    def self.configure: () { (Configuration) -> void } -> Configuration
+    def self.reset_configuration!: () -> Configuration
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: rails-worktrees
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Asjer Querido
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.2'
+description: Rails::Worktrees is a Ruby gem intended to support working with git worktrees
+  in Rails development workflows.
+email:
+- asjer@johnyontherun.com
+executables:
+- wt
+extensions: []
+extra_rdoc_files: []
+files:
+- ".release-please-manifest.json"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/wt
+- lefthook.yml
+- lib/generators/rails/worktrees/install_generator.rb
+- lib/generators/rails/worktrees/mise_follow_up.rb
+- lib/generators/rails/worktrees/templates/Procfile.dev.worktree.example.tt
+- lib/generators/rails/worktrees/templates/bin/wt
+- lib/generators/rails/worktrees/templates/rails_worktrees.rb.tt
+- lib/rails/worktrees.rb
+- lib/rails/worktrees/cli.rb
+- lib/rails/worktrees/command.rb
+- lib/rails/worktrees/command/environment_support.rb
+- lib/rails/worktrees/command/git_operations.rb
+- lib/rails/worktrees/command/name_picking.rb
+- lib/rails/worktrees/command/output.rb
+- lib/rails/worktrees/command/workspace_paths.rb
+- lib/rails/worktrees/configuration.rb
+- lib/rails/worktrees/database_config_updater.rb
+- lib/rails/worktrees/env_bootstrapper.rb
+- lib/rails/worktrees/names/cities.txt
+- lib/rails/worktrees/railtie.rb
+- lib/rails/worktrees/version.rb
+- mise.toml
+- release-please-config.json
+- sig/rails/worktrees.rbs
+homepage: https://github.com/asjer/rails-worktrees
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/asjer/rails-worktrees
+  source_code_uri: https://github.com/asjer/rails-worktrees
+  changelog_uri: https://github.com/asjer/rails-worktrees/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message: "\n============================================\n  Thank you
+  for installing rails-worktrees! \U0001F389\n\n  Run the installer:\n    $ bin/rails
+  generate rails:worktrees:install\n\n  Docs: https://github.com/asjer/rails-worktrees\n============================================\n\n"
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Helpers for managing Rails application git worktrees.
+test_files: []