git-status-tree 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4fdc77cb8d05dbec437b7ca6aaaf46bff71d2d35fa6ca2c1435c40fa1871f0d6
+  data.tar.gz: cfe0d6434eacb99525c1116668a6f251ef23b50253b45bdf413837dffbf609c4
+SHA512:
+  metadata.gz: 4f15db6fa9f6bf045faeac4f86c4f5131f0323f5771182d2d1f81fcde6cf068176cf47a8d71a2f9df3a050137b64b99788a5d24f3554fab014b51a0edc311344
+  data.tar.gz: 5f61fbea0eaf0fc67fb82fc69421aac9c3faf498759e621b54298e1fffd560e91f5cdce7539bfca151b155b4b09bead7f8cfe629434613c9d35037cdfdde52dc

data/bin/git-status-tree

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require File.join File.dirname(__FILE__), '../src/git-status-tree'
+
+puts GitStatusTree.new.to_s

data/bin/git_add_alias_tree

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+pushd `dirname $0` > /dev/null
+BIN_DIR=`pwd`
+popd > /dev/null
+
+git config --global status-tree.indent 4
+git config --global alias.tree "!sh -c \"$BIN_DIR/git-status-tree\""
+echo '#############################'
+echo '# "git tree" has been added #'
+echo '# Run: git tree             #'
+echo '#############################'

data/bin/git_remove_alias_tree

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+git config --global --unset alias.tree
+git config --global --remove-section status-tree
+echo '###############################'
+echo '# "git tree" has been removed #'
+echo '###############################'

data/ext/git_tree/Makefile

@@ -0,0 +1,4 @@
+all:
+	true
+install:
+	true

data/ext/git_tree/extconf.rb

@@ -0,0 +1,15 @@
+require 'mkmf'
+
+find_executable('bash')
+find_executable('git')
+find_executable('make')
+
+# Trick Rubygems into thinking the generated Makefile was executed
+compile = File.join(Dir.pwd, 'git_tree.' + RbConfig::CONFIG['DLEXT'])
+File.open(compile, "w") {}
+
+# Install "git tree"
+puts `../../bin/git_add_alias_tree`
+
+# Trick Rubygems into thinking the Makefile was executed
+$makefile_created = true

data/lib/bash_color.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+module BashColor
+  NONE = "\033[0m"
+
+  K = "\033[0;30m"  # black
+  R = "\033[0;31m"  # red
+  G = "\033[0;32m"  # green
+  Y = "\033[0;33m"  # yellow
+  B = "\033[0;34m"  # blue
+  M = "\033[0;35m"  # magenta
+  C = "\033[0;36m"  # cyan
+  W = "\033[0;37m"  # white
+
+  # emphasized (bolded) colors
+  EMK = "\033[1;30m"
+  EMR = "\033[1;31m"
+  EMG = "\033[1;32m"
+  EMY = "\033[1;33m"
+  EMB = "\033[1;34m"
+  EMM = "\033[1;35m"
+  EMC = "\033[1;36m"
+  EMW = "\033[1;37m"
+
+  # background colors
+  BGK = "\033[40m"
+  BGR = "\033[41m"
+  BGG = "\033[42m"
+  BGY = "\033[43m"
+  BGB = "\033[44m"
+  BGM = "\033[45m"
+  BGC = "\033[46m"
+  BGW = "\033[47m"
+end

data/lib/node.rb

