git_tree 0.3.0 → 1.0.1

data/lib/commands/abstract_command.rb

@@ -0,0 +1,88 @@
+require 'optparse'
+require_relative '../util/git_tree_walker'
+require_relative '../util/log'
+
+module GitTree
+  class AbstractCommand
+    include Logging
+
+    class << self
+      attr_accessor :allow_empty_args
+    end
+
+    def initialize(args = ARGV, options: {})
+      @raw_args = args
+      @options = { serial: false }.merge(options)
+    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.
+    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."
+    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.
+    def parse_options(args)
+      parsed_options = {}
+      parser = OptionParser.new do |opts|
+        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
+        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
+        end
+        opts.on('-s', "--serial", "Run tasks serially in a single thread in the order specified.") do
+          parsed_options[:serial] = true
+        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
+      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
+    end
+  end
+end

data/lib/commands/git_commit_all.rb

@@ -0,0 +1,155 @@
+require 'optparse'
+require 'shellwords'
+require 'timeout'
+require 'rugged'
+
+require_relative 'abstract_command'
+require_relative '../util/git_tree_walker'
+
+module GitTree
+  class CommitAllCommand < AbstractCommand
+    include Logging
+
+    attr_writer :walker
+
+    self.allow_empty_args = true
+
+    def initialize(args = ARGV, options: {})
+      $PROGRAM_NAME = 'git-commitAll'
+      super
+      # Allow walker to be injected for testing
+      @walker = @options.delete(:walker)
+    end
+
+    def run
+      setup
+      @options[:message] ||= '-'
+      @walker ||= GitTreeWalker.new(@args, options: @options)
+      @walker.process do |dir, thread_id, walker|
+        process_repo(dir, thread_id, walker, @options[:message])
+      end
+    end
+
+    private
+
+    def help(msg = nil)
+      log(QUIET, "Error: #{msg}\n", :red) if msg
+      log 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.
+        Skips directories containing a .ignore file, and all subdirectories.
+        Repositories in a detached HEAD state are skipped.
+
+        Options:
+          -h, --help                Show this help message and exit.
+          -m, --message MESSAGE     Use the given string as the commit message.
+                                    (default: "-")
+          -q, --quiet               Suppress normal output, only show errors.
+          -s, --serial              Run tasks serially in a single thread in the order specified.
+          -v, --verbose             Increase verbosity. Can be used multiple times (e.g., -v, -vv).
+
+        Usage:
+          #{$PROGRAM_NAME} [OPTIONS] [DIRECTORY...]
+
+        Usage examples:
+          #{$PROGRAM_NAME}                                # Commit with default message "-"
+          #{$PROGRAM_NAME} -m "This is a commit message"  # Commit with a custom message
+          #{$PROGRAM_NAME} $work $sites                   # Commit in repositories under specific roots
+      END_MSG
+      exit 1
+    end
+
+    # Provides an additional OptionParser to the base OptionParser defined in AbstractCommand.
+    # @param args [Array<String>] The remaining command-line arguments after the AbstractCommand OptionParser has been applied.
+    # @return [nil]
+    def parse_options(args)
+      @args = super do |opts|
+        opts.banner = "Usage: #{$PROGRAM_NAME} [options] [DIRECTORY ...]"
+        opts.on("-m MESSAGE", "--message MESSAGE", "Use the given string as the commit message.") do |m|
+          @options[:message] = m
+        end
+      end
+    end
+
+    # Processes a single git repository to check for and commit changes.
+    # @param dir [String] The path to the git repository.
+    # @param thread_id [Integer] The ID of the current worker thread.
+    # @param walker [GitTreeWalker] The GitTreeWalker instance.
+    # @param message [String] The commit message to use.
+    # @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
+      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
+          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
+          return
+        end
+
+        Timeout.timeout(GitTreeWalker::GIT_TIMEOUT) do
+          unless repo_has_changes?(dir)
+            log 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
+      rescue StandardError => e
+        log NORMAL, "#{e.class} processing #{short_dir}: #{e.message}", :red
+        e.backtrace.join("\n").each_line { |line| log DEBUG, line, :red }
+      end
+    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)
+      # For an existing repo, diff the index against the HEAD tree.
+      head_tree = repo.head.target.tree
+      diff = head_tree.diff(repo.index)
+      !diff.deltas.empty?
+    rescue Rugged::ReferenceError # Handles a new repo with no commits yet.
+      # If there's no HEAD, any file in the index is a staged change for the first commit.
+      !repo.index.empty?
+    end
+
+    # @param dir [String] The path to the git repository.
+    # @param message [String] The commit message to use.
+    # @param short_dir [String] The shortened path to the git repository.
+    # @return [nil]
+    def commit_changes(dir, message, short_dir)
+      system('git', '-C', dir, 'add', '--all', exception: true)
+
+      repo = Rugged::Repository.new(dir)
+      return unless repo_has_staged_changes?(repo)
+
+      system('git', '-C', dir, 'commit', '-m', message, '--quiet', '--no-gpg-sign', exception: true)
+
+      # Re-initialize the repo object to get the fresh state after the commit.
+      repo = Rugged::Repository.new(dir)
+
+      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
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__ || $PROGRAM_NAME.end_with?('git-commitAll') # Corrected from git-tree-commitAll
+  begin
+    GitTree::CommitAllCommand.new(ARGV).run
+  rescue Interrupt
+    log 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
+    exit 1
+  end
+end

