git_tree 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3592f1261444da8733168030eebf398f6055fb5f53e2c5758b44fac69e9092fe
-  data.tar.gz: caae86a90d3acaf2267b58de6449625fbf23a010756539ee0fd9b65efe6a6678
+  metadata.gz: 4703e322963fd70470c26e91b28bbc1bee8928abe0b8090ba7eabc5d1970f1d5
+  data.tar.gz: 2fd2b50f103e7b6ea25d917337f1710e31f5ed01c963a5eb07b1917f32fb4a00
 SHA512:
-  metadata.gz: b02edfd02bbb8589f53bdafc76b4a298b8fff75fdeee4af016b7912e85220c35366bee1e83cf1a95deb923202cdb687c32e80610dccd8408b8918a5f4b09de6e
-  data.tar.gz: 9281499cf2057b365a6ac8e01de640fe457d7d1e463c7e10da8e25c203ff3917f3673333de618db645a70c5c1da47eb4058a4922b925e317ab2cbc3ebbc639db
+  metadata.gz: 3f6f72f9f8d29388eb116423b34236fc876e3b14de99f2024cec036e562afc9be2bde0973ef78d80728e420d4b5ceedcef3906c0993c156362d89939ee674214
+  data.tar.gz: bb56c09a095f234c0c3b8a9373fe4e8c5cdd13b3935a28a7af6c2b1c671aa94c365b5f5dfacaaf15d0e1a8e7f2e9a09dc18e6c59c8c6a7913c491e30cffa4f8c

data/.rubocop.yml

@@ -79,6 +79,9 @@ Naming/FileName:
 RSpec/ExampleLength:
   Max: 20
 
+RSpec/InstanceVariable:
+  Enabled: false
+
 RSpec/MultipleExpectations:
   Max: 15
 

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Change Log
 
+## 1.0.2 / 2025-10-04
+
+* Increased `GitTreeWalker.GIT_TIMEOUT` to 5 minutes.
+* Added `git-treeconfig` command and support for configuration file and environment variable configuration.
+
+
 ## 1.0.1 / 2025-10-04
 
 * Removed unnecessary and problematic `gem_support` dependency.

data/README.md

@@ -47,6 +47,61 @@ $ gem install git_tree
 
 To register the new commands, either log out and log back in, or open a new console.
 
+
+## Configuration
+
+The `git_tree` commands can be configured to suit your preferences. Settings are resolved in the following order of precedence,
+where items higher in the list override those lower down:
+
+1. **Environment Variables**
+2. **User Configuration File** (`~/.treeconfig.yml`)
+3. **Default values** built into the gem.
+
+This allows for flexible customization of the gem's behavior.
+
+### Interactive Setup: `git-treeconfig`
+
+The easiest way to get started is to use the `git-treeconfig` command. This interactive tool will ask you a few questions
+and create a configuration file for you at `~/.treeconfig.yml`.
+
+```shell
+$ git-treeconfig
+Welcome to git-tree configuration.
+This utility will help you create a configuration file at: /home/user/.treeconfig.yml
+Press Enter to accept the default value in brackets.
+
+Git command timeout in seconds? |300| 600
+Default verbosity level (0=quiet, 1=normal, 2=verbose)? |1|
+Default root directories (space-separated)? |sites sitesUbuntu work| dev projects
+
+Configuration saved to /home/user/.treeconfig.yml
+```
+
+### Configuration File
+
+The `git-treeconfig` command generates a YAML file (`~/.treeconfig.yml`) that you can also edit manually.
+
+Here is an example:
+
+```yaml
+---
+git_timeout: 600
+verbosity: 1
+default_roots:
+- dev
+- projects
+```
+
+### Environment Variables
+
+For temporary overrides or use in CI/CD environments, you can use environment variables.
+They must be prefixed with `GIT_TREE_` and be in uppercase.
+
+- `export GIT_TREE_GIT_TIMEOUT=900`
+- `export GIT_TREE_VERBOSITY=2`
+- `export GIT_TREE_DEFAULT_ROOTS="dev projects personal"` (space-separated string)
+
+
 ## Use Cases
 
 ### Dependent Gem Maintenance
@@ -64,6 +119,7 @@ the bash script proved difficult to maintain. This use case is now fulfilled by
 provided by the `git_tree` gem.
 See below for further details.
 
+
 ### Replicating Trees of Git Repositories
 
 Whenever I set up an operating system for a new development computer,

