ctree 0.5.3

data/lib/ctree/config.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+module Ctree
+  # Configuration is layered (lowest → highest priority):
+  #   1. lib/ctree/config.yml            — shipped defaults (always the base).
+  #   2. <source_root>/.ctree/config.yml — per-repo override; created by
+  #                                        `ctree config add`. Keys here win.
+  #
+  # Note on .ctree/config.yml: this file is intentionally NOT raw-cloned into
+  # worktrees (`.ctree` is hardcoded in the top-level exclusion list at the
+  # same tier as `.git`). Instead, `ctree create` explicitly recreates it in
+  # the new worktree from the source copy. This prevents stray files in source's
+  # `.ctree/` from propagating to worktrees. See CREATE.md for details.
+  #
+  # Schema (all keys optional):
+  #   update_volumes: [<string>, ...]
+  #   share_volumes: [<string>, ...]
+  #   skip_env_keys:        [<string>, ...]
+  module Config
+    module_function
+
+    SHIPPED_CONFIG_PATH   = File.expand_path("config.yml", __dir__)
+    REPO_CONFIG_REL       = File.join(".ctree", "config.yml")
+    ARRAY_KEYS            = %w[update_volumes share_volumes skip_env_keys].freeze
+    OPTIONAL_ARRAY_KEYS   = %w[rebase exclude update empty_volumes post_update_hooks post_rebase_hooks].freeze
+    STRING_KEYS           = %w[env_filename host_name].freeze
+    OPTIONAL_STRING_KEYS  = %w[host_name_suffix compose_override_file host_domain_env_key free_branch_prefix].freeze
+    BOOLEAN_KEYS          = %w[log_prefix].freeze
+    VALID_LOG_LEVELS      = %w[info debug].freeze
+    SUPPORTED_KEYS        = (ARRAY_KEYS + OPTIONAL_ARRAY_KEYS + STRING_KEYS + OPTIONAL_STRING_KEYS + BOOLEAN_KEYS + %w[log_level]).freeze
+
+    def load(source_root)
+      # Layered lowest → highest priority. Shipped defaults are always the
+      # base so a partial repo config only overrides the keys it sets;
+      # unspecified keys fall through to the shipped values.
+      #   1. shipped defaults
+      #   2. per-repo (<source_root>/.ctree/config.yml)
+      result = load_yaml(SHIPPED_CONFIG_PATH, must_exist: true)
+
+      repo_path = File.join(source_root.to_s, REPO_CONFIG_REL)
+      if File.file?(repo_path)
+        result = result.merge(load_yaml(repo_path, must_exist: false)) { |_, _, v| v }
+      end
+
+      validate_and_normalize(result, repo_path)
+    end
+
+    # Loads shipped defaults merged with a custom config file, skipping the
+    # repo's .ctree/config.yml layer entirely. The named file replaces what
+    # the repo config would have provided — shipped defaults are still the
+    # base underneath it.
+    #
+    # override_path - path to the custom config file, relative to Dir.pwd or
+    #                 absolute. Must exist, be parseable YAML, and be a top-
+    #                 level mapping. Dies with a clear message otherwise.
+    def load_with_override(override_path)
+      abs_path = File.expand_path(override_path, Dir.pwd)
+      result = load_yaml(SHIPPED_CONFIG_PATH, must_exist: true)
+      custom = load_yaml(abs_path, must_exist: true)
+      result = result.merge(custom) { |_, _, v| v }
+      validate_and_normalize(result, abs_path)
+    end
+
+    # Returns the shipped defaults as a normalized, symbol-keyed hash.
+    def defaults
+      raw = load_yaml(SHIPPED_CONFIG_PATH, must_exist: true)
+      validate_and_normalize(raw, SHIPPED_CONFIG_PATH)
+    end
+
+    # Scaffolds <repo_top>/.ctree/config.yml from the shipped template so the
+    # repo has an annotated, committable per-repo config. Must be run inside a
+    # git repository; refuses to clobber an existing file without confirmation.
+    def add_local!(force: false)
+      top = repo_top_or_die
+      dir = top / ".ctree"
+      target = dir / "config.yml"
+      if target.exist?
+        unless Prompt.confirm("Config file exists: #{target}. Reset it? [y/N]:", default: :no, force: force)
+          Log.info "keeping existing config"
+          return
+        end
+      end
+
+      already_existed = target.exist?
+      FileUtils.mkdir_p(dir.to_s)
+      FileUtils.cp(SHIPPED_CONFIG_PATH, target.to_s)
+      Log.info "#{already_existed ? "reset" : "created"} #{target}"
+      Log.info "edit it to set this repo's ctree config"
+    end
+
+    # Removes <repo_top>/.ctree/config.yml and the .ctree directory. Must be
+    # run inside a git repository. If .ctree holds files other than config.yml,
+    # the directory is kept (we don't delete content ctree didn't create).
+    def remove_local!(force: false)
+      top = repo_top_or_die
+      dir = top / ".ctree"
+      target = dir / "config.yml"
+      unless target.exist?
+        Log.info "no local config file found at #{target}"
+        return
+      end
+      puts
+      puts "[#{PROG}] About to delete:"
+      puts "  #{target}"
+      puts "  #{dir}/  (if empty after removing the config)"
+      puts
+      unless Prompt.confirm("Type 'yes' to confirm removal:", default: nil, force: force)
+        Log.info "aborted — config file kept"
+        return
+      end
+      File.delete(target.to_s)
+      Log.info "deleted #{target}"
+
+      remaining = dir.children
+      if remaining.empty?
+        Dir.rmdir(dir.to_s)
+        Log.info "removed #{dir}"
+      else
+        Log.warn_ "kept #{dir} — it still contains: #{remaining.map(&:basename).join(", ")}"
+      end
+    end
+
+    # Prints the repo's local config as YAML, or notes that none exists.
+    def print_resolved!
+      source_root = ensure_at_repo_top!
+      repo_path = File.join(source_root.to_s, REPO_CONFIG_REL)
+      unless File.file?(repo_path)
+        Log.info "no local config file (#{REPO_CONFIG_REL}); run `#{PROG} config add` to create one"
+        return
+      end
+      puts "# Local config: #{repo_path}"
+      resolved = load(source_root)
+      puts YAML.dump(resolved.transform_keys(&:to_s))
+    end
+
+    def ensure_at_repo_top!
+      source_root = Pathname.pwd
+      toplevel_out, _, status = Sh.capture3("git", "-C", source_root.to_s, "rev-parse", "--show-toplevel")
+      Log.die "not inside a git repository" unless status.success?
+      git_top = Pathname.new(toplevel_out.strip)
+      unless source_root.realpath == git_top.realpath
+        Log.die "must be invoked from project top-level (cwd=#{source_root}, top=#{git_top})"
+      end
+      source_root
+    end
+
+    # Returns the repository top-level for the current directory, or dies with
+    # a warning. Unlike ensure_at_repo_top!, this works from any subdirectory
+    # of the repo — config add/remove always operate on the repo top-level.
+    def repo_top_or_die
+      toplevel_out, _, status = Sh.capture3("git", "-C", Pathname.pwd.to_s, "rev-parse", "--show-toplevel")
+      Log.die "ctree config must be run from within a git repository" unless status.success?
+      Pathname.new(toplevel_out.strip)
+    end
+
+    def load_yaml(path, must_exist:)
+      raw = nil
+      begin
+        raw = YAML.safe_load(File.read(path), aliases: true)
+      rescue Errno::ENOENT
+        Log.die "ctree defaults file missing: #{path}" if must_exist
+        return {}
+      rescue Psych::SyntaxError => e
+        if must_exist
+          Log.die "could not parse ctree defaults #{path}: #{e.message}"
+        else
+          Log.warn_ "could not parse #{path}: #{e.message}; ignoring overrides"
+          return {}
+        end
+      end
+
+      unless raw.is_a?(Hash)
+        Log.die "#{path}: top-level must be a YAML mapping" if must_exist
+        Log.warn_ "#{path}: top-level must be a YAML mapping; ignoring overrides"
+        return {}
+      end
+
+      raw
+    end
+
+    def validate_and_normalize(merged, config_path)
+      result = {}
+      # Insertion order here is the order `ctree config` prints. Keep
+      # host_name and host_name_suffix adjacent.
+      ARRAY_KEYS.each do |key|
+        val = merged[key]
+        unless val.is_a?(Array) && val.all? { |x| x.is_a?(String) }
+          Log.die "missing or invalid #{key.inspect} in ctree config (check config.yml or #{config_path})"
+        end
+        result[key.to_sym] = val.dup
+      end
+      OPTIONAL_ARRAY_KEYS.each do |key|
+        val = merged[key]
+        unless val.nil? || (val.is_a?(Array) && val.all? { |x| x.is_a?(String) })
+          Log.die "missing or invalid #{key.inspect} in ctree config (check config.yml or #{config_path})"
+        end
+        result[key.to_sym] = (val || []).dup
+      end
+      STRING_KEYS.each do |key|
+        val = merged[key]
+        unless val.is_a?(String) && !val.strip.empty?
+          Log.die "missing or invalid #{key.inspect} in ctree config (check config.yml or #{config_path})"
+        end
+        result[key.to_sym] = val.dup
+      end
+      OPTIONAL_STRING_KEYS.each do |key|
+        val = merged[key]
+        unless val.nil? || val.is_a?(String)
+          Log.die "missing or invalid #{key.inspect} in ctree config (check config.yml or #{config_path})"
+        end
+        result[key.to_sym] = (val || "").dup
+      end
+      BOOLEAN_KEYS.each do |key|
+        val = merged[key]
+        unless val.nil? || val.is_a?(TrueClass) || val.is_a?(FalseClass)
+          Log.die "missing or invalid #{key.inspect} in ctree config (check config.yml or #{config_path})"
+        end
+        result[key.to_sym] = (val.nil? ? true : val) # default to true
+      end
+
+      # NEW: Apply environment variable override for log_prefix
+      if ENV['CTREE_LOG_PREFIX']
+        env_val = ENV['CTREE_LOG_PREFIX'].downcase
+        if %w[true false].include?(env_val)
+          result[:log_prefix] = (env_val == 'true')
+        else
+          Log.warn_ "invalid value for CTREE_LOG_PREFIX: #{ENV['CTREE_LOG_PREFIX']}. Expected 'true' or 'false'. Ignoring."
+        end
+      end
+
+      log_level_val = merged["log_level"]
+      if log_level_val.nil?
+        result[:log_level] = "info"
+      elsif VALID_LOG_LEVELS.include?(log_level_val)
+        result[:log_level] = log_level_val
+      else
+        Log.die "invalid log_level #{log_level_val.inspect} in ctree config; must be one of: #{VALID_LOG_LEVELS.join(", ")}"
+      end
+      result
+    end
+  end
+end