@@ -0,0 +1,208 @@
+# encoding: utf-8
+
+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
+  class << self
+    attr_accessor :indent
+  end
+
+  attr_accessor :status, :name, :children
+
+  def initialize(name, children = nil, status = nil)
+    self.class.indent ||= 4
+    msg = '"name" must be a String.'
+    raise NodeNameError, msg unless name.is_a? String
+    msg = '"name" must have at least one character.'
+    raise NodeNameError, msg if name.empty?
+    msg = '"name" must not contain "/", use create_from_string.'
+    raise NodeNameError, msg if name =~ /\//
+    msg = '"children" must be a NodesCollection or nil.'
+    valid_nodes_collection = children.nil? || children.is_a?(NodesCollection)
+    raise NodeChildrenError, msg unless valid_nodes_collection
+
+    @name = name
+    @children = children
+    @status = status || []
+  end
+
+  def self.create_from_string(gs_porcelain)
+    msg = '"str_node" must be String.'
+    raise NodeTypeError, msg unless gs_porcelain.is_a? String
+    raise NodeNameError, '"str_node" too short.' if gs_porcelain.length < 4
+    status = if gs_porcelain[1..1] == ' '
+               gs_porcelain[0..0] + '+'
+             else
+               gs_porcelain[1..1]
+             end
+    path = './' + gs_porcelain[3..-1]
+    ary_nodes = path.split(/\//)
+    name = ary_nodes.shift
+
+    if ary_nodes.any?
+      children = NodesCollection.create_from_array(ary_nodes, status)
+      node = self.new(name, children)
+    else
+      node = self.new(name, nil, status)
+    end
+
+    node
+  end
+
+  def self.instances?
+    lambda { |node| node.is_a?(Node) }
+  end
+
+  def to_primitive
+    if dir?
+      {name => children.to_primitive}
+    else
+      name
+    end
+  end
+
+  def file?
+    children.nil?
+  end
+
+  def dir?
+    !file?
+  end
+
+  def valid?
+    return valid_dir? if dir?
+    return valid_file? if file?
+    false
+  end
+
+  # @return [NodesCollection]
+  def +(other)
+    raise 'not valid' unless self.valid? && other.valid?
+    raise 'not a ' + self.class.to_s unless other.is_a?(self.class)
+
+    tmp_children = [self.children, other.children].compact.inject(&:+)
+
+    NodesCollection.new([self.class.new(self.name, tmp_children)])
+  end
+
+  def <=>(other)
+    return (self.name <=> other.name) if self.file? == other.file?
+    return -1 if (self.dir? && other.file?)
+    return 1 if (self.file? && other.dir?)
+    0
+  end
+
+  def to_tree_s(depth = 0, open_parents = [0], last = true)
+    open_parents << depth
+
+    pre = pre_tree(depth, open_parents, last)
+
+    color_name = ''
+    if dir?
+      color_name += BashColor::EMB + name
+    else #file?
+      if staged?
+        color_name += BashColor::G
+      else
+        color_name += BashColor::R
+      end
+      color_name += name + ' (' + status + ')'
+    end
+    color_name +=  BashColor::NONE
+
+
+    str_tree = pre + color_name + "\n"
+    str_tree << children.to_tree_s(depth + 1, open_parents) if children
+
+    str_tree
+  end
+
+  #   'M'  modified
+  def modified?
+    self.status.include?('M')
+  end
+
+  #   'A'  added
+  def added?
+    self.status.include?('A')
+  end
+
+  #   'D'  deleted
+  def deleted?
+    self.status.include?('D')
+  end
+
+  #   'R'  renamed
+  def renamed?
+    self.status.include?('R')
+  end
+
+  #   'C'  copied
+  def copied?
+    self.status.include?('C')
+  end
+
+  #   'U'  updated but unmerged
+  def unmerged?
+    self.status.include?('U')
+  end
+
+  #   '?' new
+  def new?
+    self.status.include?('?')
+  end
+
+  #   '+' staged
+  def staged?
+    self.status.include?('+')
+  end
+
+  private
+  # Has a valid name?
+  def name_valid?
+    name &&
+      name.is_a?(String) &&
+      (name.length > 0) &&
+      name.match(/\//).nil?
+  end
+
+  # Is a valid dir?
+  def valid_dir?
+    name_valid? &&
+      children.is_a?(NodesCollection) &&
+      children.valid?
+  end
+
+  # Is a valid file?
+  def valid_file?
+    name_valid? &&
+      children.nil?
+  end
+
+  def pre_tree(depth, open_parents, last)
+    if depth == 0
+      ''
+    elsif depth > 0
+      pre_ary = Array.new(depth).fill('    ')
+
+      indent = self.class.indent - 2
+      open_parents.each do |idx|
+        pre_ary[idx] = '│' + (' ' * indent) + ' ' if pre_ary[idx] == '    '
+      end
+
+      if last
+        pre_ary[-1] = '└'
+        open_parents.delete(depth-1)
+      else
+        pre_ary[-1] = '├'
+      end
+      pre_ary[-1] += ('─' * indent) + ' '
+
+
+      pre_ary * ''
+    end
+  end
+end

data/lib/nodes_collection.rb

@@ -0,0 +1,179 @@
+# encoding: utf-8
+
+# error class for invalid NodeCollection types
+class NodesCollectionTypeError < StandardError;
+end
+
+# collection of nodes
+class NodesCollection
+  attr_accessor :nodes
+
+  def self.create_from_string(str_nodes, status = '   ')
+    msg = '"str_nodes" must be String.'
+    raise NodesCollectionTypeError, msg unless str_nodes.is_a? String
+
+    ary_nodes = str_nodes.split(/\//)
+    create_from_valid_array(ary_nodes, status)
+  end
+
+  def self.create_from_array(ary_nodes, status)
+    ary_nodes = [ary_nodes].flatten(1)
+
+    msg = '"ary_nodes" must only contain Strings.'
+    are_strings = lambda { |node| node.is_a?(String) }
+    raise NodesCollectionTypeError, msg unless ary_nodes.all? &are_strings
+
+    create_from_valid_array(ary_nodes, status)
+  end
+
+  def self.new_from_nodes_array(nodes)
+    raise msg unless nodes.all? &Node.instances?
+
+    all_nodes = nodes.group_by(&:name)
+
+    plain_nodes = []
+    all_nodes.each { |_, nodes| plain_nodes << nodes if nodes.length == 1 }
+    plain_nodes.flatten!(1)
+
+    merged_nodes = []
+    all_nodes.each do |_, nodes|
+      if nodes.length == 2
+        merged_nodes << (nodes[0] + nodes[1]).nodes[0]
+      end
+    end
+
+    self.new(plain_nodes + merged_nodes)
+  end
+
+  def self.create_from_valid_array(ary_nodes, status)
+    name = ary_nodes.shift
+    node = if ary_nodes.any?
+             children = create_from_valid_array(ary_nodes, status)
+             Node.new(name, children)
+           else
+             Node.new(name, nil, status)
+           end
+    self.new([node])
+  end
+
+  private_class_method :create_from_valid_array
+
+  def initialize(nodes = [])
+    nodes = [nodes].flatten(1)
+
+    msg = '"nodes" must only contain Nodes.'
+    are_nodes = lambda { |node| node.is_a?(Node) }
+    raise NodesCollectionTypeError, msg unless nodes.all? &are_nodes
+    @nodes = nodes
+  end
+
+  # @return [NodesCollection]
+  def +(other)
+    unless other.is_a?(Node) || other.is_a?(self.class)
+      raise 'not a Node or NodesCollection'
+    end
+
+    all_nodes = merge_nodes_with other
+    all_dirs = all_nodes.select(&:dir?)
+    all_files = all_nodes.select(&:file?)
+
+    dirs_collection = self.class.new_from_nodes_array all_dirs
+    files_collection = self.class.new all_files
+
+
+    dir_nodes = dirs_collection.sort!
+    file_nodes = files_collection.sort!
+
+    self.class.new(dir_nodes + file_nodes)
+  end
+
+  # @return [Integer]
+  def <=>(other)
+    self.to_primitive <=> other.to_primitive
+  end
+
+  # @return [Array<Node>]
+  def nodes_not_in(other)
+    self_names = self.nodes.map(&:name)
+    other_names = other.nodes.map(&:name)
+
+    self_only_names = self_names - (self_names & other_names)
+
+    self.nodes.select { |node| self_only_names.include?(node.name) }
+  end
+
+  # @return [Array<Node>]
+  def merge_common_nodes_with(other)
+    self_names = self.nodes.map(&:name)
+    other_names = other.nodes.map(&:name)
+
+    common_names = self_names & other_names
+    all_nodes = self.nodes + other.nodes
+
+    common_names.map do |name|
+      all_nodes.select { |node| node.name == name }.reduce(&:+).nodes[0]
+    end
+  end
+
+  # @return [Array<Node>]
+  def merge_nodes_with(other)
+    if other.is_a? Node
+      if self.nodes.map(&:name).include?(other.name)
+        equal_names = lambda { |node| node.name == other.name }
+        collection_merged = self.nodes.select(&equal_names)[0] + other
+        other = collection_merged.nodes[0]
+      end
+
+      nodes_merged = self.nodes + [other]
+    elsif other.is_a? NodesCollection
+      self_dedicated_nodes = self.nodes_not_in other
+      other_dedicated_nodes = other.nodes_not_in self
+      common_nodes = self.merge_common_nodes_with other
+
+      nodes_merged = self_dedicated_nodes + common_nodes + other_dedicated_nodes
+    end
+
+    nodes_merged
+  end
+
+  def files
+    nodes.select(&:file?)
+  end
+
+  def dirs
+    nodes.select(&:dir?)
+  end
+
+  def sort!
+    nodes.sort!
+  end
+
+  def to_primitive
+    nodes.map(&:to_primitive)
+  end
+
+  def valid?
+    nodes &&
+        nodes.is_a?(Array) &&
+        nodes.all? { |node| node.is_a?(Node) } &&
+        nodes.all?(&:valid?)
+    #TODO compare uniqueness of file and dir names.
+  end
+
+  def to_tree_s(depth = 0, open_parents = [])
+    tree_s = ''
+
+    if nodes.length > 1
+      to_tree_s = lambda { |node| node.to_tree_s(depth, open_parents, false) }
+      tree_s << nodes[0..-2].map(&to_tree_s) * ''
+    end
+    tree_s << nodes.last.to_tree_s(depth, open_parents)
+
+    tree_s
+  end
+
+  private
+  def add_node(other)
+  end
+
+end

data/lib/rubygems_plugin.rb

@@ -0,0 +1,5 @@
+Gem.pre_uninstall do |uninstaller|
+  bin_dir = uninstaller.spec.bin_dir
+  git_remove_alias_tree = File.join(bin_dir, 'git_remove_alias_tree')
+  puts `#{git_remove_alias_tree}`
+end

data/src/git-status-tree.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require File.join File.dirname(__FILE__), '../lib/node'
+require File.join File.dirname(__FILE__), '../lib/nodes_collection'
+require File.join File.dirname(__FILE__), '../lib/bash_color'
+require File.join File.dirname(__FILE__), '../src/git_status_tree'
+
+# GIT STATUS
+#   ' '  unmodified
+#   'M'  modified
+#   'A'  added
+#   'D'  deleted
+#   'R'  renamed
+#   'C'  copied
+#   'U'  updated but unmerged
+#   '??' new

data/src/git_status_tree.rb

@@ -0,0 +1,25 @@
+# GitStatusTree
+# use GitStatusTree.new.to_s to print the current git-status-tree
+class GitStatusTree
+  attr_reader :files, :nodes, :tree
+
+  def initialize(options = {})
+    config = %x(git config --global status-tree.indent).strip
+    config = (config =~ /\A\d+\z/) ? config.to_i : nil
+    indent = options[:indent] || config || 4
+    indent = 2 if indent < 2
+    indent = 10 if indent > 10
+    Node.indent = indent
+    @files = (%x(git status --porcelain)).split(/\n/)
+    @nodes = files.map{|file| Node.create_from_string file}
+    @tree = nodes.reduce{|a, i| (a+i).nodes[0]}
+  end
+
+  def to_s
+    if tree.nil?
+      '(working directory clean)'
+    else
+      tree.to_tree_s
+    end
+  end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: git-status-tree
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Wolfgang Teuber
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-09-28 00:00:00.000000000 Z
+dependencies: []
+description: git-status-tree is a command line tool that shows git repository changes
+  in a file tree.
+email: knugie@gmx.net
+executables:
+- git-status-tree
+extensions:
+- ext/git_tree/extconf.rb
+extra_rdoc_files: []
+files:
+- bin/git-status-tree
+- bin/git_add_alias_tree
+- bin/git_remove_alias_tree
+- ext/git_tree/Makefile
+- ext/git_tree/extconf.rb
+- lib/bash_color.rb
+- lib/node.rb
+- lib/nodes_collection.rb
+- lib/rubygems_plugin.rb
+- src/git-status-tree.rb
+- src/git_status_tree.rb
+homepage: https://github.com/knugie/git-status-tree
+licenses:
+- MIT
+- GPL-2.0
+metadata:
+  source_code_uri: https://github.com/knugie/git-status-tree
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: git status in file tree format
+test_files: []