data/lib/commands/git_evars.rb

@@ -0,0 +1,159 @@
+require_relative '../git_tree'
+require_relative 'abstract_command'
+require_relative '../util/git_tree_walker'
+require_relative '../util/zowee_optimizer'
+
+module GitTree
+  class EvarsCommand < GitTree::AbstractCommand
+    self.allow_empty_args = true
+
+    def initialize(args = ARGV, options: {})
+      $PROGRAM_NAME = 'git-evars'
+      super
+    end
+
+    def run
+      setup
+      result = []
+      if @options[:zowee]
+        walker = GitTreeWalker.new(@args, options: @options)
+        all_paths = []
+        walker.find_and_process_repos do |dir, _|
+          all_paths << dir
+        end
+        optimizer = ZoweeOptimizer.new(walker.root_map)
+        result = optimizer.optimize(all_paths, walker.display_roots)
+      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)
+        end
+      else # Args were provided, process them as roots
+        processed_args = @args.flat_map { |arg| arg.strip.split(/\s+/) }
+        processed_args.each { |root| result.concat(process_root(root)) }
+      end
+      log_stdout result.join("\n") unless result.empty?
+    end
+
+    private
+
+    # @param path [String] The path to convert to an environment variable name.
+    # @return [String] The converted environment variable name.
+    def env_var_name(path)
+      name = path.include?('/') ? File.basename(path) : path
+      name.tr(' ', '_').tr('-', '_')
+    end
+
+    # @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
+        #{$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.
+        These environment variables point to roots of git repository trees to walk.
+        Skips directories containing a .ignore file, and all subdirectories.
+
+        Does not redefine existing environment variables; messages are written to STDERR to indicate environment variables that are not redefined.
+
+        Environment variables that point to the roots of git repository trees must have been exported, for example:
+
+          $ export work=$HOME/work
+
+        Usage: #{$PROGRAM_NAME} [OPTIONS] [ROOTS...]
+
+        Options:
+          -h, --help           Show this help message and exit.
+          -q, --quiet          Suppress normal output, only show errors.
+          -z, --zowee          Optimize variable definitions for size.
+          -v, --verbose        Increase verbosity. Can be used multiple times (e.g., -v, -vv).
+
+        ROOTS can be directory names or environment variable references enclosed within single quotes (e.g., '$work').
+        Multiple roots can be specified in a single quoted string.
+
+        Usage examples:
+        $ #{$PROGRAM_NAME}                 # Use default environment variables as roots
+        $ #{$PROGRAM_NAME} '$work $sites'  # Use specific environment variables
+      END_HELP
+      exit 1
+    end
+
+    # @param args [Array<String>] The command-line arguments.
+    # @return [Array<String>] The parsed options.
+    def parse_options(args)
+      @args = super do |opts|
+        opts.on("-z", "--zowee", "Optimize variable definitions for size.") do
+          @options[:zowee] = true
+        end
+      end
+    end
+
+    # @param root [String] The root environment variable reference (e.g., '$work').
+    # @return [Array<String>] An array of environment variable definitions.
+    def process_root(root)
+      help("Environment variable reference must start with a dollar sign ($).") unless root.start_with? '$'
+
+      base = GemSupport.expand_env(root)
+      help("Environment variable '#{root}' is undefined.") if base.nil? || base.strip.empty?
+      help("Environment variable '#{root}' points to a non-existant directory (#{base}).") unless File.exist?(base)
+      help("Environment variable '#{root}' points to a file (#{base}), not a directory.") unless Dir.exist?(base)
+
+      result = [make_env_var(env_var_name(base), GemSupport.deref_symlink(base))]
+      walker = GitTreeWalker.new([root], options: @options)
+      walker.find_and_process_repos do |dir|
+        relative_dir = dir.sub(base + '/', '')
+        result << make_env_var(env_var_name(relative_dir), "#{root}/#{relative_dir}")
+      end
+      result
+    end
+
+    # @param name [String] The name of the environment variable.
+    # @param value [String] The value of the environment variable.
+    # @return [String] The environment variable definition string.
+    def make_env_var(name, value)
+      "export #{env_var_name(name)}=#{value}"
+    end
+
+    # Find which root this dir belongs to and substitute it.
+    # @param dir [String] The directory path to process.
+    # @param roots [Array<String>] An array of root environment variable names (e.g., ['work', 'sites']).
+    # @return [String] The environment variable definition string, or nil if no root matches.
+    def make_env_var_with_substitution(dir, roots)
+      found_root_var = nil
+      found_root_path = nil
+
+      roots.each do |root_name|
+        root_path = ENV.fetch(root_name, nil)
+        next if root_path.nil? || root_path.strip.empty?
+
+        next unless dir.start_with?(root_path)
+
+        found_root_var = "$#{root_name}"
+        found_root_path = root_path
+        break
+      end
+
+      if found_root_var
+        relative_dir = dir.sub(found_root_path + '/', '')
+        make_env_var(env_var_name(relative_dir), "#{found_root_var}/#{relative_dir}")
+      else
+        # Fallback to absolute path if no root matches (should be rare).
+        make_env_var(env_var_name(dir), dir)
+      end
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__ || $PROGRAM_NAME.end_with?('git-evars')
+  begin
+    GitTree::EvarsCommand.new(ARGV).run
+  rescue Interrupt
+    log 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
+    exit! 1
+  end
+end