data/lib/ctree/config.yml

@@ -0,0 +1,111 @@
+# Default ctree configuration shipped with the package.
+#
+# Override per-repo by creating <source_root>/.ctree/config.yml with the same
+# schema. Keys present in the user file replace the defaults below; absent
+# keys fall back to these values.
+
+# Name of the env file ctree reads and writes in both the source repo and
+# each worktree (e.g. COMPOSE_PROJECT_NAME, HOST_NAME, and any prompted
+# variables). Change this if a project uses a non-standard env file name.
+env_filename: .env
+
+# The suffix part of Docker volume names to share between source and worktree.
+# Suffix = everything after the leading `<project>_` in the full volume name.
+# Example: full name `myapp_node_modules` → suffix is `node_modules`.
+# ctree rewrites the worktree's compose_override_file to mount the source
+# project's volume directly (external: true) rather than creating a new one.
+share_volumes: []
+
+# The suffix part of Docker volume names that `ctree update` is allowed to
+# rsync from source into the worktree. Suffix = everything after `<project>_`.
+# Example: full name `myapp_bundler` → suffix is `bundler`.
+# This is an allowlist — volumes not listed are left untouched so new
+# stateful volumes fail closed rather than being silently overwritten.
+update_volumes: []
+
+# Volume name suffixes that ctree creates empty in the worktree rather than
+# copying from source. Use for transient volumes (e.g. logs, tmp) whose
+# content is not meaningful to a fresh branch environment.
+# Suffix = everything after the leading `<project>_`.
+# During ctree create: volume is created with no data (rsync skipped).
+# During ctree update: volume is skipped regardless of update_volumes.
+empty_volumes: []
+
+# Variables in the source .env that are auto-set during `ctree create` and
+# NOT presented as interactive prompts. COMPOSE_PROJECT_NAME is always
+# excluded (it is set to the target project name) regardless of this list.
+skip_env_keys: []
+
+# The .env variable that ctree sets to the worktree name so the worktree
+# can be accessed via its own domain (e.g. worktree-abc.docker). ctree sets
+# this automatically — the user is never prompted for it.
+host_name: HOST_NAME
+
+# The TLD written to HOST_NAME_SUFFIX in the worktree .env. When non-empty,
+# ctree writes HOST_NAME_SUFFIX=<value> so compose files can construct
+# ${HOST_NAME}.${HOST_NAME_SUFFIX} for domain routing. Leave empty for
+# projects that don't use HOST_NAME_SUFFIX.
+host_name_suffix: ""
+
+# The .env variable that ctree sets to <HOST_NAME>.<HOST_NAME_SUFFIX> during
+# `ctree create`. Use when a project reads its full worktree domain from a
+# single .env variable (e.g. MYAPP_DOMAIN). ctree computes the value as
+# <worktree_name>.<host_name_suffix> and writes it automatically — no prompt.
+# If this key also appears in skip_env_keys it is ignored there; this setting
+# takes precedence. Leave empty if the project does not use such a variable.
+host_domain_env_key: ""
+
+# Directories (relative to repo root) scanned one level deep for embedded
+# git repos during `ctree rebase`. Each subdirectory that has a .git entry
+# and is NOT listed in .gitmodules is treated as an independent embedded repo
+# and rebased from its source counterpart (local-only, no network).
+# Example: [gems/plugins] will rebase all embedded repos in the worktree's
+# gems/plugins directory from <source_root>/gems/plugins/*.
+rebase: []
+
+# The docker-compose override file that ctree automatically rewrites during
+# `ctree create` to mark shared volumes as external references to the source
+# project's volumes.
+compose_override_file: docker-compose.local.ctree.yml
+
+# Top-level names (files or directories) to skip when cloning the source
+# working tree into a new worktree during `ctree create`. Matched by
+# basename — top-level items only.
+# Note: .ctree is always implicitly excluded (it is a reserved directory
+# managed by ctree itself). Listing it here is a harmless no-op.
+# Examples: node_modules (directory), .env.local (file)
+exclude: []
+
+# Repo-relative files or directories copied from source to worktree during
+# `ctree update` and `ctree create`. Use for gitignored artifacts that
+# describe the state of shared Docker volumes (e.g. Gemfile.*.plugins.lock
+# next to gem volumes). These are not updated by `git rebase` since they are
+# gitignored, but must match the source after a volume sync for
+# gems/packages to resolve. Files are copied directly; directories are
+# synced recursively (additions, modifications, and deletions).
+# Example: [Gemfile.rails8.plugins.lock]
+update: []
+
+# Shell commands run automatically after `ctree update` completes, regardless
+# of whether any volume syncs failed. Commands execute in order from the
+# worktree root; execution stops on the first non-zero exit.
+# Example:
+#   post_update_hooks:
+#     - docker compose run --rm web bundle exec rake db:migrate RAILS_ENV=development
+post_update_hooks: []
+
+# Branch name prefix used by `ctree list` to detect free (placeholder) worktrees.
+# Any worktree whose checked-out branch starts with this prefix is treated as a
+# placeholder and shown with a "(free)" tag. `ctree list free` then limits output
+# to only those worktrees. Leave empty to disable the feature.
+# Default: "FREE-"
+free_branch_prefix: "FREE-"
+
+# Log verbosity during `ctree create`. 'info' shows one summary line per
+# phase (default). 'debug' shows every per-item action — useful when
+# diagnosing volume or file issues.
+log_level: info
+
+# Whether to show the [ctree] prefix in console output. Set to false to
+# remove the prefix from all console messages.
+log_prefix: true