data/exe/git-treeconfig

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/commands/git_treeconfig'

data/git_tree.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |spec| # rubocop:disable Metrics/BlockLength
     The git-update command updates each repository in the tree.
   END_OF_DESC
   spec.email       = ['mslinn@mslinn.com']
-  spec.executables = %w[git-commitAll git-evars git-exec git-replicate git-update]
+  spec.executables = %w[git-commitAll git-evars git-exec git-replicate git-treeconfig git-update]
   spec.files = Dir[
     '{exe,lib}/**/*',
     '.rubocop.yml',
@@ -45,11 +45,17 @@ Gem::Specification.new do |spec| # rubocop:disable Metrics/BlockLength
 
     Thanks for installing #{spec.name}!
 
+    To customize default settings like timeout and repository roots,
+    run the interactive configuration tool:
+      git-treeconfig
+
   END_MESSAGE
   spec.required_ruby_version = '>= 3.2.0'
   spec.summary               = 'Installs five commands that walk a git directory tree and perform tasks.'
   spec.version               = GitUrlsVersion::VERSION
 
+  spec.add_dependency 'anyway_config', '~> 2.0'
+  spec.add_dependency 'highline'
   spec.add_dependency 'rainbow'
   spec.add_dependency 'rugged'
 end

data/lib/commands/abstract_command.rb

@@ -1,8 +1,10 @@
 require 'optparse'
-require_relative '../util/git_tree_walker'
+require_relative '../util/config'
 require_relative '../util/log'
 
 module GitTree
+  # Abstract base class for all git-tree commands.
+  # It handles common option parsing for verbosity and help.
   class AbstractCommand
     include Logging
 
@@ -11,78 +13,53 @@ module GitTree
     end
 
     def initialize(args = ARGV, options: {})
-      @raw_args = args
-      @options = { serial: false }.merge(options)
+      @args = args
+      @options = options
+      @config = GitTree::Config.new
+      # Set initial verbosity from config before anything else happens.
+      # log Logging::VERBOSE, "AbstractCommand#initialize: Setting initial verbosity from config to: #{@config.verbosity}"
+      Logging.verbosity = @config.verbosity
     end
 
-    # This method should be called after initialize to parse options
-    # and finalize setup. This makes testing easier by allowing dependency
-    # injection before options are parsed.
+    # Common setup for all commands.
+    # Parses options and sets initial verbosity.
     def setup
-      @args = parse_options(@raw_args)
-      # Show help if no arguments are provided, unless allow_empty_args is set.
-      help if @args.empty? && !self.class.allow_empty_args
-    end
-
-    def run
-      raise NotImplementedError, "#{self.class.name} must implement the 'run' method."
+      # CLI options can override the config verbosity.
+      log Logging::VERBOSE, "AbstractCommand#setup: verbosity before parsing options: #{Logging.verbosity}"
+      parse_options(@args)
     end
 
     private
 
-    # Subclasses must implement this to provide their specific help text.
-    def help
-      raise NotImplementedError, "#{self.class.name} must implement the 'help' method."
-    end
-
-    # Provides a base OptionParser. Subclasses will add their specific options.
+    # Parses common options like -h, -q, -v.
+    # This method can be extended by subclasses by passing a block.
     def parse_options(args)
-      parsed_options = {}
       parser = OptionParser.new do |opts|
-        opts.on("-h", "--help", "Show this help message and exit.") do
+        opts.on("-h", "--help", "Show this help message and exit") do
           help
         end
-        opts.on("-q", "--quiet", "Suppress normal output, only show errors.") do
-          parsed_options[:verbosity] = QUIET
+
+        opts.on("-q", "--quiet", "Suppress normal output, only show errors") do
+          log Logging::NORMAL, "OptionParser: -q setting verbosity to QUIET"
+          Logging.verbosity = ::Logging::QUIET
         end
-        opts.on("-v", "--verbose", "Increase verbosity. Can be used multiple times (e.g., -v, -vv).") do
-          # This logic is now handled after parsing
-          parsed_options[:verbose_count] ||= 0
-          parsed_options[:verbose_count] += 1
+
+        opts.on("-s", "--serial", "Run tasks serially in a single thread") do
+          @options[:serial] = true
+          log Logging::NORMAL, "OptionParser: -s setting serial mode"
         end
-        opts.on('-s', "--serial", "Run tasks serially in a single thread in the order specified.") do
-          parsed_options[:serial] = true
+
+        opts.on("-v", "--verbose", "Increase verbosity. Can be used multiple times.") do
+          Logging.verbosity += 1
+          log Logging::NORMAL, "OptionParser: -v increased verbosity to #{Logging.verbosity}"
         end
-        yield opts if block_given?
-      end
-      remaining_args = parser.parse(args)
 
-      # Apply parsed verbosity settings
-      if parsed_options[:verbosity] == QUIET
-        Logging.verbosity = QUIET
-      elsif parsed_options[:verbose_count]
-        verbosity_level = case parsed_options[:verbose_count]
-                          when 1 then VERBOSE
-                          else DEBUG # 2 or more -v flags
-                          end
-        Logging.verbosity = verbosity_level
-        parsed_options[:verbose] = verbosity_level
+        yield(opts) if block_given?
       end
 
-      # Merge parsed options into existing @options, preserving initial ones.
-      @options.merge!(parsed_options)
-
-      remaining_args
-    end
-
-    protected
-
-    # @param dir [String] path to a git repository
-    # @return [Boolean] true if the repository has changes, false otherwise.
-    def repo_has_changes?(dir)
-      repo = Rugged::Repository.new(dir)
-      repo.status { |_path, _status| return true }
-      false
+      parser.parse!(args)
+      help("No arguments are allowed") if !self.class.allow_empty_args && args.empty?
+      args
     end
   end
 end

data/lib/commands/git_commit_all.rb

@@ -4,7 +4,7 @@ require 'timeout'
 require 'rugged'
 
 require_relative 'abstract_command'
-require_relative '../util/git_tree_walker'
+require_relative '../util/git_tree_walker' # This is correct, no change needed here.
 
 module GitTree
   class CommitAllCommand < AbstractCommand
@@ -33,10 +33,10 @@ module GitTree
     private
 
     def help(msg = nil)
-      log(QUIET, "Error: #{msg}\n", :red) if msg
-      log QUIET, <<~END_MSG
+      log(Logging::QUIET, "Error: #{msg}\n", :red) if msg
+      log Logging::QUIET, <<~END_MSG
         #{$PROGRAM_NAME} - Recursively commits and pushes changes in all git repositories under the specified roots.
-        If no directories are given, uses default environment variables (#{GitTreeWalker::DEFAULT_ROOTS.join(', ')}) as roots.
+        If no directories are given, uses default roots (#{@config.default_roots.join(', ')}) as roots.
         Skips directories containing a .ignore file, and all subdirectories.
         Repositories in a detached HEAD state are skipped.
 
@@ -79,35 +79,42 @@ module GitTree
     # @return [nil]
     def process_repo(dir, thread_id, walker, message)
       short_dir = walker.abbreviate_path(dir)
-      log VERBOSE, "Examining #{short_dir} on thread #{thread_id}", :green
+      log Logging::VERBOSE, "Examining #{short_dir} on thread #{thread_id}", :green
       begin
         # The highest priority is to check for the presence of an .ignore file.
         if File.exist?(File.join(dir, '.ignore'))
-          log DEBUG, "  Skipping #{short_dir} due to .ignore file", :green
+          log Logging::DEBUG, "  Skipping #{short_dir} due to .ignore file", :green
           return
         end
 
         repo = Rugged::Repository.new(dir)
         if repo.head_detached?
-          log VERBOSE, "  Skipping #{short_dir} because it is in a detached HEAD state", :yellow
+          log Logging::VERBOSE, "  Skipping #{short_dir} because it is in a detached HEAD state", :yellow
           return
         end
 
-        Timeout.timeout(GitTreeWalker::GIT_TIMEOUT) do
+        Timeout.timeout(walker.config.git_timeout) do
           unless repo_has_changes?(dir)
-            log DEBUG, "  No changes to commit in #{short_dir}", :green
+            log Logging::DEBUG, "  No changes to commit in #{short_dir}", :green
             return
           end
           commit_changes(dir, message, short_dir)
         end
       rescue Timeout::Error
-        log NORMAL, "[TIMEOUT] Thread #{thread_id}: git operations timed out in #{short_dir}", :red
+        log Logging::NORMAL, "[TIMEOUT] Thread #{thread_id}: git operations timed out in #{short_dir}", :red
       rescue StandardError => e
-        log NORMAL, "#{e.class} processing #{short_dir}: #{e.message}", :red
-        e.backtrace.join("\n").each_line { |line| log DEBUG, line, :red }
+        log Logging::NORMAL, "#{e.class} processing #{short_dir}: #{e.message}", :red
+        e.backtrace.join("\n").each_line { |line| log Logging::DEBUG, line, :red }
       end
     end
 
+    # @return [Boolean] True if the repository has changes, false otherwise.
+    def repo_has_changes?(dir)
+      repo = Rugged::Repository.new(dir)
+      repo.status { |_file, status| return true if status != :current && status != :ignored }
+      false
+    end
+
     # @param dir [String] The path to the git repository.
     # @return [Boolean] True if the repository has changes, false otherwise.
     def repo_has_staged_changes?(repo)
@@ -137,7 +144,7 @@ module GitTree
 
       current_branch = repo.head.name.sub('refs/heads/', '')
       system('git', '-C', dir, 'push', '--set-upstream', 'origin', current_branch, exception: true)
-      log NORMAL, "Committed and pushed changes in #{short_dir}", :green
+      log Logging::NORMAL, "Committed and pushed changes in #{short_dir}", :green
     end
   end
 end
@@ -146,10 +153,10 @@ if $PROGRAM_NAME == __FILE__ || $PROGRAM_NAME.end_with?('git-commitAll') # Corre
   begin
     GitTree::CommitAllCommand.new(ARGV).run
   rescue Interrupt
-    log NORMAL, "\nInterrupted by user", :yellow
+    log Logging::NORMAL, "\nInterrupted by user", :yellow
     exit! 130 # Use exit! to prevent further exceptions on shutdown
   rescue StandardError => e
-    log QUIET, "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}", :red
+    log Logging::QUIET, "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}", :red
     exit 1
   end
 end

data/lib/commands/git_evars.rb

@@ -18,7 +18,7 @@ module GitTree
       if @options[:zowee]
         walker = GitTreeWalker.new(@args, options: @options)
         all_paths = []
-        walker.find_and_process_repos do |dir, _|
+        walker.find_and_process_repos do |dir, _root_arg|
           all_paths << dir
         end
         optimizer = ZoweeOptimizer.new(walker.root_map)
@@ -26,7 +26,7 @@ module GitTree
       elsif @args.empty? # No args provided, use default roots and substitute them in the output
         walker = GitTreeWalker.new([], options: @options)
         walker.find_and_process_repos do |dir, _root_arg|
-          result << make_env_var_with_substitution(dir, GitTreeWalker::DEFAULT_ROOTS)
+          result << make_env_var_with_substitution(dir, walker.config.default_roots)
         end
       else # Args were provided, process them as roots
         processed_args = @args.flat_map { |arg| arg.strip.split(/\s+/) }
@@ -47,12 +47,12 @@ module GitTree
     # @param msg [String] The error message to display before the help text.
     # @return [nil]
     def help(msg = nil)
-      log(QUIET, "Error: #{msg}\n", :red) if msg
-      log QUIET, <<~END_HELP
+      log(Logging::QUIET, "Error: #{msg}\n", :red) if msg
+      log Logging::QUIET, <<~END_HELP
         #{$PROGRAM_NAME} - Generate bash environment variables for each git repository found under specified directory trees.
 
         Examines trees of git repositories and writes a bash script to STDOUT.
-        If no directories are given, uses default environment variables (#{GitTreeWalker::DEFAULT_ROOTS.join(', ')}) as roots.
+        If no directories are given, uses default roots (#{@config.default_roots.join(', ')}) as roots.
         These environment variables point to roots of git repository trees to walk.
         Skips directories containing a .ignore file, and all subdirectories.
 
@@ -150,10 +150,10 @@ if $PROGRAM_NAME == __FILE__ || $PROGRAM_NAME.end_with?('git-evars')
   begin
     GitTree::EvarsCommand.new(ARGV).run
   rescue Interrupt
-    log NORMAL, "\nInterrupted by user", :yellow
+    log Logging::NORMAL, "\nInterrupted by user", :yellow
     exit! 130 # Use exit! to prevent further exceptions on shutdown
   rescue StandardError => e
-    log QUIET, "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}", :red
+    log Logging::QUIET, "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}", :red
     exit! 1
   end
 end

data/lib/commands/git_exec.rb

@@ -35,6 +35,9 @@ module GitTree
     def execute_and_log(dir, command)
       output, status = @runner.run(command, dir)
       log_result(output, status.success?)
+    rescue Errno::ENOENT
+      error_message = "Error: Command '#{command}' not found in #{dir}"
+      log_result(error_message, false)
     rescue StandardError => e
       error_message = "Error: '#{e.message}' from executing '#{command}' in #{dir}"
       log_result(error_message, false)
@@ -48,16 +51,16 @@ module GitTree
         log_stdout output.strip
       else
         # Errors should go to STDERR.
-        log QUIET, output.strip, :red
+        log Logging::QUIET, output.strip, :red
       end
     end
 
     def help(msg = nil)
-      log(QUIET, "Error: #{msg}\n", :red) if msg
-      log QUIET, <<~END_HELP
+      log(Logging::QUIET, "Error: #{msg}\n", :red) if msg
+      log Logging::QUIET, <<~END_HELP
         #{$PROGRAM_NAME} - Executes an arbitrary shell command for each repository.
 
-        If no arguments are given, uses default environment variables (#{GitTreeWalker::DEFAULT_ROOTS.join(', ')}) as roots.
+        If no arguments are given, uses default roots (#{@config.default_roots.join(', ')}) as roots.
         These environment variables point to roots of git repository trees to walk.
         Skips directories containing a .ignore file, and all subdirectories.
 
@@ -95,10 +98,10 @@ if $PROGRAM_NAME == __FILE__ || $PROGRAM_NAME.end_with?('git-exec')
   begin
     GitTree::ExecCommand.new(ARGV).run
   rescue Interrupt
-    log NORMAL, "\nInterrupted by user", :yellow
+    log Logging::NORMAL, "\nInterrupted by user", :yellow
     exit! 130 # Use exit! to prevent further exceptions on shutdown
   rescue StandardError => e
-    log QUIET, "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}", :red
+    log Logging::QUIET, "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}", :red
     exit 1
   end
 end

data/lib/commands/git_replicate.rb

@@ -23,10 +23,10 @@ module GitTree
     private
 
     def help(msg = nil)
-      log(QUIET, "Error: #{msg}\n", :red) if msg
-      log QUIET, <<~END_HELP
+      log(Logging::QUIET, "Error: #{msg}\n", :red) if msg
+      log Logging::QUIET, <<~END_HELP
         #{$PROGRAM_NAME} - Replicates trees of git repositories and writes a bash script to STDOUT.
-        If no directories are given, uses default environment variables (#{GitTreeWalker::DEFAULT_ROOTS.join(', ')}) as roots.
+        If no directories are given, uses default roots (#{@config.default_roots.join(', ')}) as roots.
         The script clones the repositories and replicates any remotes.
         Skips directories containing a .ignore file.
 
@@ -82,10 +82,10 @@ if $PROGRAM_NAME == __FILE__ || $PROGRAM_NAME.end_with?('git-replicate') # Corre
   begin
     GitTree::ReplicateCommand.new(ARGV).run
   rescue Interrupt
-    log NORMAL, "\nInterrupted by user", :yellow
+    log Logging::NORMAL, "\nInterrupted by user", :yellow
     exit! 130 # Use exit! to prevent further exceptions on shutdown
   rescue StandardError => e
-    log QUIET, "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}", :red
+    log Logging::QUIET, "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}", :red
     exit! 1
   end
 end

data/lib/commands/git_treeconfig.rb

@@ -0,0 +1,60 @@
+require 'highline'
+require 'yaml'
+require_relative '../util/config'
+require_relative '../util/log'
+
+module GitTree
+  # A command to interactively create a user-level configuration file.
+  class TreeconfigCommand
+    include Logging
+
+    def initialize
+      $PROGRAM_NAME = 'git-treeconfig'
+      @cli = HighLine.new
+      @config_path = GitTree::Config.default_config_path
+      @existing_config = File.exist?(@config_path) ? YAML.load_file(@config_path) : {}
+    end
+
+    def run
+      @cli.say "Welcome to git-tree configuration."
+      @cli.say "This utility will help you create a configuration file at: #{@config_path}"
+      @cli.say "Press Enter to accept the default value in brackets."
+      @cli.say ""
+
+      defaults = GitTree::Config.new
+
+      new_config = {}
+      new_config['git_timeout'] = @cli.ask("Git command timeout in seconds? ", Integer) do |q|
+        q.default = @existing_config.fetch('git_timeout', defaults.git_timeout)
+      end
+
+      new_config['verbosity'] = @cli.ask("Default verbosity level (0=quiet, 1=normal, 2=verbose)? ", Integer) do |q|
+        q.default = @existing_config.fetch('verbosity', defaults.verbosity)
+        q.in = 0..2
+      end
+
+      roots_str = @cli.ask("Default root directories (space-separated)? ", String) do |q|
+        q.default = @existing_config.fetch('default_roots', defaults.default_roots).join(' ')
+      end
+      new_config['default_roots'] = roots_str.split
+
+      File.write(@config_path, new_config.to_yaml)
+
+      @cli.say ""
+      @cli.say @cli.color("Configuration saved to #{@config_path}", :green)
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__ || $PROGRAM_NAME.end_with?('git-treeconfig')
+  begin
+    GitTree::TreeconfigCommand.new.run
+  rescue Interrupt
+    # Using HighLine, a simple newline is enough on interrupt.
+    puts "\n"
+    exit 130
+  rescue StandardError => e
+    warn "An error occurred: #{e.message}" # Cannot use `log` here as it's outside the class scope
+    exit 1
+  end
+end

data/lib/commands/git_update.rb

@@ -32,11 +32,11 @@ module GitTree
     private
 
     def help(msg = nil)
-      log(QUIET, "Error: #{msg}\n", :red) if msg
-      log QUIET, <<~END_HELP
+      log(Logging::QUIET, "Error: #{msg}\n", :red) if msg
+      log Logging::QUIET, <<~END_HELP
         git-update - Recursively updates trees of git repositories.
 
-        If no arguments are given, uses default environment variables (#{GitTreeWalker::DEFAULT_ROOTS.join(', ')}) as roots.
+        If no arguments are given, uses default roots (#{@config.default_roots.join(', ')}) as roots.
         These environment variables point to roots of git repository trees to walk.
         Skips directories containing a .ignore file, and all subdirectories.
 
@@ -70,31 +70,31 @@ module GitTree
     # @return [nil]
     def process_repo(git_walker, dir, thread_id)
       abbrev_dir = git_walker.abbreviate_path(dir)
-      log NORMAL, "Updating #{abbrev_dir}", :green
-      log VERBOSE, "Thread #{thread_id}: git -C #{dir} pull", :yellow
+      log Logging::NORMAL, "Updating #{abbrev_dir}", :green
+      log Logging::VERBOSE, "Thread #{thread_id}: git -C #{dir} pull", :yellow
 
       output = nil
       status = nil
       begin
-        Timeout.timeout(GitTreeWalker::GIT_TIMEOUT) do
-          log VERBOSE, "Executing: git pull in #{dir}", :yellow
+        Timeout.timeout(git_walker.config.git_timeout) do
+          log Logging::VERBOSE, "Executing: git pull in #{dir}", :yellow
           output, status_obj = @runner.run('git pull', dir)
           status = status_obj.exitstatus
         end
       rescue Timeout::Error
-        log NORMAL, "[TIMEOUT] Thread #{thread_id}: git pull timed out in #{abbrev_dir}", :red
+        log Logging::NORMAL, "[TIMEOUT] Thread #{thread_id}: git pull timed out in #{abbrev_dir}", :red
         status = -1
       rescue StandardError => e
-        log NORMAL, "[ERROR] Thread #{thread_id}: #{e.class} in #{abbrev_dir}; #{e.message}\n#{e.backtrace.join("\n")}", :red
+        log Logging::NORMAL, "[ERROR] Thread #{thread_id}: #{e.class} in #{abbrev_dir}; #{e.message}\n#{e.backtrace.join("\n")}", :red
         status = -1
       end
 
       if !status.zero?
-        log NORMAL, "[ERROR] git pull failed in #{abbrev_dir} (exit code #{status}):", :red
-        log NORMAL, output.strip, :red unless output.to_s.strip.empty?
-      elsif Logging.verbosity >= VERBOSE
+        log Logging::NORMAL, "[ERROR] git pull failed in #{abbrev_dir} (exit code #{status}):", :red
+        log Logging::NORMAL, output.strip, :red unless output.to_s.strip.empty?
+      elsif Logging.verbosity >= Logging::VERBOSE
         # Output from a successful pull is considered NORMAL level
-        log NORMAL, output.strip, :green
+        log Logging::NORMAL, output.strip, :green
       end
     end
   end
@@ -104,10 +104,10 @@ if $PROGRAM_NAME == __FILE__ || $PROGRAM_NAME.end_with?('git-update')
   begin
     GitTree::UpdateCommand.new(ARGV).run
   rescue Interrupt
-    log NORMAL, "\nInterrupted by user", :yellow
+    log Logging::NORMAL, "\nInterrupted by user", :yellow
     exit! 130
   rescue StandardError => e
-    log QUIET, "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}", :red
+    log Logging::QUIET, "#{e.class}: #{e.message}\n#{e.backtrace.join("\n")}", :red
     exit! 1
   end
 end

data/lib/git_tree/version.rb

@@ -1,3 +1,3 @@
 module GitUrlsVersion
-  VERSION = '1.0.1'.freeze
+  VERSION = '1.0.2'.freeze
 end

data/lib/util/config.rb

@@ -0,0 +1,30 @@
+require 'anyway'
+require_relative 'log'
+
+module GitTree
+  # Centralized configuration for the git-tree gem.
+  # Uses anyway_config to load settings from:
+  # 1. A YAML file at ~/.treeconfig.yml
+  # 2. Environment variables (e.g., GIT_TREE_GIT_TIMEOUT)
+  # 3. Default values defined here.
+  class Config < Anyway::Config
+    config_name :treeconfig
+    env_prefix 'GIT_TREE'
+
+    # The location of the user's config file.
+    def self.default_config_path
+      File.expand_path('~/.treeconfig.yml')
+    end
+
+    # Define attributes with their default values.
+    attr_config :git_timeout, :verbosity, :default_roots
+
+    # Override initialize to set defaults for nil values after loading.
+    def initialize(*)
+      super
+      self.git_timeout   ||= 300
+      self.verbosity     ||= ::Logging::NORMAL
+      self.default_roots ||= %w[sites sitesUbuntu work]
+    end
+  end
+end

data/lib/util/git_tree_walker.rb

@@ -2,17 +2,16 @@ require 'English'
 require 'etc'
 require 'shellwords'
 require 'optparse'
-require 'timeout'
-require_relative 'thread_pool_manager'
+require 'timeout' # This is correct, no change needed here.
+require_relative 'config'
 require_relative 'log'
+require_relative 'thread_pool_manager'
 
 class GitTreeWalker
   include Logging
 
-  attr_reader :display_roots, :root_map
+  attr_reader :config, :display_roots, :root_map
 
-  DEFAULT_ROOTS = %w[sites sitesUbuntu work].freeze
-  GIT_TIMEOUT = 10 # TODO: for debuggin only; should be 300 # 5 minutes per git pull
   IGNORED_DIRECTORIES = ['.', '..', '.venv'].freeze
 
   def initialize(args = ARGV, options: {})
@@ -20,6 +19,8 @@ class GitTreeWalker
     @root_map = {}
     @display_roots = []
     determine_roots(args)
+    @config = GitTree::Config.new
+    log Logging::VERBOSE, "GitTreeWalker#initialize: verbosity is #{Logging.verbosity}"
   end
 
   def abbreviate_path(dir)
@@ -32,9 +33,9 @@ class GitTreeWalker
   end
 
   def process(&) # Accepts a block
-    log VERBOSE, "Processing #{@display_roots.join(' ')}", :green
+    log Logging::VERBOSE, "Processing #{@display_roots.join(' ')}", :green
     if @options[:serial]
-      log VERBOSE, "Running in serial mode.", :yellow
+      log Logging::VERBOSE, "Running in serial mode.", :yellow
       find_and_process_repos do |dir, _root_arg|
         yield(dir, 0, self) # task, thread_id, walker
       end

data/lib/util/log.rb

@@ -4,13 +4,14 @@ module Logging
   using Rainbow
 
   # Verbosity levels
-  QUIET = 0
-  NORMAL = 1
+  QUIET   = 0
+  NORMAL  = 1
   VERBOSE = 2
-  DEBUG = 3
+  DEBUG   = 3
 
   # Class-level instance variables to hold the verbosity setting for the module
-  @verbosity = NORMAL
+  @verbosity = ::Logging::NORMAL
+  # warn "Logging module loaded. Default verbosity: #{@verbosity}" if @verbosity >= NORMAL
 
   # @return [Integer] The current verbosity level.
   def self.verbosity
@@ -20,6 +21,9 @@ module Logging
   # @param level [Integer] The new verbosity level.
   # @return [nil]
   def self.verbosity=(level)
+    # warn "Logging.verbosity= called. Changing from #{@verbosity} to #{level}" \
+    #   if (@verbosity || NORMAL) >= NORMAL ||
+    #      (level || NORMAL) >= NORMAL
     @verbosity = level
   end
 

data/lib/util/thread_pool_manager.rb

@@ -10,12 +10,13 @@ class FixedThreadPoolManager
   # (less one for the monitor thread), with a minimum of 1.
   # @param percent_available_processors [Float] The percentage of available processors to use for worker threads.
   def initialize(percent_available_processors = 0.75)
+    log Logging::VERBOSE, "FixedThreadPoolManager#initialize: verbosity is #{Logging.verbosity}"
     if percent_available_processors > 1 || percent_available_processors <= 0
       msg = <<~END_MSG
         Error: The allowable range for the ThreadPool.initialize percent_available_processors is between 0 and 1.
         You provided #{percent_available_processors}.
       END_MSG
-      log QUIET, msg, :red
+      log Logging::QUIET, msg, :red
       exit! 1
     end
     @worker_count = [(Etc.nprocessors * percent_available_processors).floor, 1].max
@@ -61,7 +62,7 @@ class FixedThreadPoolManager
       break if active_workers.zero?
 
       if active_workers != last_active_count
-        warn format("Waiting for %d worker threads to complete...", active_workers) + "\r" if Logging.verbosity > NORMAL
+        warn format("Waiting for %d worker threads to complete...", active_workers) + "\r" if Logging.verbosity > ::Logging::NORMAL
         last_active_count = active_workers
       end
       begin
@@ -73,16 +74,16 @@ class FixedThreadPoolManager
     end
 
     warn (" " * 60) + "\r" # Clear the line
-    log NORMAL, "All work is complete.", :green
+    log Logging::VERBOSE, "All work is complete.", :green
   end
 
   private
 
   def initialize_workers
-    log NORMAL, "Initializing #{@worker_count} worker threads...", :green
+    log Logging::DEBUG, "Initializing #{@worker_count} worker threads...", :green
     @worker_count.times do |i|
       worker_thread = Thread.new do
-        log NORMAL, "  [Worker #{i}] Started.", :cyan
+        log Logging::DEBUG, "  [Worker #{i}] Started.", :cyan
         start_time = Time.now
         start_cpu = Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID)
         tasks_processed = 0
@@ -95,14 +96,14 @@ class FixedThreadPoolManager
           tasks_processed += 1
         end
 
-        if Logging.verbosity >= VERBOSE
+        if Logging.verbosity >= ::Logging::VERBOSE
           elapsed_time = Time.now - start_time
           cpu_time = Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID) - start_cpu
           shutdown_msg = format(
             "  [Worker #{i}] Shutting down. Processed #{tasks_processed} tasks. Elapsed: %.2fs, CPU: %.2fs",
             elapsed_time, cpu_time
           )
-          log VERBOSE, shutdown_msg, :cyan
+          log Logging::VERBOSE, shutdown_msg, :cyan
         end
       rescue Interrupt
         # This thread was interrupted by Ctrl-C, likely while waiting on the queue.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: git_tree
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Mike Slinn
@@ -9,6 +9,34 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: anyway_config
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rainbow
   requirement: !ruby/object:Gem::Requirement
@@ -58,6 +86,7 @@ executables:
 - git-evars
 - git-exec
 - git-replicate
+- git-treeconfig
 - git-update
 extensions: []
 extra_rdoc_files: []
@@ -71,6 +100,7 @@ files:
 - exe/git-evars
 - exe/git-exec
 - exe/git-replicate
+- exe/git-treeconfig
 - exe/git-update
 - git_tree.gemspec
 - lib/commands/abstract_command.rb
@@ -79,10 +109,12 @@ files:
 - lib/commands/git_exec.rb
 - lib/commands/git_exec_spec.rb
 - lib/commands/git_replicate.rb
+- lib/commands/git_treeconfig.rb
 - lib/commands/git_update.rb
 - lib/git_tree.rb
 - lib/git_tree/version.rb
 - lib/util/command_runner.rb
+- lib/util/config.rb
 - lib/util/gem_support.rb
 - lib/util/git_tree_walker.rb
 - lib/util/git_tree_walker_private.rb
@@ -102,6 +134,10 @@ post_install_message: |2+
 
   Thanks for installing git_tree!
 
+  To customize default settings like timeout and repository roots,
+  run the interactive configuration tool:
+    git-treeconfig
+
 rdoc_options: []
 require_paths:
 - lib