Add directory collapsing feature

- Closes: #16

Author: wteuber

CHANGELOG.md

@@ -6,6 +6,13 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+
+### Added
+- Directory collapsing feature with `-c, --collapse` option
+  - Collapses consecutive single-child directories into a single line
+  - Improves readability for deeply nested structures like Java packages
+  - Example: `domains/foo/bar/module/Service.java` instead of separate lines
+
 ### Fixed
 - Fixed indentation alignment issue when using custom indent values
   - Tree drawing characters now properly align with specified indentation

README.md

@@ -31,6 +31,7 @@ git tree
 ## Options
 ```
 -i, --indent INDENT    Set indentation (2-10 spaces)
+-c, --collapse         Collapse directories containing only another directory
 -v, --version          Show version
 -h, --help             Show help message
 ```
@@ -74,6 +75,20 @@ git tree
 ├── DELETEME.txt (D+)
 └── README.md (M)
 
+# Example with --collapse option for deeply nested structures
+mkdir -p domains/foo/bar/module/api/src/main/java/com/company/service
+echo "Service.java" > domains/foo/bar/module/api/src/main/java/com/company/service/Service.java
+git add domains
+git tree --collapse
+.
+├── domains/foo/bar/module/api/src/main/java/com/company/service/Service.java (A+)
+├── lib/version.rb -> git_tree_version.rb (R+)
+├── test/node/test_node_class.rb -> test/node_class_test.rb (R+)
+├── test/staged.txt (A+)
+├── test/untracked.txt (?)
+├── DELETEME.txt (D+)
+└── README.md (M)
+
 # reset repo
 git reset HEAD --hard
 git clean -xdf

bin/git-status-tree

@@ -14,6 +14,10 @@ parser = OptionParser.new do |opts|
     options[:indent] = indent
   end
 
+  opts.on('-c', '--collapse', 'Collapse directories containing only another directory') do
+    options[:collapse] = true
+  end
+
   opts.on('-v', '--version', 'Show version') do
     puts "git-status-tree #{GitStatusTree::VERSION}"
     exit 0

lib/node.rb

@@ -1,19 +1,24 @@
 # frozen_string_literal: true
 
+require_relative 'node_collapsing'
+
 class NodeNameError < StandardError; end
 class NodeChildrenError < StandardError; end
 class NodeTypeError < StandardError; end
 
 # A Node represents a file or directory in the git-status-tree
 class Node
+  include NodeCollapsing
+
   class << self
-    attr_accessor :indent
+    attr_accessor :indent, :collapse_dirs
   end
 
   attr_accessor :status, :name, :children
 
   def initialize(name, children = nil, status = nil)
     self.class.indent ||= 4
+    self.class.collapse_dirs ||= false
     validate_name!(name)
 
     msg = '"children" must be a NodesCollection or nil.'
@@ -152,10 +157,15 @@ def to_tree_s(depth = 0, open_parents = [0], last: true)
 
     pre = pre_tree(depth, open_parents, last)
 
-    str_tree = "#{pre}#{color_name}\n"
-    str_tree += children.to_tree_s(depth + 1, open_parents) if children
-
-    str_tree
+    # Handle directory collapsing if enabled
+    if self.class.collapse_dirs && collapsible?
+      render_collapsed_tree(pre, depth, open_parents)
+    else
+      # Normal rendering
+      str_tree = "#{pre}#{color_name}\n"
+      str_tree += children.to_tree_s(depth + 1, open_parents) if children
+      str_tree
+    end
   end
 
   def modified? = status.include?('M')
@@ -222,7 +232,7 @@ def pre_tree(depth, open_parents, last)
   def build_pre_array(depth, open_parents)
     spaces = ' ' * self.class.indent
     pre_ary = Array.new(depth).fill(spaces)
-      indent = self.class.indent - 2
+    indent = self.class.indent - 2
 
     open_parents.each do |idx|
       pre_ary[idx] = "│#{' ' * indent} " if pre_ary[idx] == spaces