data/lib/commands/git_exec.rb

@@ -0,0 +1,104 @@
+require 'pathname'
+require_relative 'abstract_command'
+require_relative '../util/git_tree_walker'
+require_relative '../util/thread_pool_manager'
+require_relative '../util/command_runner'
+
+module GitTree
+  class ExecCommand < GitTree::AbstractCommand
+    attr_writer :walker, :runner
+
+    def initialize(args = ARGV, options: {})
+      $PROGRAM_NAME = 'git-exec'
+      super
+      # Allow walker and runner to be injected for testing
+      @runner = @options.delete(:runner)
+      @walker = @options.delete(:walker)
+    end
+
+    def run
+      setup
+      return help('At least one root and a command must be specified.') if @args.length < 2
+
+      @runner ||= CommandRunner.new
+      # The last argument is the command to execute, the rest are roots for the walker.
+      @walker ||= GitTreeWalker.new(@args[0..-2], options: @options)
+
+      command = @args.last
+      @walker.process do |dir, _thread_id, _walker|
+        execute_and_log(dir, command)
+      end
+    end
+
+    private
+
+    def execute_and_log(dir, command)
+      output, status = @runner.run(command, dir)
+      log_result(output, status.success?)
+    rescue StandardError => e
+      error_message = "Error: '#{e.message}' from executing '#{command}' in #{dir}"
+      log_result(error_message, false)
+    end
+
+    def log_result(output, success)
+      return if output.strip.empty?
+
+      if success
+        # Successful command output should go to STDOUT.
+        log_stdout output.strip
+      else
+        # Errors should go to STDERR.
+        log QUIET, output.strip, :red
+      end
+    end
+
+    def help(msg = nil)
+      log(QUIET, "Error: #{msg}\n", :red) if msg
+      log 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.
+        These environment variables point to roots of git repository trees to walk.
+        Skips directories containing a .ignore file, and all subdirectories.
+
+        Environment variables that point to the roots of git repository trees must have been exported, for example:
+
+          $ export work=$HOME/work
+
+        Usage: #{$PROGRAM_NAME} [OPTIONS] [ROOTS...] SHELL_COMMAND
+
+        Options:
+          -h, --help           Show this help message and exit.
+          -q, --quiet          Suppress normal output, only show errors.
+          -s, --serial         Run tasks serially in a single thread in the order specified.
+          -v, --verbose        Increase verbosity. Can be used multiple times (e.g., -v, -vv).
+
+        ROOTS can be directory names or environment variable references (e.g., '$work').
+        Multiple roots can be specified in a single quoted string.
+
+        Usage examples:
+        1) For all git repositories under $sites, display their root directories:
+           $ #{$PROGRAM_NAME} '$sites' pwd
+
+        2) For all git repositories under the current directory and $my_plugins, list the `demo/` subdirectory if it exists.
+           $ #{$PROGRAM_NAME} '. $my_plugins' 'if [ -d demo ]; then realpath demo; fi'
+
+        3) For all subdirectories of the current directory, update Gemfile.lock and install a local copy of the gem:
+           $ #{$PROGRAM_NAME} . 'bundle update && rake install'
+      END_HELP
+      exit 1
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__ || $PROGRAM_NAME.end_with?('git-exec')
+  begin
+    GitTree::ExecCommand.new(ARGV).run
+  rescue Interrupt
+    log 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
+    exit 1
+  end
+end