lib/node_collapsing.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+# Module for directory collapsing functionality
+module NodeCollapsing
+  # Check if this directory can be collapsed (only contains one child, either file or directory)
+  def collapsible?
+    return false unless dir?
+    return false unless children && children.nodes.length == 1
+    return false if name == '.' # Never collapse the root node
+
+    true
+  end
+
+  # Get the collapsed path for display
+  def collapsed_path
+    return name unless collapsible?
+
+    path_parts = [name]
+    build_collapsed_path_parts(path_parts)
+    path_parts.join('/')
+  end
+
+  # Get the deepest node in a collapsible chain
+  def deepest_collapsible_node
+    current = self
+
+    current = current.children.nodes.first while current.collapsible? && current.children.nodes.first.dir?
+
+    current
+  end
+
+  # Check if this is a collapsed path ending with a file
+  def collapsed_with_file?
+    return false unless collapsible?
+
+    deepest = deepest_collapsible_node
+    deepest.children && deepest.children.nodes.length == 1 && deepest.children.nodes.first.file?
+  end
+
+  private
+
+  def build_collapsed_path_parts(path_parts)
+    current = self
+
+    # Traverse through collapsible directories
+    while current.collapsible? && current.children.nodes.first.dir?
+      child = current.children.nodes.first
+      path_parts << child.name
+      current = child
+    end
+
+    # Add file if the last child is a file
+    append_file_to_path(current, path_parts)
+  end
+
+  def append_file_to_path(node, path_parts)
+    return unless node.children && node.children.nodes.length == 1
+
+    child = node.children.nodes.first
+    path_parts << child.name if child.file?
+  end
+
+  def render_collapsed_tree(pre, depth, open_parents)
+    display_name = collapsed_path
+
+    if collapsed_with_file?
+      render_collapsed_file(pre, display_name)
+    else
+      render_collapsed_directory(pre, display_name, depth, open_parents)
+    end
+  end
+
+  def render_collapsed_file(pre, display_name)
+    deepest = deepest_collapsible_node
+    file_node = deepest.children.nodes.first
+    "#{pre}#{color_collapsed_file(display_name, file_node.status)}\n"
+  end
+
+  def render_collapsed_directory(pre, display_name, depth, open_parents)
+    str_tree = "#{pre}#{color_collapsed_name(display_name)}\n"
+    deepest = deepest_collapsible_node
+    # Only render children if they exist and have nodes
+    str_tree += deepest.children.to_tree_s(depth + 1, open_parents) if deepest.children&.nodes&.any?
+    str_tree
+  end
+
+  def color_collapsed_name(display_name)
+    BashColor::EMB + display_name + BashColor::NONE
+  end
+
+  def color_collapsed_file(display_path, status)
+    # Split the path to separate directories from the file
+    parts = display_path.split('/')
+    file_name = parts.pop
+    dir_path = parts.join('/')
+
+    if dir_path.empty?
+      # No directories, just the file
+      color_file_with_status(file_name, status)
+    else
+      # Directories in blue, file colored by status
+      "#{BashColor::EMB}#{dir_path}/#{BashColor::NONE}#{color_file_with_status(file_name, status)}"
+    end
+  end
+
+  def color_file_with_status(file_name, status)
+    color = status.include?('+') ? BashColor::G : BashColor::R
+    "#{color}#{file_name} (#{status})#{BashColor::NONE}"
+  end
+end

src/git_status_tree.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require File.join File.dirname(__FILE__), '../lib/node'
+require File.join File.dirname(__FILE__), '../lib/node_collapsing'
 require File.join File.dirname(__FILE__), '../lib/nodes_collection'
 require File.join File.dirname(__FILE__), '../lib/bash_color'
 require File.join File.dirname(__FILE__), '../lib/version'
@@ -11,6 +12,7 @@ class GitStatusTree
 
   def initialize(options = {})
     Node.indent = indent(options)
+    Node.collapse_dirs = options[:collapse] || false
     @files = `git status --porcelain`.split("\n")
     @nodes = files.map { |file| Node.create_from_string file }
     @tree = nodes.reduce { |a, i| (a + i).nodes[0] }

test/integration/test_command_line_collapse.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'tempfile'
+require 'tmpdir'
+
+class TestCommandLineCollapse < Test::Unit::TestCase
+  def setup
+    @original_dir = Dir.pwd
+    @test_dir = Dir.mktmpdir
+    Dir.chdir(@test_dir)
+    system('git init', out: File::NULL, err: File::NULL)
+  end
+
+  def teardown
+    Dir.chdir(@original_dir)
+    FileUtils.rm_rf(@test_dir)
+  end
+
+  def test_collapse_option_with_deeply_nested_structure
+    # Create deeply nested structure
+    FileUtils.mkdir_p('domains/foo/bar/module/module-api/src/main/java/com/company/api')
+    FileUtils.mkdir_p('domains/foo/bar/module/module-impl/src/main/java/com/company/impl')
+
+    File.write('domains/foo/bar/module/module-api/src/main/java/com/company/api/Service.java',
+               'public class Service {}')
+    File.write('domains/foo/bar/module/module-impl/src/main/java/com/company/impl/ServiceImpl.java',
+               'public class ServiceImpl {}')
+
+    system('git add .')
+
+    # Test without collapse
+    output_normal = `#{File.join(__dir__, '../../bin/git-status-tree')}`
+    assert_match(/^\e\[1;34m\.\e\[0m$/, output_normal) # Root node with color codes
+    assert_match(/└── \e\[1;34mdomains\e\[0m$/, output_normal)
+    assert_match(/└── \e\[1;34mfoo\e\[0m$/, output_normal)
+    assert_match(/└── \e\[1;34mbar\e\[0m$/, output_normal)
+    assert_match(/└── \e\[1;34mmodule\e\[0m$/, output_normal)
+
+    # Test with collapse
+    output_collapsed = `#{File.join(__dir__, '../../bin/git-status-tree')} --collapse`
+    assert_match(/^\e\[1;34m\.\e\[0m$/, output_collapsed) # Root node with color codes
+    assert_match(%r{└── \e\[1;34mdomains/foo/bar/module\e\[0m$}, output_collapsed)
+    # Now the files are included in the collapsed path
+    assert_match(
+      %r{├── \e\[1;34mmodule-api/src/main/java/com/company/api/\e\[0m\e\[0;32mService\.java \(A\+\)\e\[0m},
+      output_collapsed
+    )
+    assert_match(
+      %r{└── \e\[1;34mmodule-impl/src/main/java/com/company/impl/\e\[0m\e\[0;32mServiceImpl\.java \(A\+\)\e\[0m},
+      output_collapsed
+    )
+  end
+
+  def test_collapse_short_option
+    FileUtils.mkdir_p('a/b/c')
+    File.write('a/b/c/file.txt', 'content')
+    system('git add .')
+
+    output = `#{File.join(__dir__, '../../bin/git-status-tree')} -c`
+    # Should show root node and collapsed path
+    assert_match(/^\e\[1;34m\.\e\[0m$/, output)
+    assert_match(%r{└── \e\[1;34ma/b/c/\e\[0m\e\[0;32mfile\.txt \(A\+\)\e\[0m}, output)
+  end
+
+  def test_collapse_with_mixed_content
+    # Directory that should not collapse (has files and subdirs)
+    FileUtils.mkdir_p('src/main')
+    File.write('src/file.txt', 'content')
+    File.write('src/main/Main.java', 'public class Main {}')
+
+    # Directory that should collapse
+    FileUtils.mkdir_p('test/unit/java/com/company')
+    File.write('test/unit/java/com/company/Test.java', 'public class Test {}')
+
+    system('git add .')
+
+    output = `#{File.join(__dir__, '../../bin/git-status-tree')} --collapse`
+
+    # Should show root node
+    assert_match(/^\e\[1;34m\.\e\[0m$/, output)
+
+    # src should not be collapsed because it contains both files and directories
+    assert_match(/├── \e\[1;34msrc\e\[0m$/, output)
+    assert_match(%r{│\s+├── \e\[1;34mmain/\e\[0m\e\[0;32mMain\.java}, output)
+    assert_match(/│\s+└── \e\[0;32mfile\.txt/, output)
+
+    # test should be collapsed, and now includes the file
+    assert_match(%r{└── \e\[1;34mtest/unit/java/com/company/\e\[0m\e\[0;32mTest\.java \(A\+\)\e\[0m}, output)
+  end
+
+  def test_collapse_with_single_file_in_directory
+    # Create structure similar to test/node/test_node_class.rb
+    FileUtils.mkdir_p('test/node')
+    File.write('test/node/test_node_class.rb', 'class TestNodeClass; end')
+    system('git add .')
+
+    output = `#{File.join(__dir__, '../../bin/git-status-tree')} --collapse`
+    # Should show root node
+    assert_match(/^\e\[1;34m\.\e\[0m$/, output)
+    # The entire path including the file should be collapsed
+    assert_match(%r{└── \e\[1;34mtest/node/\e\[0m\e\[0;32mtest_node_class\.rb \(A\+\)\e\[0m}, output)
+  end
+end