data/lib/commands/git_replicate.rb

@@ -0,0 +1,91 @@
+require_relative '../git_tree'
+require_relative 'abstract_command'
+require_relative '../util/git_tree_walker'
+
+module GitTree
+  class ReplicateCommand < GitTree::AbstractCommand
+    self.allow_empty_args = true
+
+    def initialize(args = ARGV, options: {})
+      $PROGRAM_NAME = 'git-replicate'
+      super
+    end
+
+    # @return [nil]
+    def run
+      setup
+      result = []
+      walker = GitTreeWalker.new(@args, options: @options)
+      walker.find_and_process_repos { |dir, root_arg| result << replicate_one(dir, root_arg) }
+      log_stdout result.join("\n") unless result.empty?
+    end
+
+    private
+
+    def help(msg = nil)
+      log(QUIET, "Error: #{msg}\n", :red) if msg
+      log 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.
+        The script clones the repositories and replicates any remotes.
+        Skips directories containing a .ignore file.
+
+        Options:
+          -h, --help           Show this help message and exit.
+          -q, --quiet          Suppress normal output, only show errors.
+          -v, --verbose        Increase verbosity. Can be used multiple times (e.g., -v, -vv).
+
+        Usage: #{$PROGRAM_NAME} [OPTIONS] [ROOTS...]
+
+        ROOTS can be directory names or environment variable references (e.g., '$work').
+        Multiple roots can be specified in a single quoted string.
+
+        Usage examples:
+        $ #{$PROGRAM_NAME} '$work'
+        $ #{$PROGRAM_NAME} '$work $sites'
+      END_HELP
+      exit! 1
+    end
+
+    def replicate_one(dir, root_arg)
+      output = []
+      config_path = File.join(dir, '.git', 'config')
+      return output unless File.exist?(config_path)
+
+      config = Rugged::Config.new(config_path)
+      origin_url = config['remote.origin.url']
+      return output unless origin_url
+
+      base_path = File.expand_path(ENV.fetch(root_arg.tr("'$", ''), ''))
+      relative_dir = dir.sub(base_path + '/', '')
+
+      output << "if [ ! -d \"#{relative_dir}/.git\" ]; then"
+      output << "  mkdir -p '#{File.dirname(relative_dir)}'"
+      output << "  pushd '#{File.dirname(relative_dir)}' > /dev/null"
+      output << "  git clone '#{origin_url}' '#{File.basename(relative_dir)}'"
+      config.each_key do |key|
+        next unless key.start_with?('remote.') && key.end_with?('.url')
+
+        remote_name = key.split('.')[1]
+        next if remote_name == 'origin'
+
+        output << "  git remote add #{remote_name} '#{config[key]}'"
+      end
+      output << '  popd > /dev/null'
+      output << 'fi'
+      output
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__ || $PROGRAM_NAME.end_with?('git-replicate') # Corrected from git-tree-replicate
+  begin
+    GitTree::ReplicateCommand.new(ARGV).run
+  rescue Interrupt
+    log 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
+    exit! 1
+  end
+end