├── .gitignore
├── .github
    └── workflows
    │   ├── crates-io.yml
    │   ├── tests.yml
    │   └── release.yml
├── Justfile
├── src
    ├── lib.rs
    ├── print
    │   ├── colors.rs
    │   ├── mod.rs
    │   ├── svg.rs
    │   └── format.rs
    ├── config.rs
    ├── settings.rs
    ├── main.rs
    └── graph.rs
├── LICENSE
├── Cargo.toml
├── docs
    ├── branch_assignment.md
    └── manual.md
├── README.md
└── Cargo.lock


/.gitignore:
--------------------------------------------------------------------------------
1 | /target
2 | *.iml
3 | /.idea/
4 | 


--------------------------------------------------------------------------------
/.github/workflows/crates-io.yml:
--------------------------------------------------------------------------------
 1 | name: Crates.io
 2 | 
 3 | on:
 4 |   release:
 5 |     types: [ created ]
 6 | 
 7 | env:
 8 |   CARGO_TERM_COLOR: always
 9 | 
10 | jobs:
11 |   publish:
12 |     name: Publish to crates.io
13 |     runs-on: ubuntu-latest
14 |     steps:
15 |       - name: Checkout
16 |         uses: actions/checkout@v2
17 |       - name: Install Rust
18 |         uses: actions-rs/toolchain@v1
19 |         with:
20 |           toolchain: stable
21 |           override: true
22 |       - name: Publish binaries
23 |         uses: katyo/publish-crates@v1
24 |         with:
25 |           registry-token: ${{ secrets.CRATES_IO_TOKEN }}
26 | 


--------------------------------------------------------------------------------
/Justfile:
--------------------------------------------------------------------------------
 1 | _default:
 2 |     @just --choose
 3 | 
 4 | # Shows a list of all available recipes
 5 | help:
 6 |     @just --list
 7 | 
 8 | green := '\033[0;32m'
 9 | red := '\033[0;31m'
10 | reset := '\033[0m'
11 | 
12 | # Checks if all requirements to work on this project are installed
13 | check-requirements:
14 |     @command -v cargo &>/dev/null && echo -e "{{ green }}✓{{ reset}} cargo installed" || echo -e "{{ red }}✖{{ reset }} cargo missing"
15 | 
16 | # Runs the same linters as the pipeline with fix option
17 | lint:
18 |     cargo fmt --all # Is in fix mode by default
19 |     cargo clippy --all --all-targets --allow-dirty --fix
20 | 
21 | # Runs the same test as the pipeline but locally
22 | test:
23 |     cargo test --all
24 | 
25 | 


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
 1 | //! git-graph shows clear git graphs arranged for your branching model.
 2 | //!
 3 | //! It provides both a library and a command line tool.
 4 | //!
 5 | //! The main steps are:
 6 | //! 1. Read branching model configuration (See [config] and [settings])
 7 | //! 2. Lay out the graph structure according to the branching model (See [graph])
 8 | //! 3. Render the layout to text or SVG (See [mod@print])
 9 | 
10 | // Configure clippy to look for complex functions
11 | #![warn(clippy::cognitive_complexity)]
12 | #![warn(clippy::too_many_lines)]
13 | 
14 | use git2::Repository;
15 | use std::path::Path;
16 | 
17 | pub mod config;
18 | pub mod graph;
19 | pub mod print;
20 | pub mod settings;
21 | 
22 | pub fn get_repo<P: AsRef<Path>>(
23 |     path: P,
24 |     skip_repo_owner_validation: bool,
25 | ) -> Result<Repository, git2::Error> {
26 |     if skip_repo_owner_validation {
27 |         unsafe { git2::opts::set_verify_owner_validation(false)? }
28 |     }
29 |     Repository::discover(path)
30 | }
31 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2020 Martin Lange
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "git-graph"
 3 | version = "0.7.0"
 4 | authors = ["Martin Lange <martin_lange_@gmx.net>"]
 5 | description = "Command line tool to show clear git graphs arranged for your branching model"
 6 | repository = "https://github.com/mlange-42/git-graph.git"
 7 | keywords = ["git", "graph"]
 8 | license = "MIT"
 9 | readme = "README.md"
10 | edition = "2021"
11 | rust-version = "1.83.0"
12 | 
13 | [profile.release]
14 | opt-level = 3
15 | lto = true
16 | codegen-units = 1
17 | debug = false
18 | debug-assertions = false
19 | overflow-checks = false
20 | 
21 | [dependencies]
22 | git2 = {version = "0.20", default-features = false, optional = false}
23 | regex = {version = "1.7", default-features = false, optional = false, features = ["std"]}
24 | serde = "1.0"
25 | serde_derive = {version = "1.0", default-features = false, optional = false}
26 | toml = "0.9"
27 | itertools = "0.14"
28 | svg = "0.18"
29 | clap = {version = "4.0", optional = false, features = ["cargo"]}
30 | lazy_static = "1.4"
31 | yansi = "1.0"
32 | atty = "0.2"
33 | platform-dirs = "0.3"
34 | crossterm = {version = "0.29", optional = false}
35 | chrono = {version = "0.4", optional = false}
36 | textwrap = {version = "0.16", default-features = false, optional = false, features = ["unicode-width"]}
37 | 


--------------------------------------------------------------------------------
/src/print/colors.rs:
--------------------------------------------------------------------------------
 1 | //! ANSI terminal color handling.
 2 | 
 3 | use lazy_static::lazy_static;
 4 | use std::collections::HashMap;
 5 | 
 6 | /// Converts a color name to the index in the 256-color palette.
 7 | pub fn to_terminal_color(color: &str) -> Result<u8, String> {
 8 |     match NAMED_COLORS.get(color) {
 9 |         None => match color.parse::<u8>() {
10 |             Ok(col) => Ok(col),
11 |             Err(_) => Err(format!("Color {} not found", color)),
12 |         },
13 |         Some(rgb) => Ok(*rgb),
14 |     }
15 | }
16 | 
17 | macro_rules! hashmap {
18 |     ($( $key: expr => $val: expr ),*) => {{
19 |          let mut map = ::std::collections::HashMap::new();
20 |          $( map.insert($key, $val); )*
21 |          map
22 |     }}
23 | }
24 | 
25 | lazy_static! {
26 |     /// Named ANSI colors
27 |     pub static ref NAMED_COLORS: HashMap<&'static str, u8> = hashmap![
28 |         "black" => 0,
29 |         "red" => 1,
30 |         "green" => 2,
31 |         "yellow" => 3,
32 |         "blue" => 4,
33 |         "magenta" => 5,
34 |         "cyan" => 6,
35 |         "white" => 7,
36 |         "bright_black" => 8,
37 |         "bright_red" => 9,
38 |         "bright_green" => 10,
39 |         "bright_yellow" => 11,
40 |         "bright_blue" => 12,
41 |         "bright_magenta" => 13,
42 |         "bright_cyan" => 14,
43 |         "bright_white" => 15
44 |     ];
45 | }
46 | 


--------------------------------------------------------------------------------
/.github/workflows/tests.yml:
--------------------------------------------------------------------------------
 1 | name: Tests
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [ master ]
 6 |   pull_request:
 7 | 
 8 | env:
 9 |   CARGO_TERM_COLOR: always
10 | 
11 | jobs:
12 |   test:
13 |     name: Test Suite
14 |     runs-on: ubuntu-latest
15 |     steps:
16 |       - name: Checkout sources
17 |         uses: actions/checkout@v2
18 | 
19 |       - name: Install stable toolchain
20 |         uses: actions-rs/toolchain@v1
21 |         with:
22 |           profile: minimal
23 |           toolchain: stable
24 |           override: true
25 | 
26 |       - name: Run cargo test
27 |         uses: actions-rs/cargo@v1
28 |         with:
29 |           command: test
30 |           args: --all
31 | 
32 |   lints:
33 |     name: Lints
34 |     runs-on: ubuntu-latest
35 |     steps:
36 |       - name: Checkout sources
37 |         uses: actions/checkout@v2
38 | 
39 |       - name: Install stable toolchain
40 |         uses: actions-rs/toolchain@v1
41 |         with:
42 |           profile: minimal
43 |           toolchain: stable
44 |           override: true
45 |           components: rustfmt, clippy
46 | 
47 |       - name: Run cargo fmt
48 |         uses: actions-rs/cargo@v1
49 |         with:
50 |           command: fmt
51 |           args: --all -- --check
52 | 
53 |       - name: Run cargo clippy
54 |         uses: actions-rs/cargo@v1
55 |         with:
56 |           command: clippy
57 |           args: --all --all-targets -- --deny warnings
58 | 


--------------------------------------------------------------------------------
/src/print/mod.rs:
--------------------------------------------------------------------------------
 1 | //! Create visual representations of git graphs.
 2 | 
 3 | use crate::graph::GitGraph;
 4 | use std::cmp::max;
 5 | 
 6 | pub mod colors;
 7 | pub mod format;
 8 | pub mod svg;
 9 | pub mod unicode;
10 | 
11 | /// Find the index at which a between-branch connection
12 | /// has to deviate from the current branch's column.
13 | ///
14 | /// Returns the last index on the current column.
15 | fn get_deviate_index(graph: &GitGraph, index: usize, par_index: usize) -> usize {
16 |     let info = &graph.commits[index];
17 | 
18 |     let par_info = &graph.commits[par_index];
19 |     let par_branch = &graph.all_branches[par_info.branch_trace.unwrap()];
20 | 
21 |     let mut min_split_idx = index;
22 |     for sibling_oid in &par_info.children {
23 |         if let Some(&sibling_index) = graph.indices.get(sibling_oid) {
24 |             if let Some(sibling) = graph.commits.get(sibling_index) {
25 |                 if let Some(sibling_trace) = sibling.branch_trace {
26 |                     let sibling_branch = &graph.all_branches[sibling_trace];
27 |                     if sibling_oid != &info.oid
28 |                         && sibling_branch.visual.column == par_branch.visual.column
29 |                         && sibling_index > min_split_idx
30 |                     {
31 |                         min_split_idx = sibling_index;
32 |                     }
33 |                 }
34 |             }
35 |         }
36 |     }
37 | 
38 |     // TODO: in cases where no crossings occur, the rule for merge commits can also be applied to normal commits
39 |     // See also branch::trace_branch()
40 |     if info.is_merge {
41 |         max(index, min_split_idx)
42 |     } else {
43 |         (par_index as i32 - 1) as usize
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/.github/workflows/release.yml:
--------------------------------------------------------------------------------
 1 | name: Release
 2 | 
 3 | on:
 4 |   release:
 5 |     types: [created]
 6 |   push:
 7 |     branches: [master]
 8 |   pull_request:
 9 | 
10 | env:
11 |   CARGO_TERM_COLOR: always
12 |   REPO: git-graph
13 | 
14 | jobs:
15 |   release:
16 |     name: Release for ${{ matrix.os }}
17 |     runs-on: ${{ matrix.os }}
18 |     strategy:
19 |       matrix:
20 |         include:
21 |           - os: ubuntu-latest
22 |             bin_extension: ""
23 |             os_name: "linux-amd64"
24 |           - os: windows-latest
25 |             bin_extension: ".exe"
26 |             os_name: "windows-amd64"
27 |           - os: macos-latest
28 |             bin_extension: ""
29 |             os_name: "macos-amd64"
30 | 
31 |     steps:
32 |       - uses: actions/checkout@v2
33 | 
34 |       - name: Get tag or commit
35 |         run: |
36 |           if [[ "${GITHUB_REF}" == refs/tags/* ]]; then
37 |             echo "RELEASE_VERSION=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
38 |           else
39 |             SHORT_SHA=$(echo "${GITHUB_SHA}" | cut -c1-7)
40 |             echo "RELEASE_VERSION=${SHORT_SHA}" >> $GITHUB_ENV
41 |           fi
42 |         shell: bash
43 | 
44 |       - name: Build
45 |         run: |
46 |           cargo build --release
47 | 
48 |       - name: Compress
49 |         run: |
50 |           cp -f target/release/$REPO${{ matrix.bin_extension }} .
51 |           tar -czf release.tar.gz $REPO${{ matrix.bin_extension }}
52 |         shell: bash
53 | 
54 |       - name: Archive build artifacts
55 |         uses: actions/upload-artifact@v4
56 |         with:
57 |           name: ${{ env.REPO }}-${{ env.RELEASE_VERSION }}-${{ matrix.os_name }}
58 |           path: release.tar.gz
59 | 
60 |       - name: Upload binaries to release
61 |         if: github.event_name == 'release'
62 |         uses: svenstaro/upload-release-action@v2
63 |         with:
64 |           repo_token: ${{ secrets.GITHUB_TOKEN }}
65 |           file: release.tar.gz
66 |           asset_name: ${{ env.REPO }}-${{ env.RELEASE_VERSION }}-${{ matrix.os_name }}.tar.gz
67 |           tag: ${{ github.ref }}
68 | 


--------------------------------------------------------------------------------
/docs/branch_assignment.md:
--------------------------------------------------------------------------------
 1 | 
 2 | # Overview
 3 | 
 4 | To generate a graph, [GitGraph::new()] will read the repository
 5 | and assign every commit to a single branch.
 6 | 
 7 | It takes the following steps to generate the graph
 8 | 
 9 | - Identify branches
10 | - Sort branches by persistence
11 | - Trace branches to commits
12 | - Filtering and indexing
13 | 
14 | ## Identify branches
15 | Local and remote git-branches and tags are used as candidates for branches.
16 | A branch can be identified by a merge commit, even though no current git-branch
17 | refers to it.
18 | 
19 | ## Sort branches by persistence
20 | Each branch is assigned a persistence which can be configured by settings.
21 | Think of persistence as z-order where lower values take preceedence.
22 | **TODO** Merge branch
23 | 
24 | ## Trace branches to commits
25 | The branches now get to pick their commits, in order of persistence. Each
26 | branch starts with a head, and follow the primary parent while it is
27 | available. It stops when the parent is a commit already assigned to a branch.
28 | **TODO** Duplicate branch names
29 | **TODO** Handle visual artifacts on merge
30 | 
31 | ## Filtering and indexing
32 | Commits that have not been assigned a branch is filtered out.
33 | An *index_map* is created to map from original commit index, to filtered
34 | commit index.
35 | **TODO** what? why? Would it not be better to track from child/heads instead of every single commit in repo?
36 | 
37 | 
38 | 
39 | 
40 | # Branch sorting
41 | The goal of this algorithm is to assign a column number to each tracked branch so that they can be visualized linearly without overlapping in the graph. It uses a shortest-first scheduling strategy (optionally longest-first and with forward/backward start sorting).
42 | 
43 | ## Initialization
44 | - occupied: A vector of vectors of vectors of tuples. 
45 | The outer vector is indexed by the branch's order_group (determined by branch_order based on the settings.branches.order). 
46 | Each inner vector represents a column within that order group, 
47 | and the tuples (start, end) store the range of commits occupied by a branch in that column. 
48 | 
49 | ## Preparing Branches for Sorting
50 | - It creates branches_sort, a vector of tuples containing the branch index, its start commit index (range.0), its end commit index (range.1), its source order group, and its target order group. 
51 | - It filters out branches that don't have a defined range (meaning they weren't associated with any commits). 
52 | ## Sorting Branches
53 | - The branches_sort vector is sorted based on a key that prioritizes: 
54 |     1. The maximum of the source and target order groups. This likely aims to keep related branches (e.g., those involved in merges) closer together. 
55 |     2. The length of the branch's lifespan (end - start commit index), either shortest-first or longest-first based on the shortest_first setting. 
56 |     3. The starting commit index, either forward or backward based on the forward setting. 
57 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # git-graph
  2 | 
  3 | [![Tests](https://github.com/mlange-42/git-graph/actions/workflows/tests.yml/badge.svg)](https://github.com/mlange-42/git-graph/actions/workflows/tests.yml)
  4 | [![GitHub](https://img.shields.io/badge/github-repo-blue?logo=github)](https://github.com/mlange-42/git-graph)
  5 | [![Crate](https://img.shields.io/crates/v/git-graph.svg)](https://crates.io/crates/git-graph)
  6 | [![MIT license](https://img.shields.io/github/license/mlange-42/git-graph)](https://github.com/mlange-42/git-graph/blob/master/LICENSE)
  7 | 
  8 | A command line tool to visualize Git history graphs in a comprehensible way, following different branching models.
  9 | 
 10 | The image below shows an example using the [GitFlow](https://nvie.com/posts/a-successful-git-branching-model/) branching model for a comparison between graphs generated by git-graph (far left) versus other tools and Git clients. 
 11 | 
 12 | > GitFlow was chosen for its complexity, while any other branching model is supported, including user-defined ones.
 13 | 
 14 | ![Graph comparison between tools](https://user-images.githubusercontent.com/44003176/103466403-36a81780-4d45-11eb-90cc-167d210d7a52.png)
 15 | 
 16 | Decide for yourself which graph is the most comprehensible. :sunglasses:
 17 | 
 18 | If you want an **interactive Git terminal application**, see [**git-igitt**](https://github.com/mlange-42/git-igitt), which is based on git-graph.
 19 | 
 20 | ## Features
 21 | 
 22 | * View structured graphs directly in the terminal
 23 | * Pre-defined and custom branching models and coloring
 24 | * Different styles, including ASCII-only (i.e. no "special characters")
 25 | * Custom commit formatting, like with `git log --format="..."`
 26 | 
 27 | ## Installation
 28 | 
 29 | **Pre-compiled binaries**
 30 | 
 31 | 1. Download the [latest binaries](https://github.com/mlange-42/git-graph/releases) for your platform
 32 | 2. Unzip somewhere
 33 | 3. *Optional:* add directory `git-graph` to your `PATH` environmental variable
 34 | 
 35 | **Using `cargo`**
 36 | 
 37 | In case you have [Rust](https://www.rust-lang.org/) installed, you can install with `cargo`:
 38 | 
 39 | ```
 40 | cargo install git-graph
 41 | ```
 42 | 
 43 | **From `homebrew`**
 44 | 
 45 | If you use the [homebrew](https://brew.sh/) package manager:
 46 | 
 47 | ```
 48 | brew install git-graph
 49 | ```
 50 | 
 51 | ## Usage
 52 | 
 53 | **For detailed information, see the [manual](docs/manual.md)**.
 54 | 
 55 | For basic usage, run the following command inside a Git repository's folder:
 56 | 
 57 | ```
 58 | git-graph
 59 | ```
 60 | 
 61 | > Note: git-graph needs to be on the PATH, or you need use the full path to git-graph:
 62 | > 
 63 | > ```
 64 | > C:/path/to/git-graph/git-graph
 65 | > ```
 66 | 
 67 | **Branching models**
 68 | 
 69 | Run git-graph with a specific model, e.g. `simple`:
 70 | 
 71 | ```
 72 | git-graph --model simple
 73 | ```
 74 | 
 75 | Alternatively, set the model for the current repository permanently:
 76 | 
 77 | ```
 78 | git-graph model simple
 79 | ```
 80 | 
 81 | **Get help**
 82 | 
 83 | For the full CLI help describing all options, use:
 84 | 
 85 | ```
 86 | git-graph -h
 87 | git-graph --help
 88 | ```
 89 | 
 90 | For **styles** and commit **formatting**, see the [manual](docs/manual.md).
 91 | 
 92 | ## Custom branching models
 93 | 
 94 | Branching models are configured using the files in `APP_DATA/git-graph/models`. 
 95 | 
 96 | * Windows: `C:\Users\<user>\AppData\Roaming\git-graph`
 97 | * Linux: `~/.config/git-graph`
 98 | * OSX: `~/Library/Application Support/git-graph`
 99 | 
100 | File names of any `.toml` files in the `models` directory can be used in parameter `--model`, or via sub-command `model`. E.g., to use a branching model defined in `my-model.toml`, use:
101 | 
102 | ```
103 | git-graph --model my-model
104 | ```
105 | 
106 | **For details on how to create your own branching models see the manual, section [Custom branching models](docs/manual.md#custom-branching-models).**
107 | 
108 | ## Limitations
109 | 
110 | * Summaries of merge commits (i.e. 1st line of message) should not be modified! git-graph needs them to categorize merged branches.
111 | * Supports only the primary remote repository `origin`.
112 | * Does currently not support "octopus merges" (i.e. no more than 2 parents)
113 | * On Windows PowerShell, piping to file output does not work properly (changes encoding), so you may want to use the default Windows console instead
114 | 
115 | ## Contributing
116 | 
117 | Please report any issues and feature requests in the [issue tracker](https://github.com/mlange-42/git-graph/issues).
118 | 
119 | Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
120 | 


--------------------------------------------------------------------------------
/src/config.rs:
--------------------------------------------------------------------------------
  1 | //! Branching model configurations.
  2 | //!
  3 | //! In this module you will find functions to read and write branching model
  4 | //! configurations on disk.
  5 | //!
  6 | //! The [branching models][BranchSettingsDef] themselves are defined in
  7 | //! module [settings][super::settings]
  8 | 
  9 | use crate::settings::{BranchSettingsDef, RepoSettings};
 10 | use git2::Repository;
 11 | use std::ffi::OsStr;
 12 | use std::path::{Path, PathBuf};
 13 | 
 14 | /// Creates the directory `APP_DATA/git-graph/models` if it does not exist,
 15 | /// and writes the files for built-in branching models there.
 16 | pub fn create_config<P: AsRef<Path> + AsRef<OsStr>>(app_model_path: &P) -> Result<(), String> {
 17 |     let path: &Path = app_model_path.as_ref();
 18 |     if !path.exists() {
 19 |         std::fs::create_dir_all(app_model_path).map_err(|err| err.to_string())?;
 20 | 
 21 |         let models = [
 22 |             (BranchSettingsDef::git_flow(), "git-flow.toml"),
 23 |             (BranchSettingsDef::simple(), "simple.toml"),
 24 |             (BranchSettingsDef::none(), "none.toml"),
 25 |         ];
 26 |         for (model, file) in &models {
 27 |             let mut path = PathBuf::from(&app_model_path);
 28 |             path.push(file);
 29 |             let str = toml::to_string_pretty(&model).map_err(|err| err.to_string())?;
 30 |             std::fs::write(&path, str).map_err(|err| err.to_string())?;
 31 |         }
 32 |     }
 33 | 
 34 |     Ok(())
 35 | }
 36 | 
 37 | /// Get models available in `APP_DATA/git-graph/models`.
 38 | pub fn get_available_models<P: AsRef<Path>>(app_model_path: &P) -> Result<Vec<String>, String> {
 39 |     let models = std::fs::read_dir(app_model_path)
 40 |         .map_err(|err| err.to_string())?
 41 |         .filter_map(|e| match e {
 42 |             Ok(e) => {
 43 |                 if let (Some(name), Some(ext)) = (e.path().file_name(), e.path().extension()) {
 44 |                     if ext == "toml" {
 45 |                         name.to_str()
 46 |                             .map(|name| (name[..(name.len() - 5)]).to_string())
 47 |                     } else {
 48 |                         None
 49 |                     }
 50 |                 } else {
 51 |                     None
 52 |                 }
 53 |             }
 54 |             Err(_) => None,
 55 |         })
 56 |         .collect::<Vec<_>>();
 57 | 
 58 |     Ok(models)
 59 | }
 60 | 
 61 | /// Get the currently set branching model for a repo.
 62 | pub fn get_model_name(repository: &Repository, file_name: &str) -> Result<Option<String>, String> {
 63 |     let mut config_path = PathBuf::from(repository.path());
 64 |     config_path.push(file_name);
 65 | 
 66 |     if config_path.exists() {
 67 |         let repo_config: RepoSettings =
 68 |             toml::from_str(&std::fs::read_to_string(config_path).map_err(|err| err.to_string())?)
 69 |                 .map_err(|err| err.to_string())?;
 70 | 
 71 |         Ok(Some(repo_config.model))
 72 |     } else {
 73 |         Ok(None)
 74 |     }
 75 | }
 76 | 
 77 | /// Try to get the branch settings for a given model.
 78 | /// If no model name is given, returns the branch settings set for the repo, or the default otherwise.
 79 | pub fn get_model<P: AsRef<Path> + AsRef<OsStr>>(
 80 |     repository: &Repository,
 81 |     model: Option<&str>,
 82 |     repo_config_file: &str,
 83 |     app_model_path: &P,
 84 | ) -> Result<BranchSettingsDef, String> {
 85 |     match model {
 86 |         Some(model) => read_model(model, app_model_path),
 87 |         None => {
 88 |             let mut config_path = PathBuf::from(repository.path());
 89 |             config_path.push(repo_config_file);
 90 | 
 91 |             if config_path.exists() {
 92 |                 let repo_config: RepoSettings = toml::from_str(
 93 |                     &std::fs::read_to_string(config_path).map_err(|err| err.to_string())?,
 94 |                 )
 95 |                 .map_err(|err| err.to_string())?;
 96 | 
 97 |                 read_model(&repo_config.model, app_model_path)
 98 |             } else {
 99 |                 Ok(read_model("git-flow", app_model_path)
100 |                     .unwrap_or_else(|_| BranchSettingsDef::git_flow()))
101 |             }
102 |         }
103 |     }
104 | }
105 | 
106 | /// Read a branching model file.
107 | fn read_model<P: AsRef<Path> + AsRef<OsStr>>(
108 |     model: &str,
109 |     app_model_path: &P,
110 | ) -> Result<BranchSettingsDef, String> {
111 |     let mut model_file = PathBuf::from(&app_model_path);
112 |     model_file.push(format!("{}.toml", model));
113 | 
114 |     if model_file.exists() {
115 |         toml::from_str::<BranchSettingsDef>(
116 |             &std::fs::read_to_string(model_file).map_err(|err| err.to_string())?,
117 |         )
118 |         .map_err(|err| err.to_string())
119 |     } else {
120 |         let models = get_available_models(&app_model_path)?;
121 |         let path: &Path = app_model_path.as_ref();
122 |         Err(format!(
123 |             "ERROR: No branching model named '{}' found in {}\n       Available models are: {}",
124 |             model,
125 |             path.display(),
126 |             itertools::join(models, ", ")
127 |         ))
128 |     }
129 | }
130 | /// Permanently sets the branching model for a repository
131 | pub fn set_model<P: AsRef<Path>>(
132 |     repository: &Repository,
133 |     model: &str,
134 |     repo_config_file: &str,
135 |     app_model_path: &P,
136 | ) -> Result<(), String> {
137 |     let models = get_available_models(&app_model_path)?;
138 | 
139 |     if !models.contains(&model.to_string()) {
140 |         return Err(format!(
141 |             "ERROR: No branching model named '{}' found in {}\n       Available models are: {}",
142 |             model,
143 |             app_model_path.as_ref().display(),
144 |             itertools::join(models, ", ")
145 |         ));
146 |     }
147 | 
148 |     let mut config_path = PathBuf::from(repository.path());
149 |     config_path.push(repo_config_file);
150 | 
151 |     let config = RepoSettings {
152 |         model: model.to_string(),
153 |     };
154 | 
155 |     let str = toml::to_string_pretty(&config).map_err(|err| err.to_string())?;
156 |     std::fs::write(&config_path, str).map_err(|err| err.to_string())?;
157 | 
158 |     Ok(())
159 | }
160 | 


--------------------------------------------------------------------------------
/src/print/svg.rs:
--------------------------------------------------------------------------------
  1 | //! Create graphs in SVG format (Scalable Vector Graphics).
  2 | 
  3 | use crate::graph::GitGraph;
  4 | use crate::settings::Settings;
  5 | use svg::node::element::path::Data;
  6 | use svg::node::element::{Circle, Line, Path};
  7 | use svg::Document;
  8 | 
  9 | /// Creates a SVG visual representation of a graph.
 10 | pub fn print_svg(graph: &GitGraph, settings: &Settings) -> Result<String, String> {
 11 |     let mut document = Document::new();
 12 | 
 13 |     let max_idx = graph.commits.len();
 14 |     let mut max_column = 0;
 15 | 
 16 |     if settings.debug {
 17 |         for branch in &graph.all_branches {
 18 |             if let (Some(start), Some(end)) = branch.range {
 19 |                 document = document.add(bold_line(
 20 |                     start,
 21 |                     branch.visual.column.unwrap(),
 22 |                     end,
 23 |                     branch.visual.column.unwrap(),
 24 |                     "cyan",
 25 |                 ));
 26 |             }
 27 |         }
 28 |     }
 29 | 
 30 |     for (idx, info) in graph.commits.iter().enumerate() {
 31 |         if let Some(trace) = info.branch_trace {
 32 |             let branch = &graph.all_branches[trace];
 33 |             let branch_color = &branch.visual.svg_color;
 34 | 
 35 |             if branch.visual.column.unwrap() > max_column {
 36 |                 max_column = branch.visual.column.unwrap();
 37 |             }
 38 | 
 39 |             for p in 0..2 {
 40 |                 let parent = info.parents[p];
 41 |                 let Some(par_oid) = parent else {
 42 |                     continue;
 43 |                 };
 44 |                 let Some(par_idx) = graph.indices.get(&par_oid) else {
 45 |                     // Parent is outside scope of graph.indices
 46 |                     // so draw a vertical line to the bottom
 47 |                     let idx_bottom = max_idx;
 48 |                     document = document.add(line(
 49 |                         idx,
 50 |                         branch.visual.column.unwrap(),
 51 |                         idx_bottom,
 52 |                         branch.visual.column.unwrap(),
 53 |                         branch_color,
 54 |                     ));
 55 |                     continue;
 56 |                 };
 57 |                 let par_info = &graph.commits[*par_idx];
 58 |                 let par_branch = &graph.all_branches[par_info.branch_trace.unwrap()];
 59 | 
 60 |                 let color = if info.is_merge {
 61 |                     &par_branch.visual.svg_color
 62 |                 } else {
 63 |                     branch_color
 64 |                 };
 65 | 
 66 |                 if branch.visual.column == par_branch.visual.column {
 67 |                     document = document.add(line(
 68 |                         idx,
 69 |                         branch.visual.column.unwrap(),
 70 |                         *par_idx,
 71 |                         par_branch.visual.column.unwrap(),
 72 |                         color,
 73 |                     ));
 74 |                 } else {
 75 |                     let split_index = super::get_deviate_index(graph, idx, *par_idx);
 76 |                     document = document.add(path(
 77 |                         idx,
 78 |                         branch.visual.column.unwrap(),
 79 |                         *par_idx,
 80 |                         par_branch.visual.column.unwrap(),
 81 |                         split_index,
 82 |                         color,
 83 |                     ));
 84 |                 }
 85 |             }
 86 | 
 87 |             document = document.add(commit_dot(
 88 |                 idx,
 89 |                 branch.visual.column.unwrap(),
 90 |                 branch_color,
 91 |                 !info.is_merge,
 92 |             ));
 93 |         }
 94 |     }
 95 |     let (x_max, y_max) = commit_coord(max_idx + 1, max_column + 1);
 96 |     document = document
 97 |         .set("viewBox", (0, 0, x_max, y_max))
 98 |         .set("width", x_max)
 99 |         .set("height", y_max);
100 | 
101 |     let mut out: Vec<u8> = vec![];
102 |     svg::write(&mut out, &document).map_err(|err| err.to_string())?;
103 |     Ok(String::from_utf8(out).unwrap_or_else(|_| "Invalid UTF8 character.".to_string()))
104 | }
105 | 
106 | fn commit_dot(index: usize, column: usize, color: &str, filled: bool) -> Circle {
107 |     let (x, y) = commit_coord(index, column);
108 |     Circle::new()
109 |         .set("cx", x)
110 |         .set("cy", y)
111 |         .set("r", 4)
112 |         .set("fill", if filled { color } else { "white" })
113 |         .set("stroke", color)
114 |         .set("stroke-width", 1)
115 | }
116 | 
117 | fn line(index1: usize, column1: usize, index2: usize, column2: usize, color: &str) -> Line {
118 |     let (x1, y1) = commit_coord(index1, column1);
119 |     let (x2, y2) = commit_coord(index2, column2);
120 |     Line::new()
121 |         .set("x1", x1)
122 |         .set("y1", y1)
123 |         .set("x2", x2)
124 |         .set("y2", y2)
125 |         .set("stroke", color)
126 |         .set("stroke-width", 1)
127 | }
128 | 
129 | fn bold_line(index1: usize, column1: usize, index2: usize, column2: usize, color: &str) -> Line {
130 |     let (x1, y1) = commit_coord(index1, column1);
131 |     let (x2, y2) = commit_coord(index2, column2);
132 |     Line::new()
133 |         .set("x1", x1)
134 |         .set("y1", y1)
135 |         .set("x2", x2)
136 |         .set("y2", y2)
137 |         .set("stroke", color)
138 |         .set("stroke-width", 5)
139 | }
140 | 
141 | fn path(
142 |     index1: usize,
143 |     column1: usize,
144 |     index2: usize,
145 |     column2: usize,
146 |     split_idx: usize,
147 |     color: &str,
148 | ) -> Path {
149 |     let c0 = commit_coord(index1, column1);
150 | 
151 |     let c1 = commit_coord(split_idx, column1);
152 |     let c2 = commit_coord(split_idx + 1, column2);
153 | 
154 |     let c3 = commit_coord(index2, column2);
155 | 
156 |     let m = (0.5 * (c1.0 + c2.0), 0.5 * (c1.1 + c2.1));
157 | 
158 |     let data = Data::new()
159 |         .move_to(c0)
160 |         .line_to(c1)
161 |         .quadratic_curve_to((c1.0, m.1, m.0, m.1))
162 |         .quadratic_curve_to((c2.0, m.1, c2.0, c2.1))
163 |         .line_to(c3);
164 | 
165 |     Path::new()
166 |         .set("d", data)
167 |         .set("fill", "none")
168 |         .set("stroke", color)
169 |         .set("stroke-width", 1)
170 | }
171 | 
172 | fn commit_coord(index: usize, column: usize) -> (f32, f32) {
173 |     (15.0 * (column as f32 + 1.0), 15.0 * (index as f32 + 1.0))
174 | }
175 | 


--------------------------------------------------------------------------------
/docs/manual.md:
--------------------------------------------------------------------------------
  1 | # git-graph manual
  2 | 
  3 | **Content**
  4 | 
  5 | * [Overview](#overview)
  6 | * [Options](#options)
  7 | * [Formatting](#formatting)
  8 | * [Custom branching models](#custom-branching-models)
  9 | 
 10 | ## Overview
 11 | 
 12 | The most basic usage is to simply call git-graph from inside a Git repository:
 13 | 
 14 | ```
 15 | git-graph
 16 | ```
 17 | 
 18 | This works also deeper down the directory tree, so no need to be in the repository's root folder.
 19 | 
 20 | Alternatively, the path to the repository to visualize can be specified with option `--path`:
 21 | 
 22 | ```
 23 | git-graph --path "path/to/repo"
 24 | ```
 25 | 
 26 | **Branching models**
 27 | 
 28 | The above call assumes the GitFlow branching model (the default). Different branching models can be used with the option `--model` or `-m`:
 29 | 
 30 | ```
 31 | git-graph --model simple
 32 | ```
 33 | 
 34 | To *permanently* set the branching model for a repository, use subcommand `model`, like
 35 | 
 36 | ```
 37 | git-graph model simple
 38 | ```
 39 | 
 40 | Use the subcommand without argument to view the currently set branching model of a repository:
 41 | 
 42 | ```
 43 | git-graph model
 44 | ```
 45 | 
 46 | To view all available branching models, use option `--list` or `-l` of the subcommand:
 47 | 
 48 | ```
 49 | git-graph model --list
 50 | ```
 51 | 
 52 | For **defining your own models**, see section [Custom branching models](#custom-branching-models).
 53 | 
 54 | **Styles**
 55 | 
 56 | Git-graph supports different styles. Besides the default `normal` (alias `thin`), supported styles are `round`, `bold`, `double` and `ascii`. Use a style with option `--style` or `-s`:
 57 | 
 58 | ```
 59 | git-graph --style round
 60 | ```
 61 | 
 62 | ![styles](https://user-images.githubusercontent.com/44003176/103467621-357ce780-4d51-11eb-8ff9-dd7be8b40f84.png)
 63 | 
 64 | Style `ascii` can be used for devices and media that do not support Unicode/UTF-8 characters. 
 65 | 
 66 | **Formatting**
 67 | 
 68 | Git-graph supports predefined as well as custom commit formatting through option `--format`. Available presets follow Git: `oneline` (the default), `short`, `medium` and `full`. For details and custom formatting, see section [Formatting](#formatting).
 69 | 
 70 | For a complete list of all available options, see the next section [Options](#options).
 71 | 
 72 | ## Options
 73 | 
 74 | All options are explained in the CLI help. View it with `git-graph -h`:
 75 | 
 76 | ```
 77 | Structured Git graphs for your branching model.
 78 |     https://github.com/mlange-42/git-graph
 79 | 
 80 | EXAMPES:
 81 |     git-graph                   -> Show graph
 82 |     git-graph --style round     -> Show graph in a different style
 83 |     git-graph --model <model>   -> Show graph using a certain <model>
 84 |     git-graph model --list      -> List available branching models
 85 |     git-graph model             -> Show repo's current branching models
 86 |     git-graph model <model>     -> Permanently set model <model> for this repo
 87 | 
 88 | USAGE:
 89 |     git-graph [FLAGS] [OPTIONS] [SUBCOMMAND]
 90 | 
 91 | FLAGS:
 92 |     -d, --debug       Additional debug output and graphics.
 93 |     -h, --help        Prints help information
 94 |     -l, --local       Show only local branches, no remotes.
 95 |         --no-color    Print without colors. Missing color support should be detected
 96 |                       automatically (e.g. when piping to a file).
 97 |                       Overrides option '--color'
 98 |         --no-pager    Use no pager (print everything at once without prompt).
 99 |     -S, --sparse      Print a less compact graph: merge lines point to target lines
100 |                       rather than merge commits.
101 |         --svg         Render graph as SVG instead of text-based.
102 |     -V, --version     Prints version information
103 | 
104 | OPTIONS:
105 |         --color <color>      Specify when colors should be used. One of [auto|always|never].
106 |                              Default: auto.
107 |     -f, --format <format>    Commit format. One of [oneline|short|medium|full|"<string>"].
108 |                                (First character can be used as abbreviation, e.g. '-f m')
109 |                              Default: oneline.
110 |                              For placeholders supported in "<string>", consult 'git-graph --help'
111 |     -n, --max-count <n>      Maximum number of commits
112 |     -m, --model <model>      Branching model. Available presets are [simple|git-flow|none].
113 |                              Default: git-flow.
114 |                              Permanently set the model for a repository with
115 |                              > git-graph model <model>
116 |     -p, --path <path>        Open repository from this path or above. Default '.'
117 |     -s, --style <style>      Output style. One of [normal/thin|round|bold|double|ascii].
118 |                                (First character can be used as abbreviation, e.g. '-s r')
119 |     -w, --wrap <wrap>        Line wrapping for formatted commit text. Default: 'auto 0 8'
120 |                              Argument format: [<width>|auto|none[ <indent1>[ <indent2>]]]
121 |                              For examples, consult 'git-graph --help'
122 | 
123 | SUBCOMMANDS:
124 |     help     Prints this message or the help of the given subcommand(s)
125 |     model    Prints or permanently sets the branching model for a repository.
126 | ```
127 | 
128 | For longer explanations, use `git-graph --help`.
129 | 
130 | ## Formatting
131 | 
132 | Formatting can be specified with the `--format` option.
133 | 
134 | Predefined formats are `oneline` (the default), `short`, `medium` and `full`. They should behave like the Git formatting presets described in the [Git documentation](https://git-scm.com/docs/pretty-formats).
135 | 
136 | **oneline**
137 | 
138 | ```
139 | <hash> [<refs>] <title line>
140 | ```
141 | 
142 | **short**
143 | 
144 | ```
145 | commit <hash> [<refs>]
146 | Author: <author>
147 | 
148 | <title line>
149 | ```
150 | 
151 | **medium**
152 | 
153 | ```
154 | commit <hash> [<refs>]
155 | Author: <author>
156 | Date:   <author date>
157 | 
158 | <title line>
159 | 
160 | <full commit message>
161 | ```
162 | 
163 | **full**
164 | 
165 | ```
166 | commit <hash> [<refs>]
167 | Author: <author>
168 | Commit: <committer>
169 | Date:   <author date>
170 | 
171 | <title line>
172 | 
173 | <full commit message>
174 | ```
175 | 
176 | ### Custom formatting
177 | 
178 | Formatting strings use a subset of the placeholders available in `git log --format="..."`:
179 | 
180 | | Placeholder | Replaced with                               |
181 | | ----------- | ------------------------------------------- |
182 | | %n          | newline                                     |
183 | | %H          | commit hash                                 |
184 | | %h          | abbreviated commit hash                     |
185 | | %P          | parent commit hashes                        |
186 | | %p          | abbreviated parent commit hashes            |
187 | | %d          | refs (branches, tags)                       |
188 | | %s          | commit summary                              |
189 | | %b          | commit message body                         |
190 | | %B          | raw body (subject and body)                 |
191 | | %an         | author name                                 |
192 | | %ae         | author email                                |
193 | | %ad         | author date                                 |
194 | | %as         | author date in short format `YYYY-MM-DD`    |
195 | | %ar         | author date, relative format (e.g., "21 hours ago") |
196 | | %cn         | committer name                              |
197 | | %ce         | committer email                             |
198 | | %cd         | committer date                              |
199 | | %cs         | committer date in short format `YYYY-MM-DD` |
200 | | %cr         | committer date, relative format (e.g., "4 days ago") |
201 | 
202 | If you add a '+' (plus sign) after % of a placeholder, a line-feed is inserted immediately before the expansion if and only if the placeholder expands to a non-empty string.
203 | 
204 | If you add a '-' (minus sign) after % of a placeholder, all consecutive line-feeds immediately preceding the expansion are deleted if and only if the placeholder expands to an empty string.
205 | 
206 | If you add a ' ' (space) after % of a placeholder, a space is inserted immediately before the expansion if and only if the placeholder expands to a non-empty string.
207 | 
208 | See also the [Git documentation](https://git-scm.com/docs/pretty-formats).
209 | 
210 | More formatting placeholders are planned for later releases.
211 | 
212 | **Examples**
213 | 
214 | Format recreating `oneline`:
215 | 
216 | ```
217 | git-graph --format "%h%d %s"
218 | ```
219 | 
220 | Format similar to `short`:
221 | 
222 | ```
223 | git-graph --format "commit %H%nAuthor: %an %ae%n%n    %s%n"
224 | ```
225 | 
226 | ## Custom branching models
227 | 
228 | Branching models are configured using the files in `APP_DATA/git-graph/models`. 
229 | 
230 | * Windows: `C:\Users\<user>\AppData\Roaming\git-graph`
231 | * Linux: `~/.config/git-graph`
232 | * OSX: `~/Library/Application Support/git-graph`
233 | 
234 | File names of any `.toml` files in the `models` directory can be used in parameter `--model`, or via sub-command `model`. E.g., to use a branching model defined in `my-model.toml`, use:
235 | 
236 | ```
237 | git-graph --model my-model
238 | ```
239 | 
240 | **Branching model files** are in [TOML](https://toml.io/en/) format and have several sections, relying on Regular Expressions to categorize branches. The listing below shows the `git-flow` model (slightly abbreviated) with explanatory comments.
241 | 
242 | ```toml
243 | # RegEx patterns for branch groups by persistence, from most persistent
244 | # to most short-leved branches. This is used to back-trace branches.
245 | # Branches not matching any pattern are assumed least persistent.
246 | persistence = [
247 |     '^(master|main|trunk)$', # Matches exactly `master` or `main`  or `trunk`
248 |     '^(develop|dev)$',
249 |     '^feature.*$',     # Matches everything starting with `feature`
250 |     '^release.*$',
251 |     '^hotfix.*$',
252 |     '^bugfix.*$',
253 | ]
254 | 
255 | # RegEx patterns for visual ordering of branches, from left to right.
256 | # Here, `master`, `main` or `trunk` are shown left-most, followed by branches
257 | # starting with `hotfix` or `release`, followed by `develop` or `dev`.
258 | # Branches not matching any pattern (e.g. starting with `feature`)
259 | # are displayed further to the right.
260 | order = [
261 |     '^(master|main|trunk)$',      # Matches exactly `master` or `main` or `trunk`
262 |     '^(hotfix|release).*$', # Matches everything starting with `hotfix` or `release`
263 |     '^(develop|dev)$',      # Matches exactly `develop` or `dev`
264 | ]
265 | 
266 | # Colors of branches in terminal output. 
267 | # For supported colors, see section Colors (below this listing).
268 | [terminal_colors]
269 | # Each entry is composed of a RegEx pattern and a list of colors that
270 | # will be used alternating (see e.g. `feature...`).
271 | matches = [
272 |     [
273 |         '^(master|main|trunk)$',
274 |         ['bright_blue'],
275 |     ],
276 |     [
277 |         '^(develop|dev)$',
278 |         ['bright_yellow'],
279 |     ],
280 |     [   # Branches obviously merged in from forks are prefixed with 'fork/'. 
281 |         # The 'fork/' prefix is only available in order and colors, but not in persistence!
282 |         '^(feature|fork/).*$',
283 |         ['bright_magenta', 'bright_cyan'], # Multiple colors for alternating use
284 |     ],
285 |         [
286 |         '^release.*$',
287 |         ['bright_green'],
288 |     ],
289 |         [
290 |         '^(bugfix|hotfix).*$',
291 |         ['bright_red'],
292 |     ],
293 |     [
294 |         '^tags/.*$',
295 |         ['bright_green'],
296 |     ],
297 | ]
298 | # A list of colors that are used (alternating) for all branches
299 | # not matching any of the above pattern. 
300 | unknown = ['white']
301 | 
302 | # Colors of branches in SVG output. 
303 | # Same structure as terminal_colors. 
304 | # For supported colors, see section Colors (below this listing).
305 | [svg_colors]
306 | matches = [
307 |     [
308 |         '^(master|main|trunk)$',
309 |         ['blue'],
310 |     ],
311 |     [ 
312 |         '...',
313 |     ]
314 | ]
315 | unknown = ['gray']
316 | ```
317 | 
318 | **Tags**
319 | 
320 | Internally, all tags start with `tag/`. To match Git tags, use RegEx patterns like `^tags/.*$`. However, only tags that are not on any branch are ordered and colored separately.
321 | 
322 | **Colors**
323 | 
324 | **Terminal colors** support the 8 system color names `black`, `red`, `green`, `yellow`, `blue`, `magenta`, `cyan` and `white`, as well as each of them prefixed with `bright_` (e.g. `bright_blue`).
325 | 
326 | Further, indices of the 256-color palette are supported. For a full list, see [here](https://jonasjacek.github.io/colors/). Indices must be quoted as strings (e.g. `'16'`)
327 | 
328 | **SVG colors** support all named web colors (full list [here](https://htmlcolorcodes.com/color-names/)), as well as RGB colors in hex notation, like `#ffffff`.
329 | 


--------------------------------------------------------------------------------
/src/settings.rs:
--------------------------------------------------------------------------------
  1 | //! Graph generation settings.
  2 | //!
  3 | //! The settings control how a branching graph is layed out.
  4 | //! They are used in the [print][super::print] module when generating
  5 | //! a visualization and persisted to disk in the [config][super::config] module.
  6 | //!
  7 | //! These are the main structs
  8 | //! * [Settings] The main settings object, which contains:
  9 | //!   * [CommitFormat] Format of the commit summary text to the right of the graph.
 10 | //!   * [Characters] The symbols to use when rendering a graph as text.
 11 | //!   * [BranchSettings] Control how a graph is formatted.
 12 | //!   * [BranchOrder] Determines the left-to-right order of branches.
 13 | //!   * [MergePatterns] Regex that extract branch names from a merge commit.
 14 | 
 15 | use crate::print::format::CommitFormat;
 16 | use regex::{Error, Regex};
 17 | use serde_derive::{Deserialize, Serialize};
 18 | use std::str::FromStr;
 19 | 
 20 | /// Repository settings for the branching model.
 21 | /// Used to read repo's git-graph.toml
 22 | #[derive(Serialize, Deserialize)]
 23 | pub struct RepoSettings {
 24 |     /// The repository's branching model
 25 |     pub model: String,
 26 | }
 27 | 
 28 | /// Ordering policy for branches in visual columns.
 29 | pub enum BranchOrder {
 30 |     /// Recommended! Shortest branches are inserted left-most.
 31 |     ///
 32 |     /// For branches with equal length, branches ending last are inserted first.
 33 |     /// Reverse (arg = false): Branches ending first are inserted first.
 34 |     ShortestFirst(bool),
 35 |     /// Longest branches are inserted left-most.
 36 |     ///
 37 |     /// For branches with equal length, branches ending last are inserted first.
 38 |     /// Reverse (arg = false): Branches ending first are inserted first.
 39 |     LongestFirst(bool),
 40 | }
 41 | 
 42 | /// Top-level settings
 43 | pub struct Settings {
 44 |     /// Reverse the order of commits
 45 |     pub reverse_commit_order: bool,
 46 |     /// Debug printing and drawing
 47 |     pub debug: bool,
 48 |     /// Compact text-based graph
 49 |     pub compact: bool,
 50 |     /// Colored text-based graph
 51 |     pub colored: bool,
 52 |     /// Include remote branches?
 53 |     pub include_remote: bool,
 54 |     /// Formatting for commits
 55 |     pub format: CommitFormat,
 56 |     /// Text wrapping options
 57 |     pub wrapping: Option<(Option<usize>, Option<usize>, Option<usize>)>,
 58 |     /// Characters to use for text-based graph
 59 |     pub characters: Characters,
 60 |     /// Branch column sorting algorithm
 61 |     pub branch_order: BranchOrder,
 62 |     /// Settings for branches
 63 |     pub branches: BranchSettings,
 64 |     /// Regex patterns for finding branch names in merge commit summaries
 65 |     pub merge_patterns: MergePatterns,
 66 | }
 67 | 
 68 | /// Helper for reading BranchSettings, required due to RegEx.
 69 | #[derive(Serialize, Deserialize)]
 70 | pub struct BranchSettingsDef {
 71 |     /// Branch persistence
 72 |     pub persistence: Vec<String>,
 73 |     /// Branch ordering
 74 |     pub order: Vec<String>,
 75 |     /// Branch colors
 76 |     pub terminal_colors: ColorsDef,
 77 |     /// Branch colors for SVG output
 78 |     pub svg_colors: ColorsDef,
 79 | }
 80 | 
 81 | /// Helper for reading branch colors, required due to RegEx.
 82 | #[derive(Serialize, Deserialize)]
 83 | pub struct ColorsDef {
 84 |     matches: Vec<(String, Vec<String>)>,
 85 |     unknown: Vec<String>,
 86 | }
 87 | 
 88 | impl BranchSettingsDef {
 89 |     /// The Git-Flow model.
 90 |     pub fn git_flow() -> Self {
 91 |         BranchSettingsDef {
 92 |             persistence: vec![
 93 |                 r"^(master|main|trunk)$".to_string(),
 94 |                 r"^(develop|dev)$".to_string(),
 95 |                 r"^feature.*$".to_string(),
 96 |                 r"^release.*$".to_string(),
 97 |                 r"^hotfix.*$".to_string(),
 98 |                 r"^bugfix.*$".to_string(),
 99 |             ],
100 |             order: vec![
101 |                 r"^(master|main|trunk)$".to_string(),
102 |                 r"^(hotfix|release).*$".to_string(),
103 |                 r"^(develop|dev)$".to_string(),
104 |             ],
105 |             terminal_colors: ColorsDef {
106 |                 matches: vec![
107 |                     (
108 |                         r"^(master|main|trunk)$".to_string(),
109 |                         vec!["bright_blue".to_string()],
110 |                     ),
111 |                     (
112 |                         r"^(develop|dev)$".to_string(),
113 |                         vec!["bright_yellow".to_string()],
114 |                     ),
115 |                     (
116 |                         r"^(feature|fork/).*$".to_string(),
117 |                         vec!["bright_magenta".to_string(), "bright_cyan".to_string()],
118 |                     ),
119 |                     (r"^release.*$".to_string(), vec!["bright_green".to_string()]),
120 |                     (
121 |                         r"^(bugfix|hotfix).*$".to_string(),
122 |                         vec!["bright_red".to_string()],
123 |                     ),
124 |                     (r"^tags/.*$".to_string(), vec!["bright_green".to_string()]),
125 |                 ],
126 |                 unknown: vec!["white".to_string()],
127 |             },
128 | 
129 |             svg_colors: ColorsDef {
130 |                 matches: vec![
131 |                     (
132 |                         r"^(master|main|trunk)$".to_string(),
133 |                         vec!["blue".to_string()],
134 |                     ),
135 |                     (r"^(develop|dev)$".to_string(), vec!["orange".to_string()]),
136 |                     (
137 |                         r"^(feature|fork/).*$".to_string(),
138 |                         vec!["purple".to_string(), "turquoise".to_string()],
139 |                     ),
140 |                     (r"^release.*$".to_string(), vec!["green".to_string()]),
141 |                     (r"^(bugfix|hotfix).*$".to_string(), vec!["red".to_string()]),
142 |                     (r"^tags/.*$".to_string(), vec!["green".to_string()]),
143 |                 ],
144 |                 unknown: vec!["gray".to_string()],
145 |             },
146 |         }
147 |     }
148 | 
149 |     /// Simple feature-based model.
150 |     pub fn simple() -> Self {
151 |         BranchSettingsDef {
152 |             persistence: vec![r"^(master|main|trunk)$".to_string()],
153 |             order: vec![
154 |                 r"^tags/.*$".to_string(),
155 |                 r"^(master|main|trunk)$".to_string(),
156 |             ],
157 |             terminal_colors: ColorsDef {
158 |                 matches: vec![
159 |                     (
160 |                         r"^(master|main|trunk)$".to_string(),
161 |                         vec!["bright_blue".to_string()],
162 |                     ),
163 |                     (r"^tags/.*$".to_string(), vec!["bright_green".to_string()]),
164 |                 ],
165 |                 unknown: vec![
166 |                     "bright_yellow".to_string(),
167 |                     "bright_green".to_string(),
168 |                     "bright_red".to_string(),
169 |                     "bright_magenta".to_string(),
170 |                     "bright_cyan".to_string(),
171 |                 ],
172 |             },
173 | 
174 |             svg_colors: ColorsDef {
175 |                 matches: vec![
176 |                     (
177 |                         r"^(master|main|trunk)$".to_string(),
178 |                         vec!["blue".to_string()],
179 |                     ),
180 |                     (r"^tags/.*$".to_string(), vec!["green".to_string()]),
181 |                 ],
182 |                 unknown: vec![
183 |                     "orange".to_string(),
184 |                     "green".to_string(),
185 |                     "red".to_string(),
186 |                     "purple".to_string(),
187 |                     "turquoise".to_string(),
188 |                 ],
189 |             },
190 |         }
191 |     }
192 | 
193 |     /// Very simple model without any defined branch roles.
194 |     pub fn none() -> Self {
195 |         BranchSettingsDef {
196 |             persistence: vec![],
197 |             order: vec![],
198 |             terminal_colors: ColorsDef {
199 |                 matches: vec![],
200 |                 unknown: vec![
201 |                     "bright_blue".to_string(),
202 |                     "bright_yellow".to_string(),
203 |                     "bright_green".to_string(),
204 |                     "bright_red".to_string(),
205 |                     "bright_magenta".to_string(),
206 |                     "bright_cyan".to_string(),
207 |                 ],
208 |             },
209 | 
210 |             svg_colors: ColorsDef {
211 |                 matches: vec![],
212 |                 unknown: vec![
213 |                     "blue".to_string(),
214 |                     "orange".to_string(),
215 |                     "green".to_string(),
216 |                     "red".to_string(),
217 |                     "purple".to_string(),
218 |                     "turquoise".to_string(),
219 |                 ],
220 |             },
221 |         }
222 |     }
223 | }
224 | 
225 | /// Settings defining branching models
226 | pub struct BranchSettings {
227 |     /// Branch persistence
228 |     pub persistence: Vec<Regex>,
229 |     /// Branch ordering
230 |     pub order: Vec<Regex>,
231 |     /// Branch colors
232 |     pub terminal_colors: Vec<(Regex, Vec<String>)>,
233 |     /// Colors for branches not matching any of `colors`
234 |     pub terminal_colors_unknown: Vec<String>,
235 |     /// Branch colors for SVG output
236 |     pub svg_colors: Vec<(Regex, Vec<String>)>,
237 |     /// Colors for branches not matching any of `colors` for SVG output
238 |     pub svg_colors_unknown: Vec<String>,
239 | }
240 | 
241 | impl BranchSettings {
242 |     pub fn from(def: BranchSettingsDef) -> Result<Self, Error> {
243 |         let persistence = def
244 |             .persistence
245 |             .iter()
246 |             .map(|str| Regex::new(str))
247 |             .collect::<Result<Vec<_>, Error>>()?;
248 | 
249 |         let order = def
250 |             .order
251 |             .iter()
252 |             .map(|str| Regex::new(str))
253 |             .collect::<Result<Vec<_>, Error>>()?;
254 | 
255 |         let terminal_colors = def
256 |             .terminal_colors
257 |             .matches
258 |             .into_iter()
259 |             .map(|(str, vec)| Regex::new(&str).map(|re| (re, vec)))
260 |             .collect::<Result<Vec<_>, Error>>()?;
261 | 
262 |         let terminal_colors_unknown = def.terminal_colors.unknown;
263 | 
264 |         let svg_colors = def
265 |             .svg_colors
266 |             .matches
267 |             .into_iter()
268 |             .map(|(str, vec)| Regex::new(&str).map(|re| (re, vec)))
269 |             .collect::<Result<Vec<_>, Error>>()?;
270 | 
271 |         let svg_colors_unknown = def.svg_colors.unknown;
272 | 
273 |         Ok(BranchSettings {
274 |             persistence,
275 |             order,
276 |             terminal_colors,
277 |             terminal_colors_unknown,
278 |             svg_colors,
279 |             svg_colors_unknown,
280 |         })
281 |     }
282 | }
283 | 
284 | /// RegEx patterns for extracting branch names from merge commit summaries.
285 | pub struct MergePatterns {
286 |     /// The patterns. Evaluated in the given order.
287 |     pub patterns: Vec<Regex>,
288 | }
289 | 
290 | impl Default for MergePatterns {
291 |     fn default() -> Self {
292 |         MergePatterns {
293 |             patterns: vec![
294 |                 // GitLab pull request
295 |                 Regex::new(r"^Merge branch '(.+)' into '.+'$").unwrap(),
296 |                 // Git default
297 |                 Regex::new(r"^Merge branch '(.+)' into .+$").unwrap(),
298 |                 // Git default into main branch
299 |                 Regex::new(r"^Merge branch '(.+)'$").unwrap(),
300 |                 // GitHub pull request
301 |                 Regex::new(r"^Merge pull request #[0-9]+ from .[^/]+/(.+)$").unwrap(),
302 |                 // GitHub pull request (from fork?)
303 |                 Regex::new(r"^Merge branch '(.+)' of .+$").unwrap(),
304 |                 // BitBucket pull request
305 |                 Regex::new(r"^Merged in (.+) \(pull request #[0-9]+\)$").unwrap(),
306 |             ],
307 |         }
308 |     }
309 | }
310 | 
311 | /// The characters used for drawing text-based graphs.
312 | pub struct Characters {
313 |     pub chars: Vec<char>,
314 | }
315 | 
316 | impl FromStr for Characters {
317 |     type Err = String;
318 | 
319 |     fn from_str(str: &str) -> Result<Self, Self::Err> {
320 |         match str {
321 |             "normal" | "thin" | "n" | "t" => Ok(Characters::thin()),
322 |             "round" | "r" => Ok(Characters::round()),
323 |             "bold" | "b" => Ok(Characters::bold()),
324 |             "double" | "d" => Ok(Characters::double()),
325 |             "ascii" | "a" => Ok(Characters::ascii()),
326 |             _ => Err(format!("Unknown characters/style '{}'. Must be one of [normal|thin|round|bold|double|ascii]", str)),
327 |         }
328 |     }
329 | }
330 | 
331 | impl Characters {
332 |     /// Default/thin graphs
333 |     pub fn thin() -> Self {
334 |         Characters {
335 |             chars: " ●○│─┼└┌┐┘┤├┴┬<>".chars().collect(),
336 |         }
337 |     }
338 |     /// Graphs with rounded corners
339 |     pub fn round() -> Self {
340 |         Characters {
341 |             chars: " ●○│─┼╰╭╮╯┤├┴┬<>".chars().collect(),
342 |         }
343 |     }
344 |     /// Bold/fat graphs
345 |     pub fn bold() -> Self {
346 |         Characters {
347 |             chars: " ●○┃━╋┗┏┓┛┫┣┻┳<>".chars().collect(),
348 |         }
349 |     }
350 |     /// Double-lined graphs
351 |     pub fn double() -> Self {
352 |         Characters {
353 |             chars: " ●○║═╬╚╔╗╝╣╠╩╦<>".chars().collect(),
354 |         }
355 |     }
356 |     /// ASCII-only graphs
357 |     pub fn ascii() -> Self {
358 |         Characters {
359 |             chars: " *o|-+'..'||++<>".chars().collect(),
360 |         }
361 |     }
362 | 
363 |     pub fn reverse(self) -> Self {
364 |         let mut chars = self.chars;
365 | 
366 |         chars.swap(6, 8);
367 |         chars.swap(7, 9);
368 |         chars.swap(10, 11);
369 |         chars.swap(12, 13);
370 |         chars.swap(14, 15);
371 | 
372 |         Characters { chars }
373 |     }
374 | }
375 | 


--------------------------------------------------------------------------------
/src/print/format.rs:
--------------------------------------------------------------------------------
  1 | //! Formatting of commits.
  2 | 
  3 | use chrono::{FixedOffset, Local, TimeZone};
  4 | use git2::{Commit, Time};
  5 | use lazy_static::lazy_static;
  6 | use std::fmt::Write;
  7 | use std::str::FromStr;
  8 | use textwrap::Options;
  9 | use yansi::Paint;
 10 | 
 11 | /// Commit formatting options.
 12 | #[derive(Ord, PartialOrd, Eq, PartialEq)]
 13 | pub enum CommitFormat {
 14 |     OneLine,
 15 |     Short,
 16 |     Medium,
 17 |     Full,
 18 |     Format(String),
 19 | }
 20 | 
 21 | impl FromStr for CommitFormat {
 22 |     type Err = String;
 23 | 
 24 |     fn from_str(str: &str) -> Result<Self, Self::Err> {
 25 |         match str {
 26 |             "oneline" | "o" => Ok(CommitFormat::OneLine),
 27 |             "short" | "s" => Ok(CommitFormat::Short),
 28 |             "medium" | "m" => Ok(CommitFormat::Medium),
 29 |             "full" | "f" => Ok(CommitFormat::Full),
 30 |             str => Ok(CommitFormat::Format(str.to_string())),
 31 |         }
 32 |     }
 33 | }
 34 | 
 35 | const NEW_LINE: usize = 0;
 36 | const HASH: usize = 1;
 37 | const HASH_ABBREV: usize = 2;
 38 | const PARENT_HASHES: usize = 3;
 39 | const PARENT_HASHES_ABBREV: usize = 4;
 40 | const REFS: usize = 5;
 41 | const SUBJECT: usize = 6;
 42 | const AUTHOR: usize = 7;
 43 | const AUTHOR_EMAIL: usize = 8;
 44 | const AUTHOR_DATE: usize = 9;
 45 | const AUTHOR_DATE_SHORT: usize = 10;
 46 | const AUTHOR_DATE_RELATIVE: usize = 11;
 47 | const COMMITTER: usize = 12;
 48 | const COMMITTER_EMAIL: usize = 13;
 49 | const COMMITTER_DATE: usize = 14;
 50 | const COMMITTER_DATE_SHORT: usize = 15;
 51 | const COMMITTER_DATE_RELATIVE: usize = 16;
 52 | const BODY: usize = 17;
 53 | const BODY_RAW: usize = 18;
 54 | 
 55 | const MODE_SPACE: usize = 1;
 56 | const MODE_PLUS: usize = 2;
 57 | const MODE_MINUS: usize = 3;
 58 | 
 59 | lazy_static! {
 60 |     pub static ref PLACEHOLDERS: Vec<[String; 4]> = {
 61 |         let base = vec![
 62 |             "n", "H", "h", "P", "p", "d", "s", "an", "ae", "ad", "as", "ar", "cn", "ce", "cd",
 63 |             "cs", "cr", "b", "B",
 64 |         ];
 65 |         base.iter()
 66 |             .map(|b| {
 67 |                 [
 68 |                     format!("%{}", b),
 69 |                     format!("% {}", b),
 70 |                     format!("%+{}", b),
 71 |                     format!("%-{}", b),
 72 |                 ]
 73 |             })
 74 |             .collect()
 75 |     };
 76 | }
 77 | 
 78 | /// Format a commit for `CommitFormat::Format(String)`.
 79 | pub fn format_commit(
 80 |     format: &str,
 81 |     commit: &Commit,
 82 |     branches: String,
 83 |     wrapping: &Option<Options>,
 84 |     hash_color: Option<u8>,
 85 | ) -> Result<Vec<String>, String> {
 86 |     // Find replacements
 87 |     let mut replacements = vec![];
 88 |     for (idx, arr) in PLACEHOLDERS.iter().enumerate() {
 89 |         let mut curr = 0;
 90 |         loop {
 91 |             let mut found = false;
 92 |             for (mode, str) in arr.iter().enumerate() {
 93 |                 if let Some(start) = &format[curr..].find(str) {
 94 |                     replacements.push((curr + start, str.len(), idx, mode));
 95 |                     curr += start + str.len();
 96 |                     found = true;
 97 |                     break;
 98 |                 }
 99 |             }
100 |             if !found {
101 |                 break;
102 |             }
103 |         }
104 |     }
105 |     replacements.sort_by_key(|p| p.0);
106 | 
107 |     // Generate formatted lines
108 |     let mut lines = vec![];
109 |     let mut out = String::new();
110 |     let mut formatter = CommitFieldFormatter::new(
111 |         commit, &branches, hash_color, wrapping, &mut out, &mut lines,
112 |     );
113 | 
114 |     let mut curr = 0;
115 |     for &(start, len, idx, mode) in &replacements {
116 |         formatter.out.push_str(&format[curr..start]);
117 |         formatter.format_field(idx, mode)?;
118 |         curr = start + len;
119 |     }
120 |     formatter.out.push_str(&format[curr..]);
121 |     formatter.finalize_tail();
122 |     Ok(lines)
123 | }
124 | 
125 | struct CommitFieldFormatter<'a> {
126 |     commit: &'a Commit<'a>,
127 |     branches: &'a str,
128 |     hash_color: Option<u8>,
129 |     wrapping: &'a Option<Options<'a>>,
130 |     out: &'a mut String,
131 |     lines: &'a mut Vec<String>,
132 | }
133 | 
134 | impl<'a> CommitFieldFormatter<'a> {
135 |     fn new(
136 |         commit: &'a Commit,
137 |         branches: &'a str,
138 |         hash_color: Option<u8>,
139 |         wrapping: &'a Option<Options>,
140 |         out: &'a mut String,
141 |         lines: &'a mut Vec<String>,
142 |     ) -> Self {
143 |         Self {
144 |             commit,
145 |             branches,
146 |             hash_color,
147 |             wrapping,
148 |             out,
149 |             lines,
150 |         }
151 |     }
152 | 
153 |     fn handle_mode(&mut self, mode: usize, field_has_content: bool) {
154 |         match mode {
155 |             MODE_SPACE => {
156 |                 if field_has_content {
157 |                     self.out.push(' ');
158 |                 }
159 |             }
160 |             MODE_PLUS => {
161 |                 if field_has_content {
162 |                     self.add_line();
163 |                 }
164 |             }
165 |             MODE_MINUS => {
166 |                 if !field_has_content {
167 |                     *self.out = remove_empty_lines(self.lines, self.out.clone());
168 |                 }
169 |             }
170 |             _ => {}
171 |         }
172 |     }
173 | 
174 |     pub fn format_field(&mut self, idx: usize, mode: usize) -> Result<(), String> {
175 |         match idx {
176 |             NEW_LINE => self.add_line(),
177 |             HASH => self.format_hash(mode),
178 |             HASH_ABBREV => self.format_hash_abbrev(mode),
179 |             PARENT_HASHES => self.format_parent_hashes(mode)?,
180 |             PARENT_HASHES_ABBREV => self.format_parent_hashes_abbrev(mode)?,
181 |             REFS => self.format_refs(mode),
182 |             SUBJECT => self.format_subject(mode)?,
183 |             AUTHOR => self.format_author(mode),
184 |             AUTHOR_EMAIL => self.format_author_email(mode),
185 |             AUTHOR_DATE => self.format_author_date(mode),
186 |             AUTHOR_DATE_SHORT => self.format_author_date_short(mode),
187 |             AUTHOR_DATE_RELATIVE => self.format_author_date_relative(mode),
188 |             COMMITTER => self.format_committer(mode),
189 |             COMMITTER_EMAIL => self.format_committer_email(mode),
190 |             COMMITTER_DATE => self.format_committer_date(mode),
191 |             COMMITTER_DATE_SHORT => self.format_committer_date_short(mode),
192 |             COMMITTER_DATE_RELATIVE => self.format_committer_date_relative(mode),
193 |             BODY => self.format_body(mode)?,
194 |             BODY_RAW => self.format_body_raw(mode)?,
195 |             x => return Err(format!("No commit field at index {}", x)),
196 |         }
197 |         Ok(())
198 |     }
199 | 
200 |     fn add_line(&mut self) {
201 |         if !self.out.is_empty() {
202 |             add_line(self.lines, self.out, self.wrapping);
203 |         }
204 |     }
205 | 
206 |     pub fn finalize_tail(&mut self) {
207 |         self.add_line();
208 |     }
209 | 
210 |     fn format_hash(&mut self, mode: usize) {
211 |         self.handle_mode(mode, true);
212 |         let id = self.commit.id();
213 |         if let Some(color) = self.hash_color {
214 |             self.out.push_str(&id.to_string().fixed(color).to_string());
215 |         } else {
216 |             self.out.push_str(&id.to_string());
217 |         }
218 |     }
219 | 
220 |     fn format_hash_abbrev(&mut self, mode: usize) {
221 |         self.handle_mode(mode, true);
222 |         let id = self.commit.id().to_string();
223 |         let s = &id[..7];
224 |         if let Some(color) = self.hash_color {
225 |             self.out.push_str(&s.fixed(color).to_string());
226 |         } else {
227 |             self.out.push_str(s);
228 |         }
229 |     }
230 | 
231 |     fn format_parent_hashes(&mut self, mode: usize) -> Result<(), String> {
232 |         self.handle_mode(mode, true);
233 |         for i in 0..self.commit.parent_count() {
234 |             self.out
235 |                 .push_str(&self.commit.parent_id(i).unwrap().to_string());
236 |             if i < self.commit.parent_count() - 1 {
237 |                 self.out.push(' ');
238 |             }
239 |         }
240 |         Ok(())
241 |     }
242 | 
243 |     fn format_parent_hashes_abbrev(&mut self, mode: usize) -> Result<(), String> {
244 |         self.handle_mode(mode, true);
245 |         for i in 0..self.commit.parent_count() {
246 |             let parent_id = self.commit.parent_id(i).map_err(|err| err.to_string())?;
247 |             self.out.push_str(&parent_id.to_string()[..7]);
248 |             if i < self.commit.parent_count() - 1 {
249 |                 self.out.push(' ');
250 |             }
251 |         }
252 |         Ok(())
253 |     }
254 | 
255 |     fn format_refs(&mut self, mode: usize) {
256 |         self.handle_mode(mode, !self.branches.is_empty());
257 |         self.out.push_str(self.branches);
258 |     }
259 | 
260 |     fn format_subject(&mut self, mode: usize) -> Result<(), String> {
261 |         let summary = self.commit.summary().unwrap_or("");
262 |         self.handle_mode(mode, !summary.is_empty());
263 |         self.out.push_str(summary);
264 |         Ok(())
265 |     }
266 | 
267 |     fn format_author(&mut self, mode: usize) {
268 |         self.handle_mode(mode, true);
269 |         self.out.push_str(self.commit.author().name().unwrap_or(""));
270 |     }
271 | 
272 |     fn format_author_email(&mut self, mode: usize) {
273 |         self.handle_mode(mode, true);
274 |         self.out
275 |             .push_str(self.commit.author().email().unwrap_or(""));
276 |     }
277 | 
278 |     fn format_author_date(&mut self, mode: usize) {
279 |         self.handle_mode(mode, true);
280 |         self.out.push_str(&format_date(
281 |             self.commit.author().when(),
282 |             "%a %b %e %H:%M:%S %Y %z",
283 |         ));
284 |     }
285 | 
286 |     fn format_author_date_short(&mut self, mode: usize) {
287 |         self.handle_mode(mode, true);
288 |         self.out
289 |             .push_str(&format_date(self.commit.author().when(), "%F"));
290 |     }
291 | 
292 |     fn format_author_date_relative(&mut self, mode: usize) {
293 |         self.handle_mode(mode, true);
294 |         self.out
295 |             .push_str(&format_relative_time(self.commit.author().when()));
296 |     }
297 | 
298 |     fn format_committer(&mut self, mode: usize) {
299 |         self.handle_mode(mode, true);
300 |         self.out
301 |             .push_str(self.commit.committer().name().unwrap_or(""));
302 |     }
303 | 
304 |     fn format_committer_email(&mut self, mode: usize) {
305 |         self.handle_mode(mode, true);
306 |         self.out
307 |             .push_str(self.commit.committer().email().unwrap_or(""));
308 |     }
309 | 
310 |     fn format_committer_date(&mut self, mode: usize) {
311 |         self.handle_mode(mode, true);
312 |         self.out.push_str(&format_date(
313 |             self.commit.committer().when(),
314 |             "%a %b %e %H:%M:%S %Y %z",
315 |         ));
316 |     }
317 | 
318 |     fn format_committer_date_short(&mut self, mode: usize) {
319 |         self.handle_mode(mode, true);
320 |         self.out
321 |             .push_str(&format_date(self.commit.committer().when(), "%F"));
322 |     }
323 | 
324 |     fn format_committer_date_relative(&mut self, mode: usize) {
325 |         self.handle_mode(mode, true);
326 |         self.out
327 |             .push_str(&format_relative_time(self.commit.committer().when()));
328 |     }
329 | 
330 |     fn format_body(&mut self, mode: usize) -> Result<(), String> {
331 |         let message = self
332 |             .commit
333 |             .message()
334 |             .unwrap_or("")
335 |             .lines()
336 |             .collect::<Vec<&str>>();
337 |         let num_parts = message.len();
338 |         self.handle_mode(mode, num_parts > 2);
339 |         for (cnt, line) in message.iter().enumerate() {
340 |             if cnt > 1 && (cnt < num_parts - 1 || !line.is_empty()) {
341 |                 self.out.push_str(line);
342 |                 self.add_line();
343 |             }
344 |         }
345 |         Ok(())
346 |     }
347 | 
348 |     fn format_body_raw(&mut self, mode: usize) -> Result<(), String> {
349 |         let message = self
350 |             .commit
351 |             .message()
352 |             .unwrap_or("")
353 |             .lines()
354 |             .collect::<Vec<&str>>();
355 |         let num_parts = message.len();
356 |         self.handle_mode(mode, !message.is_empty());
357 |         for (cnt, line) in message.iter().enumerate() {
358 |             if cnt < num_parts - 1 || !line.is_empty() {
359 |                 self.out.push_str(line);
360 |                 self.add_line();
361 |             }
362 |         }
363 |         Ok(())
364 |     }
365 | }
366 | 
367 | /// Format a commit for `CommitFormat::OneLine`.
368 | pub fn format_oneline(
369 |     commit: &Commit,
370 |     branches: String,
371 |     wrapping: &Option<Options>,
372 |     hash_color: Option<u8>,
373 | ) -> Vec<String> {
374 |     let mut out = String::new();
375 |     let id = commit.id();
376 |     if let Some(color) = hash_color {
377 |         write!(out, "{}", id.to_string()[..7].fixed(color))
378 |     } else {
379 |         write!(out, "{}", &id.to_string()[..7])
380 |     }
381 |     .unwrap();
382 | 
383 |     write!(out, "{} {}", branches, commit.summary().unwrap_or("")).unwrap();
384 | 
385 |     if let Some(wrap) = wrapping {
386 |         textwrap::fill(&out, wrap)
387 |             .lines()
388 |             .map(|str| str.to_string())
389 |             .collect()
390 |     } else {
391 |         vec![out]
392 |     }
393 | }
394 | 
395 | /// Format a commit for `CommitFormat::Short`, `CommitFormat::Medium` or `CommitFormat::Full`.
396 | pub fn format(
397 |     commit: &Commit,
398 |     branches: String,
399 |     wrapping: &Option<Options>,
400 |     hash_color: Option<u8>,
401 |     format: &CommitFormat,
402 | ) -> Result<Vec<String>, String> {
403 |     match format {
404 |         CommitFormat::OneLine => return Ok(format_oneline(commit, branches, wrapping, hash_color)),
405 |         CommitFormat::Format(format) => {
406 |             return format_commit(format, commit, branches, wrapping, hash_color)
407 |         }
408 |         _ => {}
409 |     }
410 | 
411 |     let mut out_vec = vec![];
412 |     let mut out = String::new();
413 | 
414 |     let id = commit.id();
415 |     if let Some(color) = hash_color {
416 |         write!(out, "commit {}", id.to_string().fixed(color))
417 |     } else {
418 |         write!(out, "commit {}", &id)
419 |     }
420 |     .map_err(|err| err.to_string())?;
421 | 
422 |     write!(out, "{}", branches).map_err(|err| err.to_string())?;
423 |     append_wrapped(&mut out_vec, out, wrapping);
424 | 
425 |     if commit.parent_count() > 1 {
426 |         out = String::new();
427 |         write!(
428 |             out,
429 |             "Merge: {} {}",
430 |             &commit.parent_id(0).unwrap().to_string()[..7],
431 |             &commit.parent_id(1).unwrap().to_string()[..7]
432 |         )
433 |         .map_err(|err| err.to_string())?;
434 |         append_wrapped(&mut out_vec, out, wrapping);
435 |     }
436 | 
437 |     out = String::new();
438 |     write!(
439 |         out,
440 |         "Author: {} <{}>",
441 |         commit.author().name().unwrap_or(""),
442 |         commit.author().email().unwrap_or("")
443 |     )
444 |     .map_err(|err| err.to_string())?;
445 |     append_wrapped(&mut out_vec, out, wrapping);
446 | 
447 |     if format > &CommitFormat::Medium {
448 |         out = String::new();
449 |         write!(
450 |             out,
451 |             "Commit: {} <{}>",
452 |             commit.committer().name().unwrap_or(""),
453 |             commit.committer().email().unwrap_or("")
454 |         )
455 |         .map_err(|err| err.to_string())?;
456 |         append_wrapped(&mut out_vec, out, wrapping);
457 |     }
458 | 
459 |     if format > &CommitFormat::Short {
460 |         out = String::new();
461 |         write!(
462 |             out,
463 |             "Date:   {}",
464 |             format_date(commit.author().when(), "%a %b %e %H:%M:%S %Y %z")
465 |         )
466 |         .map_err(|err| err.to_string())?;
467 |         append_wrapped(&mut out_vec, out, wrapping);
468 |     }
469 | 
470 |     if format == &CommitFormat::Short {
471 |         out_vec.push("".to_string());
472 |         append_wrapped(
473 |             &mut out_vec,
474 |             format!("    {}", commit.summary().unwrap_or("")),
475 |             wrapping,
476 |         );
477 |         out_vec.push("".to_string());
478 |     } else {
479 |         out_vec.push("".to_string());
480 |         let mut add_line = true;
481 |         for line in commit.message().unwrap_or("").lines() {
482 |             if line.is_empty() {
483 |                 out_vec.push(line.to_string());
484 |             } else {
485 |                 append_wrapped(&mut out_vec, format!("    {}", line), wrapping);
486 |             }
487 |             add_line = !line.trim().is_empty();
488 |         }
489 |         if add_line {
490 |             out_vec.push("".to_string());
491 |         }
492 |     }
493 | 
494 |     Ok(out_vec)
495 | }
496 | 
497 | pub fn format_date(time: Time, format: &str) -> String {
498 |     let offset = FixedOffset::east_opt(time.offset_minutes() * 60).expect("Invalid offset minutes");
499 |     let date = offset
500 |         .timestamp_opt(time.seconds(), 0)
501 |         .single()
502 |         .expect("Invalid timestamp, maybe a fold or gap in local time");
503 |     date.format(format).to_string()
504 | }
505 | 
506 | /// Format a time as a relative time string (e.g., "21 hours ago", "4 days ago")
507 | pub fn format_relative_time(time: Time) -> String {
508 |     let offset = FixedOffset::east_opt(time.offset_minutes() * 60).expect("Invalid offset minutes");
509 |     let commit_time = Local::from_offset(&offset)
510 |         .timestamp_opt(time.seconds(), 0)
511 |         .single()
512 |         .expect("Invalid timestamp");
513 |     let now = Local::now();
514 |     let duration = now.signed_duration_since(commit_time);
515 | 
516 |     let seconds = duration.num_seconds();
517 |     let minutes = duration.num_minutes();
518 |     let hours = duration.num_hours();
519 |     let days = duration.num_hours() / 24;
520 |     let weeks = days / 7;
521 |     let months = days / 30;
522 |     let years = days / 365;
523 | 
524 |     if seconds < 60 {
525 |         format!("{} seconds ago", seconds)
526 |     } else if minutes < 60 {
527 |         format!("{} minutes ago", minutes)
528 |     } else if hours < 24 {
529 |         format!("{} hours ago", hours)
530 |     } else if days < 7 {
531 |         format!("{} days ago", days)
532 |     } else if weeks < 4 {
533 |         format!("{} weeks ago", weeks)
534 |     } else if months < 12 {
535 |         format!("{} months ago", months)
536 |     } else {
537 |         format!("{} years ago", years)
538 |     }
539 | }
540 | 
541 | fn append_wrapped(vec: &mut Vec<String>, str: String, wrapping: &Option<Options>) {
542 |     if str.is_empty() {
543 |         vec.push(str);
544 |     } else if let Some(wrap) = wrapping {
545 |         vec.extend(
546 |             textwrap::fill(&str, wrap)
547 |                 .lines()
548 |                 .map(|str| str.to_string()),
549 |         )
550 |     } else {
551 |         vec.push(str);
552 |     }
553 | }
554 | 
555 | fn add_line(lines: &mut Vec<String>, line: &mut String, wrapping: &Option<Options>) {
556 |     let mut temp = String::new();
557 |     std::mem::swap(&mut temp, line);
558 |     append_wrapped(lines, temp, wrapping);
559 | }
560 | 
561 | fn remove_empty_lines(lines: &mut Vec<String>, mut line: String) -> String {
562 |     while !lines.is_empty() && lines.last().unwrap().is_empty() {
563 |         line = lines.remove(lines.len() - 1);
564 |     }
565 |     if !lines.is_empty() {
566 |         line = lines.remove(lines.len() - 1);
567 |     }
568 |     line
569 | }
570 | 


--------------------------------------------------------------------------------
/src/main.rs:
--------------------------------------------------------------------------------
  1 | //! Command line tool to show clear git graphs arranged for your branching model.
  2 | 
  3 | // Configure clippy to look for complex functions
  4 | #![warn(clippy::cognitive_complexity)]
  5 | #![warn(clippy::too_many_lines)]
  6 | 
  7 | use clap::ArgMatches;
  8 | use clap::{crate_version, Arg, Command};
  9 | use git2::Repository;
 10 | use git_graph::config::{
 11 |     create_config, get_available_models, get_model, get_model_name, set_model,
 12 | };
 13 | use git_graph::get_repo;
 14 | use git_graph::graph::GitGraph;
 15 | use git_graph::print::format::CommitFormat;
 16 | use git_graph::print::svg::print_svg;
 17 | use git_graph::print::unicode::print_unicode;
 18 | use git_graph::settings::{
 19 |     BranchOrder, BranchSettings, BranchSettingsDef, Characters, MergePatterns, Settings,
 20 | };
 21 | use platform_dirs::AppDirs;
 22 | use std::path::PathBuf;
 23 | use std::str::FromStr;
 24 | use std::time::Instant;
 25 | 
 26 | const REPO_CONFIG_FILE: &str = "git-graph.toml";
 27 | 
 28 | fn main() {
 29 |     std::process::exit(match from_args() {
 30 |         Ok(_) => 0,
 31 |         Err(err) => {
 32 |             eprintln!("{}", err);
 33 |             1
 34 |         }
 35 |     });
 36 | }
 37 | 
 38 | fn from_args() -> Result<(), String> {
 39 |     let mut ses = Session::new();
 40 |     store_default_models(&mut ses)?;
 41 | 
 42 |     let matches = match_args();
 43 |     if !configure_session(&mut ses, &matches)? {
 44 |         return Ok(()); // If the configuration decided session should not start
 45 |     };
 46 | 
 47 |     run(
 48 |         ses.repository.unwrap(),
 49 |         ses.settings.as_ref().unwrap(),
 50 |         ses.svg,
 51 |         ses.commit_limit,
 52 |     )
 53 | }
 54 | 
 55 | fn match_args() -> ArgMatches {
 56 |     // Declare command line argument interface for clap
 57 |     let app = Command::new("git-graph").version(crate_version!()).about(
 58 |         "Structured Git graphs for your branching model.\n    \
 59 |                  https://github.com/mlange-42/git-graph\n\
 60 |              \n\
 61 |              EXAMPES:\n    \
 62 |                  git-graph                   -> Show graph\n    \
 63 |                  git-graph --style round     -> Show graph in a different style\n    \
 64 |                  git-graph --model <model>   -> Show graph using a certain <model>\n    \
 65 |                  git-graph model --list      -> List available branching models\n    \
 66 |                  git-graph model             -> Show repo's current branching models\n    \
 67 |                  git-graph model <model>     -> Permanently set model <model> for this repo",
 68 |     );
 69 |     let app = add_repo_args(app);
 70 |     let app = add_model_args(app);
 71 |     let app = add_commit_limit_args(app);
 72 |     let app = add_color_args(app);
 73 |     let app = add_wrap_args(app);
 74 |     let app = add_format_args(app);
 75 | 
 76 |     let app = app
 77 |         .arg(
 78 |             Arg::new("reverse")
 79 |                 .long("reverse")
 80 |                 .short('r')
 81 |                 .help("Reverse the order of commits.")
 82 |                 .required(false)
 83 |                 .num_args(0),
 84 |         )
 85 |         .arg(
 86 |             Arg::new("local")
 87 |                 .long("local")
 88 |                 .short('l')
 89 |                 .help("Show only local branches, no remotes.")
 90 |                 .required(false)
 91 |                 .num_args(0),
 92 |         )
 93 |         .arg(
 94 |             Arg::new("svg")
 95 |                 .long("svg")
 96 |                 .help("Render graph as SVG instead of text-based.")
 97 |                 .required(false)
 98 |                 .num_args(0),
 99 |         )
100 |         .arg(
101 |             Arg::new("debug")
102 |                 .long("debug")
103 |                 .short('d')
104 |                 .help("Additional debug output and graphics.")
105 |                 .required(false)
106 |                 .num_args(0),
107 |         )
108 |         .arg(
109 |             Arg::new("sparse")
110 |                 .long("sparse")
111 |                 .short('S')
112 |                 .help(
113 |                     "Print a less compact graph: merge lines point to target lines\n\
114 |                        rather than merge commits.",
115 |                 )
116 |                 .required(false)
117 |                 .num_args(0),
118 |         )
119 |         .arg(
120 |             Arg::new("style")
121 |                 .long("style")
122 |                 .short('s')
123 |                 .help(
124 |                     "Output style. One of [normal/thin|round|bold|double|ascii].\n  \
125 |                          (First character can be used as abbreviation, e.g. '-s r')",
126 |                 )
127 |                 .required(false)
128 |                 .num_args(1),
129 |         );
130 | 
131 |     // Return match of declared arguments with what is present on command line
132 |     app.get_matches()
133 | }
134 | 
135 | /// Return true if session should continue, false if it should exit now
136 | fn configure_session(ses: &mut Session, matches: &ArgMatches) -> Result<bool, String> {
137 |     // return values
138 |     let exit_now = false;
139 |     let run_application = true;
140 | 
141 |     if match_model_list(ses, matches)? {
142 |         return Ok(exit_now); // Exit after showing model list
143 |     }
144 | 
145 |     match_repo_args(ses, matches)?;
146 | 
147 |     if match_model_subcommand(ses, matches)? {
148 |         return Ok(exit_now); // Exit after model subcommand
149 |     }
150 |     match_commit_limit_args(ses, matches)?;
151 | 
152 |     let include_remote = !matches.get_flag("local");
153 | 
154 |     let reverse_commit_order = matches.get_flag("reverse");
155 | 
156 |     ses.svg = matches.get_flag("svg");
157 |     let compact = !matches.get_flag("sparse");
158 |     let debug = matches.get_flag("debug");
159 |     let style = matches
160 |         .get_one::<String>("style")
161 |         .map(|s| Characters::from_str(s))
162 |         .unwrap_or_else(|| Ok(Characters::thin()))?;
163 | 
164 |     let style = if reverse_commit_order {
165 |         style.reverse()
166 |     } else {
167 |         style
168 |     };
169 | 
170 |     let model = match_model_opt(ses, matches)?;
171 | 
172 |     let format = match_format_args(ses, matches)?;
173 | 
174 |     let colored = match_color_args(ses, matches)?;
175 | 
176 |     let wrapping = match_wrap_args(ses, matches)?;
177 | 
178 |     let settings = Settings {
179 |         reverse_commit_order,
180 |         debug,
181 |         colored,
182 |         compact,
183 |         include_remote,
184 |         format,
185 |         wrapping,
186 |         characters: style,
187 |         branch_order: BranchOrder::ShortestFirst(true),
188 |         branches: BranchSettings::from(model).map_err(|err| err.to_string())?,
189 |         merge_patterns: MergePatterns::default(),
190 |     };
191 |     ses.settings = Some(settings);
192 | 
193 |     Ok(run_application)
194 | }
195 | 
196 | struct Session {
197 |     // models related fields
198 |     models_dir: PathBuf,
199 | 
200 |     // Settings related fields
201 |     pub settings: Option<Settings>,
202 | 
203 |     // Other fields
204 |     pub repository: Option<Repository>,
205 |     pub svg: bool,
206 |     pub commit_limit: Option<usize>,
207 | }
208 | 
209 | impl Session {
210 |     pub fn new() -> Self {
211 |         Self {
212 |             // models related fields
213 |             models_dir: PathBuf::new(),
214 | 
215 |             // Settings related fields
216 |             settings: None,
217 | 
218 |             // Other fields
219 |             repository: None,
220 |             svg: false,
221 |             commit_limit: None,
222 |         }
223 |     }
224 | }
225 | 
226 | fn add_repo_args(app: Command) -> Command {
227 |     app.arg(
228 |         Arg::new("path")
229 |             .long("path")
230 |             .short('p')
231 |             .help("Open repository from this path or above. Default '.'")
232 |             .required(false)
233 |             .num_args(1),
234 |     )
235 |     .arg(
236 |         Arg::new("skip-repo-owner-validation")
237 |             .long("skip-repo-owner-validation")
238 |             .help(
239 |                 "Skip owner validation for the repository.\n\
240 |                 This will turn off libgit2's owner validation, which may increase security risks.\n\
241 |                 Please do not disable this validation for repositories you do not trust.",
242 |             )
243 |             .required(false)
244 |             .num_args(0),
245 |     )
246 | }
247 | 
248 | fn match_repo_args(ses: &mut Session, matches: &ArgMatches) -> Result<(), String> {
249 |     let skip_repo_owner_validation = matches.get_flag("skip-repo-owner-validation");
250 |     if skip_repo_owner_validation {
251 |         println!("Warning: skip-repo-owner-validation is set! ");
252 |     }
253 |     let default_path = ".".to_string();
254 |     let path = matches.get_one::<String>("path").unwrap_or(&default_path);
255 |     let repository = get_repo(path, skip_repo_owner_validation)
256 |         .map_err(|err| format!("ERROR: {}\n       Navigate into a repository before running git-graph, or use option --path", err.message()))?;
257 | 
258 |     ses.repository = Some(repository);
259 |     Ok(())
260 | }
261 | 
262 | //
263 | //  "model" subcommand
264 | //
265 | 
266 | /// Fill APP_dir/git-graph folder with default models
267 | fn store_default_models(ses: &mut Session) -> Result<(), String> {
268 |     let app_dir = AppDirs::new(Some("git-graph"), false).unwrap().config_dir;
269 |     let mut models_dir = app_dir;
270 |     models_dir.push("models");
271 | 
272 |     create_config(&models_dir)?;
273 | 
274 |     ses.models_dir = models_dir;
275 |     Ok(())
276 | }
277 | 
278 | fn add_model_args(app: Command) -> Command {
279 |     app
280 |         .arg(
281 |             Arg::new("model")
282 |                 .long("model")
283 |                 .short('m')
284 |                 .help("Branching model. Available presets are [simple|git-flow|none].\n\
285 |                        Default: git-flow. \n\
286 |                        Permanently set the model for a repository with\n\
287 |                          > git-graph model <model>")
288 |                 .required(false)
289 |                 .num_args(1),
290 |         )
291 |         .subcommand(Command::new("model")
292 |         .about("Prints or permanently sets the branching model for a repository.")
293 |         .arg(
294 |             Arg::new("model")
295 |                 .help("The branching model to be used. Available presets are [simple|git-flow|none].\n\
296 |                         When not given, prints the currently set model.")
297 |                 .value_name("model")
298 |                 .num_args(1)
299 |                 .required(false)
300 |                 .index(1))
301 |         .arg(
302 |             Arg::new("list")
303 |                 .long("list")
304 |                 .short('l')
305 |                 .help("List all available branching models.")
306 |                 .required(false)
307 |                 .num_args(0),
308 |     ))
309 | }
310 | 
311 | fn match_model_list(ses: &mut Session, matches: &ArgMatches) -> Result<bool, String> {
312 |     if let Some(matches) = matches.subcommand_matches("model") {
313 |         if matches.get_flag("list") {
314 |             println!(
315 |                 "{}",
316 |                 itertools::join(get_available_models(&ses.models_dir)?, "\n")
317 |             );
318 |             return Ok(true);
319 |         }
320 |     }
321 |     Ok(false)
322 | }
323 | 
324 | fn match_model_subcommand(ses: &mut Session, matches: &ArgMatches) -> Result<bool, String> {
325 |     if let Some(matches) = matches.subcommand_matches("model") {
326 |         let repository = ses.repository.as_ref().unwrap();
327 |         match matches.get_one::<String>("model") {
328 |             None => {
329 |                 let curr_model = get_model_name(repository, REPO_CONFIG_FILE)?;
330 |                 match curr_model {
331 |                     None => print!("No branching model set"),
332 |                     Some(model) => print!("{}", model),
333 |                 }
334 |             }
335 |             Some(model) => {
336 |                 set_model(repository, model, REPO_CONFIG_FILE, &ses.models_dir)?;
337 |                 eprint!("Branching model set to '{}'", model);
338 |             }
339 |         };
340 |         return Ok(true);
341 |     }
342 |     Ok(false)
343 | }
344 | 
345 | fn match_model_opt(ses: &mut Session, matches: &ArgMatches) -> Result<BranchSettingsDef, String> {
346 |     let model = get_model(
347 |         ses.repository.as_ref().unwrap(),
348 |         matches.get_one::<String>("model").map(|s| &s[..]),
349 |         REPO_CONFIG_FILE,
350 |         &ses.models_dir,
351 |     )?;
352 |     Ok(model)
353 | }
354 | 
355 | //
356 | //  commit_limit flag
357 | //
358 | 
359 | fn add_commit_limit_args(app: Command) -> Command {
360 |     app.arg(
361 |         Arg::new("max-count")
362 |             .long("max-count")
363 |             .short('n')
364 |             .help("Maximum number of commits")
365 |             .required(false)
366 |             .num_args(1)
367 |             .value_name("n"),
368 |     )
369 | }
370 | 
371 | fn match_commit_limit_args(ses: &mut Session, matches: &ArgMatches) -> Result<(), String> {
372 |     ses.commit_limit = match matches.get_one::<String>("max-count") {
373 |         None => None,
374 |         Some(str) => match str.parse::<usize>() {
375 |             Ok(val) => Some(val),
376 |             Err(_) => {
377 |                 return Err(format![
378 |                     "Option max-count must be a positive number, but got '{}'",
379 |                     str
380 |                 ])
381 |             }
382 |         },
383 |     };
384 | 
385 |     Ok(())
386 | }
387 | 
388 | //
389 | //  color flag
390 | //
391 | 
392 | fn add_color_args(app: Command) -> Command {
393 |     app.arg(
394 |         Arg::new("color")
395 |             .long("color")
396 |             .help(
397 |                 "Specify when colors should be used. One of [auto|always|never].\n\
398 |                        Default: auto.",
399 |             )
400 |             .required(false)
401 |             .num_args(1),
402 |     )
403 |     .arg(
404 |         Arg::new("no-color")
405 |             .long("no-color")
406 |             .help(
407 |                 "Print without colors. Missing color support should be detected\n\
408 |                        automatically (e.g. when piping to a file).\n\
409 |                        Overrides option '--color'",
410 |             )
411 |             .required(false)
412 |             .num_args(0),
413 |     )
414 | }
415 | 
416 | fn match_color_args(_ses: &mut Session, matches: &ArgMatches) -> Result<bool, String> {
417 |     let colored = if matches.get_flag("no-color") {
418 |         false
419 |     } else if let Some(mode) = matches.get_one::<String>("color") {
420 |         match &mode[..] {
421 |             "auto" => {
422 |                 atty::is(atty::Stream::Stdout)
423 |                     && (!cfg!(windows) || {
424 |                         yansi::enable();
425 |                         yansi::is_enabled()
426 |                     })
427 |             }
428 |             "always" => {
429 |                 if cfg!(windows) {
430 |                     yansi::enable();
431 |                 }
432 |                 true
433 |             }
434 |             "never" => false,
435 |             other => {
436 |                 return Err(format!(
437 |                     "Unknown color mode '{}'. Supports [auto|always|never].",
438 |                     other
439 |                 ))
440 |             }
441 |         }
442 |     } else {
443 |         atty::is(atty::Stream::Stdout)
444 |             && (!cfg!(windows) || {
445 |                 yansi::enable();
446 |                 yansi::is_enabled()
447 |             })
448 |     };
449 | 
450 |     Ok(colored)
451 | }
452 | 
453 | //
454 | //  wrap flag
455 | //
456 | 
457 | fn add_wrap_args(app: Command) -> Command {
458 |     app.arg(
459 |         Arg::new("wrap")
460 |             .long("wrap")
461 |             .short('w')
462 |             .help(
463 |                 "Line wrapping for formatted commit text. Default: 'auto 0 8'\n\
464 |                        Argument format: [<width>|auto|none[ <indent1>[ <indent2>]]]\n\
465 |                        For examples, consult 'git-graph --help'",
466 |             )
467 |             .long_help(
468 |                 "Line wrapping for formatted commit text. Default: 'auto 0 8'\n\
469 |                        Argument format: [<width>|auto|none[ <indent1>[ <indent2>]]]\n\
470 |                        Examples:\n    \
471 |                            git-graph --wrap auto\n    \
472 |                            git-graph --wrap auto 0 8\n    \
473 |                            git-graph --wrap none\n    \
474 |                            git-graph --wrap 80\n    \
475 |                            git-graph --wrap 80 0 8\n\
476 |                        'auto' uses the terminal's width if on a terminal.",
477 |             )
478 |             .required(false)
479 |             .num_args(0..=3),
480 |     )
481 | }
482 | 
483 | type WrapType = Option<(Option<usize>, Option<usize>, Option<usize>)>;
484 | fn match_wrap_args(_ses: &mut Session, matches: &ArgMatches) -> Result<WrapType, String> {
485 |     let wrapping = if let Some(wrap_values) = matches.get_many::<String>("wrap") {
486 |         let strings = wrap_values.map(|s| s.as_str()).collect::<Vec<_>>();
487 |         if strings.is_empty() {
488 |             Some((None, Some(0), Some(8)))
489 |         } else {
490 |             match strings[0] {
491 |                 "none" => None,
492 |                 "auto" => {
493 |                     let wrap = strings
494 |                         .iter()
495 |                         .skip(1)
496 |                         .map(|str| str.parse::<usize>())
497 |                         .collect::<Result<Vec<_>, _>>()
498 |                         .map_err(|_| {
499 |                             format!(
500 |                                 "ERROR: Can't parse option --wrap '{}' to integers.",
501 |                                 strings.join(" ")
502 |                             )
503 |                         })?;
504 |                     Some((None, wrap.first().cloned(), wrap.get(1).cloned()))
505 |                 }
506 |                 _ => {
507 |                     let wrap = strings
508 |                         .iter()
509 |                         .map(|str| str.parse::<usize>())
510 |                         .collect::<Result<Vec<_>, _>>()
511 |                         .map_err(|_| {
512 |                             format!(
513 |                                 "ERROR: Can't parse option --wrap '{}' to integers.",
514 |                                 strings.join(" ")
515 |                             )
516 |                         })?;
517 |                     Some((
518 |                         wrap.first().cloned(),
519 |                         wrap.get(1).cloned(),
520 |                         wrap.get(2).cloned(),
521 |                     ))
522 |                 }
523 |             }
524 |         }
525 |     } else {
526 |         Some((None, Some(0), Some(8)))
527 |     };
528 | 
529 |     Ok(wrapping)
530 | }
531 | 
532 | //
533 | //  commit format flags - format
534 | //
535 | 
536 | fn add_format_args(app: Command) -> Command {
537 |     app
538 |         .arg(
539 |             Arg::new("format")
540 |                 .long("format")
541 |                 .short('f')
542 |                 .help("Commit format. One of [oneline|short|medium|full|\"<string>\"].\n  \
543 |                          (First character can be used as abbreviation, e.g. '-f m')\n\
544 |                        Default: oneline.\n\
545 |                        For placeholders supported in \"<string>\", consult 'git-graph --help'")
546 |                 .long_help("Commit format. One of [oneline|short|medium|full|\"<string>\"].\n  \
547 |                               (First character can be used as abbreviation, e.g. '-f m')\n\
548 |                             Formatting placeholders for \"<string>\":\n    \
549 |                                 %n    newline\n    \
550 |                                 %H    commit hash\n    \
551 |                                 %h    abbreviated commit hash\n    \
552 |                                 %P    parent commit hashes\n    \
553 |                                 %p    abbreviated parent commit hashes\n    \
554 |                                 %d    refs (branches, tags)\n    \
555 |                                 %s    commit summary\n    \
556 |                                 %b    commit message body\n    \
557 |                                 %B    raw body (subject and body)\n    \
558 |                                 %an   author name\n    \
559 |                                 %ae   author email\n    \
560 |                                 %ad   author date\n    \
561 |                                 %as   author date in short format 'YYYY-MM-DD'\n    \
562 |                                 %cn   committer name\n    \
563 |                                 %ce   committer email\n    \
564 |                                 %cd   committer date\n    \
565 |                                 %cs   committer date in short format 'YYYY-MM-DD'\n    \
566 |                                 \n    \
567 |                                 If you add a + (plus sign) after % of a placeholder,\n       \
568 |                                    a line-feed is inserted immediately before the expansion if\n       \
569 |                                    and only if the placeholder expands to a non-empty string.\n    \
570 |                                 If you add a - (minus sign) after % of a placeholder, all\n       \
571 |                                    consecutive line-feeds immediately preceding the expansion are\n       \
572 |                                    deleted if and only if the placeholder expands to an empty string.\n    \
573 |                                 If you add a ' ' (space) after % of a placeholder, a space is\n       \
574 |                                    inserted immediately before the expansion if and only if\n       \
575 |                                    the placeholder expands to a non-empty string.\n\
576 |                             \n    \
577 |                                 See also the respective git help: https://git-scm.com/docs/pretty-formats\n")
578 |                 .required(false)
579 |                 .num_args(1),
580 |         )
581 | }
582 | 
583 | fn match_format_args(_ses: &mut Session, matches: &ArgMatches) -> Result<CommitFormat, String> {
584 |     let format = match matches.get_one::<String>("format") {
585 |         None => CommitFormat::OneLine,
586 |         Some(str) => CommitFormat::from_str(str)?,
587 |     };
588 |     Ok(format)
589 | }
590 | 
591 | //
592 | //  Run application
593 | //
594 | 
595 | fn run(
596 |     repository: Repository,
597 |     settings: &Settings,
598 |     svg: bool,
599 |     max_commits: Option<usize>,
600 | ) -> Result<(), String> {
601 |     let now = Instant::now();
602 |     let graph = GitGraph::new(repository, settings, None, max_commits)?;
603 | 
604 |     let duration_graph = now.elapsed().as_micros();
605 | 
606 |     if settings.debug {
607 |         for branch in &graph.all_branches {
608 |             eprintln!(
609 |                 "{} (col {}) ({:?}) {} s: {:?}, t: {:?}",
610 |                 branch.name,
611 |                 branch.visual.column.unwrap_or(99),
612 |                 branch.range,
613 |                 if branch.is_merged { "m" } else { "" },
614 |                 branch.visual.source_order_group,
615 |                 branch.visual.target_order_group
616 |             );
617 |         }
618 |     }
619 | 
620 |     let now = Instant::now();
621 | 
622 |     if svg {
623 |         println!("{}", print_svg(&graph, settings)?);
624 |     } else {
625 |         let (g_lines, t_lines, _indices) = print_unicode(&graph, settings)?;
626 |         print_unpaged(&g_lines, &t_lines);
627 |     };
628 | 
629 |     let duration_print = now.elapsed().as_micros();
630 | 
631 |     if settings.debug {
632 |         eprintln!(
633 |             "Graph construction: {:.1} ms, printing: {:.1} ms ({} commits)",
634 |             duration_graph as f32 / 1000.0,
635 |             duration_print as f32 / 1000.0,
636 |             graph.commits.len()
637 |         );
638 |     }
639 |     Ok(())
640 | }
641 | 
642 | /// Print the graph, un-paged.
643 | fn print_unpaged(graph_lines: &[String], text_lines: &[String]) {
644 |     for (g_line, t_line) in graph_lines.iter().zip(text_lines.iter()) {
645 |         println!(" {}  {}", g_line, t_line);
646 |     }
647 | }
648 | 


--------------------------------------------------------------------------------
/Cargo.lock:
--------------------------------------------------------------------------------
   1 | # This file is automatically @generated by Cargo.
   2 | # It is not intended for manual editing.
   3 | version = 4
   4 | 
   5 | [[package]]
   6 | name = "aho-corasick"
   7 | version = "1.1.4"
   8 | source = "registry+https://github.com/rust-lang/crates.io-index"
   9 | checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
  10 | dependencies = [
  11 |  "memchr",
  12 | ]
  13 | 
  14 | [[package]]
  15 | name = "android_system_properties"
  16 | version = "0.1.5"
  17 | source = "registry+https://github.com/rust-lang/crates.io-index"
  18 | checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
  19 | dependencies = [
  20 |  "libc",
  21 | ]
  22 | 
  23 | [[package]]
  24 | name = "anstream"
  25 | version = "0.6.21"
  26 | source = "registry+https://github.com/rust-lang/crates.io-index"
  27 | checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
  28 | dependencies = [
  29 |  "anstyle",
  30 |  "anstyle-parse",
  31 |  "anstyle-query",
  32 |  "anstyle-wincon",
  33 |  "colorchoice",
  34 |  "is_terminal_polyfill",
  35 |  "utf8parse",
  36 | ]
  37 | 
  38 | [[package]]
  39 | name = "anstyle"
  40 | version = "1.0.13"
  41 | source = "registry+https://github.com/rust-lang/crates.io-index"
  42 | checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78"
  43 | 
  44 | [[package]]
  45 | name = "anstyle-parse"
  46 | version = "0.2.7"
  47 | source = "registry+https://github.com/rust-lang/crates.io-index"
  48 | checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
  49 | dependencies = [
  50 |  "utf8parse",
  51 | ]
  52 | 
  53 | [[package]]
  54 | name = "anstyle-query"
  55 | version = "1.1.4"
  56 | source = "registry+https://github.com/rust-lang/crates.io-index"
  57 | checksum = "9e231f6134f61b71076a3eab506c379d4f36122f2af15a9ff04415ea4c3339e2"
  58 | dependencies = [
  59 |  "windows-sys 0.60.2",
  60 | ]
  61 | 
  62 | [[package]]
  63 | name = "anstyle-wincon"
  64 | version = "3.0.10"
  65 | source = "registry+https://github.com/rust-lang/crates.io-index"
  66 | checksum = "3e0633414522a32ffaac8ac6cc8f748e090c5717661fddeea04219e2344f5f2a"
  67 | dependencies = [
  68 |  "anstyle",
  69 |  "once_cell_polyfill",
  70 |  "windows-sys 0.60.2",
  71 | ]
  72 | 
  73 | [[package]]
  74 | name = "atty"
  75 | version = "0.2.14"
  76 | source = "registry+https://github.com/rust-lang/crates.io-index"
  77 | checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
  78 | dependencies = [
  79 |  "hermit-abi",
  80 |  "libc",
  81 |  "winapi",
  82 | ]
  83 | 
  84 | [[package]]
  85 | name = "autocfg"
  86 | version = "1.5.0"
  87 | source = "registry+https://github.com/rust-lang/crates.io-index"
  88 | checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
  89 | 
  90 | [[package]]
  91 | name = "bitflags"
  92 | version = "2.10.0"
  93 | source = "registry+https://github.com/rust-lang/crates.io-index"
  94 | checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
  95 | 
  96 | [[package]]
  97 | name = "bumpalo"
  98 | version = "3.19.0"
  99 | source = "registry+https://github.com/rust-lang/crates.io-index"
 100 | checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
 101 | 
 102 | [[package]]
 103 | name = "cc"
 104 | version = "1.2.45"
 105 | source = "registry+https://github.com/rust-lang/crates.io-index"
 106 | checksum = "35900b6c8d709fb1d854671ae27aeaa9eec2f8b01b364e1619a40da3e6fe2afe"
 107 | dependencies = [
 108 |  "find-msvc-tools",
 109 |  "jobserver",
 110 |  "libc",
 111 |  "shlex",
 112 | ]
 113 | 
 114 | [[package]]
 115 | name = "cfg-if"
 116 | version = "1.0.4"
 117 | source = "registry+https://github.com/rust-lang/crates.io-index"
 118 | checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 119 | 
 120 | [[package]]
 121 | name = "chrono"
 122 | version = "0.4.42"
 123 | source = "registry+https://github.com/rust-lang/crates.io-index"
 124 | checksum = "145052bdd345b87320e369255277e3fb5152762ad123a901ef5c262dd38fe8d2"
 125 | dependencies = [
 126 |  "iana-time-zone",
 127 |  "js-sys",
 128 |  "num-traits",
 129 |  "wasm-bindgen",
 130 |  "windows-link",
 131 | ]
 132 | 
 133 | [[package]]
 134 | name = "clap"
 135 | version = "4.5.51"
 136 | source = "registry+https://github.com/rust-lang/crates.io-index"
 137 | checksum = "4c26d721170e0295f191a69bd9a1f93efcdb0aff38684b61ab5750468972e5f5"
 138 | dependencies = [
 139 |  "clap_builder",
 140 | ]
 141 | 
 142 | [[package]]
 143 | name = "clap_builder"
 144 | version = "4.5.51"
 145 | source = "registry+https://github.com/rust-lang/crates.io-index"
 146 | checksum = "75835f0c7bf681bfd05abe44e965760fea999a5286c6eb2d59883634fd02011a"
 147 | dependencies = [
 148 |  "anstream",
 149 |  "anstyle",
 150 |  "clap_lex",
 151 |  "strsim",
 152 | ]
 153 | 
 154 | [[package]]
 155 | name = "clap_lex"
 156 | version = "0.7.6"
 157 | source = "registry+https://github.com/rust-lang/crates.io-index"
 158 | checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
 159 | 
 160 | [[package]]
 161 | name = "colorchoice"
 162 | version = "1.0.4"
 163 | source = "registry+https://github.com/rust-lang/crates.io-index"
 164 | checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
 165 | 
 166 | [[package]]
 167 | name = "convert_case"
 168 | version = "0.7.1"
 169 | source = "registry+https://github.com/rust-lang/crates.io-index"
 170 | checksum = "bb402b8d4c85569410425650ce3eddc7d698ed96d39a73f941b08fb63082f1e7"
 171 | dependencies = [
 172 |  "unicode-segmentation",
 173 | ]
 174 | 
 175 | [[package]]
 176 | name = "core-foundation-sys"
 177 | version = "0.8.7"
 178 | source = "registry+https://github.com/rust-lang/crates.io-index"
 179 | checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 180 | 
 181 | [[package]]
 182 | name = "crossterm"
 183 | version = "0.29.0"
 184 | source = "registry+https://github.com/rust-lang/crates.io-index"
 185 | checksum = "d8b9f2e4c67f833b660cdb0a3523065869fb35570177239812ed4c905aeff87b"
 186 | dependencies = [
 187 |  "bitflags",
 188 |  "crossterm_winapi",
 189 |  "derive_more",
 190 |  "document-features",
 191 |  "mio",
 192 |  "parking_lot",
 193 |  "rustix",
 194 |  "signal-hook",
 195 |  "signal-hook-mio",
 196 |  "winapi",
 197 | ]
 198 | 
 199 | [[package]]
 200 | name = "crossterm_winapi"
 201 | version = "0.9.1"
 202 | source = "registry+https://github.com/rust-lang/crates.io-index"
 203 | checksum = "acdd7c62a3665c7f6830a51635d9ac9b23ed385797f70a83bb8bafe9c572ab2b"
 204 | dependencies = [
 205 |  "winapi",
 206 | ]
 207 | 
 208 | [[package]]
 209 | name = "derive_more"
 210 | version = "2.0.1"
 211 | source = "registry+https://github.com/rust-lang/crates.io-index"
 212 | checksum = "093242cf7570c207c83073cf82f79706fe7b8317e98620a47d5be7c3d8497678"
 213 | dependencies = [
 214 |  "derive_more-impl",
 215 | ]
 216 | 
 217 | [[package]]
 218 | name = "derive_more-impl"
 219 | version = "2.0.1"
 220 | source = "registry+https://github.com/rust-lang/crates.io-index"
 221 | checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
 222 | dependencies = [
 223 |  "convert_case",
 224 |  "proc-macro2",
 225 |  "quote",
 226 |  "syn",
 227 | ]
 228 | 
 229 | [[package]]
 230 | name = "dirs-next"
 231 | version = "1.0.2"
 232 | source = "registry+https://github.com/rust-lang/crates.io-index"
 233 | checksum = "cf36e65a80337bea855cd4ef9b8401ffce06a7baedf2e85ec467b1ac3f6e82b6"
 234 | dependencies = [
 235 |  "cfg-if",
 236 |  "dirs-sys-next",
 237 | ]
 238 | 
 239 | [[package]]
 240 | name = "dirs-sys-next"
 241 | version = "0.1.2"
 242 | source = "registry+https://github.com/rust-lang/crates.io-index"
 243 | checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
 244 | dependencies = [
 245 |  "libc",
 246 |  "redox_users",
 247 |  "winapi",
 248 | ]
 249 | 
 250 | [[package]]
 251 | name = "displaydoc"
 252 | version = "0.2.5"
 253 | source = "registry+https://github.com/rust-lang/crates.io-index"
 254 | checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
 255 | dependencies = [
 256 |  "proc-macro2",
 257 |  "quote",
 258 |  "syn",
 259 | ]
 260 | 
 261 | [[package]]
 262 | name = "document-features"
 263 | version = "0.2.12"
 264 | source = "registry+https://github.com/rust-lang/crates.io-index"
 265 | checksum = "d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61"
 266 | dependencies = [
 267 |  "litrs",
 268 | ]
 269 | 
 270 | [[package]]
 271 | name = "either"
 272 | version = "1.15.0"
 273 | source = "registry+https://github.com/rust-lang/crates.io-index"
 274 | checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
 275 | 
 276 | [[package]]
 277 | name = "equivalent"
 278 | version = "1.0.2"
 279 | source = "registry+https://github.com/rust-lang/crates.io-index"
 280 | checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 281 | 
 282 | [[package]]
 283 | name = "errno"
 284 | version = "0.3.14"
 285 | source = "registry+https://github.com/rust-lang/crates.io-index"
 286 | checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 287 | dependencies = [
 288 |  "libc",
 289 |  "windows-sys 0.61.2",
 290 | ]
 291 | 
 292 | [[package]]
 293 | name = "find-msvc-tools"
 294 | version = "0.1.4"
 295 | source = "registry+https://github.com/rust-lang/crates.io-index"
 296 | checksum = "52051878f80a721bb68ebfbc930e07b65ba72f2da88968ea5c06fd6ca3d3a127"
 297 | 
 298 | [[package]]
 299 | name = "form_urlencoded"
 300 | version = "1.2.2"
 301 | source = "registry+https://github.com/rust-lang/crates.io-index"
 302 | checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
 303 | dependencies = [
 304 |  "percent-encoding",
 305 | ]
 306 | 
 307 | [[package]]
 308 | name = "getrandom"
 309 | version = "0.2.16"
 310 | source = "registry+https://github.com/rust-lang/crates.io-index"
 311 | checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
 312 | dependencies = [
 313 |  "cfg-if",
 314 |  "libc",
 315 |  "wasi",
 316 | ]
 317 | 
 318 | [[package]]
 319 | name = "getrandom"
 320 | version = "0.3.4"
 321 | source = "registry+https://github.com/rust-lang/crates.io-index"
 322 | checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
 323 | dependencies = [
 324 |  "cfg-if",
 325 |  "libc",
 326 |  "r-efi",
 327 |  "wasip2",
 328 | ]
 329 | 
 330 | [[package]]
 331 | name = "git-graph"
 332 | version = "0.7.0"
 333 | dependencies = [
 334 |  "atty",
 335 |  "chrono",
 336 |  "clap",
 337 |  "crossterm",
 338 |  "git2",
 339 |  "itertools",
 340 |  "lazy_static",
 341 |  "platform-dirs",
 342 |  "regex",
 343 |  "serde",
 344 |  "serde_derive",
 345 |  "svg",
 346 |  "textwrap",
 347 |  "toml",
 348 |  "yansi",
 349 | ]
 350 | 
 351 | [[package]]
 352 | name = "git2"
 353 | version = "0.20.2"
 354 | source = "registry+https://github.com/rust-lang/crates.io-index"
 355 | checksum = "2deb07a133b1520dc1a5690e9bd08950108873d7ed5de38dcc74d3b5ebffa110"
 356 | dependencies = [
 357 |  "bitflags",
 358 |  "libc",
 359 |  "libgit2-sys",
 360 |  "log",
 361 |  "url",
 362 | ]
 363 | 
 364 | [[package]]
 365 | name = "hashbrown"
 366 | version = "0.16.0"
 367 | source = "registry+https://github.com/rust-lang/crates.io-index"
 368 | checksum = "5419bdc4f6a9207fbeba6d11b604d481addf78ecd10c11ad51e76c2f6482748d"
 369 | 
 370 | [[package]]
 371 | name = "hermit-abi"
 372 | version = "0.1.19"
 373 | source = "registry+https://github.com/rust-lang/crates.io-index"
 374 | checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
 375 | dependencies = [
 376 |  "libc",
 377 | ]
 378 | 
 379 | [[package]]
 380 | name = "iana-time-zone"
 381 | version = "0.1.64"
 382 | source = "registry+https://github.com/rust-lang/crates.io-index"
 383 | checksum = "33e57f83510bb73707521ebaffa789ec8caf86f9657cad665b092b581d40e9fb"
 384 | dependencies = [
 385 |  "android_system_properties",
 386 |  "core-foundation-sys",
 387 |  "iana-time-zone-haiku",
 388 |  "js-sys",
 389 |  "log",
 390 |  "wasm-bindgen",
 391 |  "windows-core",
 392 | ]
 393 | 
 394 | [[package]]
 395 | name = "iana-time-zone-haiku"
 396 | version = "0.1.2"
 397 | source = "registry+https://github.com/rust-lang/crates.io-index"
 398 | checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
 399 | dependencies = [
 400 |  "cc",
 401 | ]
 402 | 
 403 | [[package]]
 404 | name = "icu_collections"
 405 | version = "2.1.1"
 406 | source = "registry+https://github.com/rust-lang/crates.io-index"
 407 | checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
 408 | dependencies = [
 409 |  "displaydoc",
 410 |  "potential_utf",
 411 |  "yoke",
 412 |  "zerofrom",
 413 |  "zerovec",
 414 | ]
 415 | 
 416 | [[package]]
 417 | name = "icu_locale_core"
 418 | version = "2.1.1"
 419 | source = "registry+https://github.com/rust-lang/crates.io-index"
 420 | checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
 421 | dependencies = [
 422 |  "displaydoc",
 423 |  "litemap",
 424 |  "tinystr",
 425 |  "writeable",
 426 |  "zerovec",
 427 | ]
 428 | 
 429 | [[package]]
 430 | name = "icu_normalizer"
 431 | version = "2.1.1"
 432 | source = "registry+https://github.com/rust-lang/crates.io-index"
 433 | checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
 434 | dependencies = [
 435 |  "icu_collections",
 436 |  "icu_normalizer_data",
 437 |  "icu_properties",
 438 |  "icu_provider",
 439 |  "smallvec",
 440 |  "zerovec",
 441 | ]
 442 | 
 443 | [[package]]
 444 | name = "icu_normalizer_data"
 445 | version = "2.1.1"
 446 | source = "registry+https://github.com/rust-lang/crates.io-index"
 447 | checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
 448 | 
 449 | [[package]]
 450 | name = "icu_properties"
 451 | version = "2.1.1"
 452 | source = "registry+https://github.com/rust-lang/crates.io-index"
 453 | checksum = "e93fcd3157766c0c8da2f8cff6ce651a31f0810eaa1c51ec363ef790bbb5fb99"
 454 | dependencies = [
 455 |  "icu_collections",
 456 |  "icu_locale_core",
 457 |  "icu_properties_data",
 458 |  "icu_provider",
 459 |  "zerotrie",
 460 |  "zerovec",
 461 | ]
 462 | 
 463 | [[package]]
 464 | name = "icu_properties_data"
 465 | version = "2.1.1"
 466 | source = "registry+https://github.com/rust-lang/crates.io-index"
 467 | checksum = "02845b3647bb045f1100ecd6480ff52f34c35f82d9880e029d329c21d1054899"
 468 | 
 469 | [[package]]
 470 | name = "icu_provider"
 471 | version = "2.1.1"
 472 | source = "registry+https://github.com/rust-lang/crates.io-index"
 473 | checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
 474 | dependencies = [
 475 |  "displaydoc",
 476 |  "icu_locale_core",
 477 |  "writeable",
 478 |  "yoke",
 479 |  "zerofrom",
 480 |  "zerotrie",
 481 |  "zerovec",
 482 | ]
 483 | 
 484 | [[package]]
 485 | name = "idna"
 486 | version = "1.1.0"
 487 | source = "registry+https://github.com/rust-lang/crates.io-index"
 488 | checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
 489 | dependencies = [
 490 |  "idna_adapter",
 491 |  "smallvec",
 492 |  "utf8_iter",
 493 | ]
 494 | 
 495 | [[package]]
 496 | name = "idna_adapter"
 497 | version = "1.2.1"
 498 | source = "registry+https://github.com/rust-lang/crates.io-index"
 499 | checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
 500 | dependencies = [
 501 |  "icu_normalizer",
 502 |  "icu_properties",
 503 | ]
 504 | 
 505 | [[package]]
 506 | name = "indexmap"
 507 | version = "2.12.0"
 508 | source = "registry+https://github.com/rust-lang/crates.io-index"
 509 | checksum = "6717a8d2a5a929a1a2eb43a12812498ed141a0bcfb7e8f7844fbdbe4303bba9f"
 510 | dependencies = [
 511 |  "equivalent",
 512 |  "hashbrown",
 513 | ]
 514 | 
 515 | [[package]]
 516 | name = "is_terminal_polyfill"
 517 | version = "1.70.2"
 518 | source = "registry+https://github.com/rust-lang/crates.io-index"
 519 | checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
 520 | 
 521 | [[package]]
 522 | name = "itertools"
 523 | version = "0.14.0"
 524 | source = "registry+https://github.com/rust-lang/crates.io-index"
 525 | checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
 526 | dependencies = [
 527 |  "either",
 528 | ]
 529 | 
 530 | [[package]]
 531 | name = "jobserver"
 532 | version = "0.1.34"
 533 | source = "registry+https://github.com/rust-lang/crates.io-index"
 534 | checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
 535 | dependencies = [
 536 |  "getrandom 0.3.4",
 537 |  "libc",
 538 | ]
 539 | 
 540 | [[package]]
 541 | name = "js-sys"
 542 | version = "0.3.82"
 543 | source = "registry+https://github.com/rust-lang/crates.io-index"
 544 | checksum = "b011eec8cc36da2aab2d5cff675ec18454fad408585853910a202391cf9f8e65"
 545 | dependencies = [
 546 |  "once_cell",
 547 |  "wasm-bindgen",
 548 | ]
 549 | 
 550 | [[package]]
 551 | name = "lazy_static"
 552 | version = "1.5.0"
 553 | source = "registry+https://github.com/rust-lang/crates.io-index"
 554 | checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 555 | 
 556 | [[package]]
 557 | name = "libc"
 558 | version = "0.2.177"
 559 | source = "registry+https://github.com/rust-lang/crates.io-index"
 560 | checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"
 561 | 
 562 | [[package]]
 563 | name = "libgit2-sys"
 564 | version = "0.18.2+1.9.1"
 565 | source = "registry+https://github.com/rust-lang/crates.io-index"
 566 | checksum = "1c42fe03df2bd3c53a3a9c7317ad91d80c81cd1fb0caec8d7cc4cd2bfa10c222"
 567 | dependencies = [
 568 |  "cc",
 569 |  "libc",
 570 |  "libz-sys",
 571 |  "pkg-config",
 572 | ]
 573 | 
 574 | [[package]]
 575 | name = "libredox"
 576 | version = "0.1.10"
 577 | source = "registry+https://github.com/rust-lang/crates.io-index"
 578 | checksum = "416f7e718bdb06000964960ffa43b4335ad4012ae8b99060261aa4a8088d5ccb"
 579 | dependencies = [
 580 |  "bitflags",
 581 |  "libc",
 582 | ]
 583 | 
 584 | [[package]]
 585 | name = "libz-sys"
 586 | version = "1.1.22"
 587 | source = "registry+https://github.com/rust-lang/crates.io-index"
 588 | checksum = "8b70e7a7df205e92a1a4cd9aaae7898dac0aa555503cc0a649494d0d60e7651d"
 589 | dependencies = [
 590 |  "cc",
 591 |  "libc",
 592 |  "pkg-config",
 593 |  "vcpkg",
 594 | ]
 595 | 
 596 | [[package]]
 597 | name = "linux-raw-sys"
 598 | version = "0.11.0"
 599 | source = "registry+https://github.com/rust-lang/crates.io-index"
 600 | checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
 601 | 
 602 | [[package]]
 603 | name = "litemap"
 604 | version = "0.8.1"
 605 | source = "registry+https://github.com/rust-lang/crates.io-index"
 606 | checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
 607 | 
 608 | [[package]]
 609 | name = "litrs"
 610 | version = "1.0.0"
 611 | source = "registry+https://github.com/rust-lang/crates.io-index"
 612 | checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092"
 613 | 
 614 | [[package]]
 615 | name = "lock_api"
 616 | version = "0.4.14"
 617 | source = "registry+https://github.com/rust-lang/crates.io-index"
 618 | checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
 619 | dependencies = [
 620 |  "scopeguard",
 621 | ]
 622 | 
 623 | [[package]]
 624 | name = "log"
 625 | version = "0.4.28"
 626 | source = "registry+https://github.com/rust-lang/crates.io-index"
 627 | checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
 628 | 
 629 | [[package]]
 630 | name = "memchr"
 631 | version = "2.7.6"
 632 | source = "registry+https://github.com/rust-lang/crates.io-index"
 633 | checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
 634 | 
 635 | [[package]]
 636 | name = "mio"
 637 | version = "1.1.0"
 638 | source = "registry+https://github.com/rust-lang/crates.io-index"
 639 | checksum = "69d83b0086dc8ecf3ce9ae2874b2d1290252e2a30720bea58a5c6639b0092873"
 640 | dependencies = [
 641 |  "libc",
 642 |  "log",
 643 |  "wasi",
 644 |  "windows-sys 0.61.2",
 645 | ]
 646 | 
 647 | [[package]]
 648 | name = "num-traits"
 649 | version = "0.2.19"
 650 | source = "registry+https://github.com/rust-lang/crates.io-index"
 651 | checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
 652 | dependencies = [
 653 |  "autocfg",
 654 | ]
 655 | 
 656 | [[package]]
 657 | name = "once_cell"
 658 | version = "1.21.3"
 659 | source = "registry+https://github.com/rust-lang/crates.io-index"
 660 | checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 661 | 
 662 | [[package]]
 663 | name = "once_cell_polyfill"
 664 | version = "1.70.2"
 665 | source = "registry+https://github.com/rust-lang/crates.io-index"
 666 | checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 667 | 
 668 | [[package]]
 669 | name = "parking_lot"
 670 | version = "0.12.5"
 671 | source = "registry+https://github.com/rust-lang/crates.io-index"
 672 | checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
 673 | dependencies = [
 674 |  "lock_api",
 675 |  "parking_lot_core",
 676 | ]
 677 | 
 678 | [[package]]
 679 | name = "parking_lot_core"
 680 | version = "0.9.12"
 681 | source = "registry+https://github.com/rust-lang/crates.io-index"
 682 | checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
 683 | dependencies = [
 684 |  "cfg-if",
 685 |  "libc",
 686 |  "redox_syscall",
 687 |  "smallvec",
 688 |  "windows-link",
 689 | ]
 690 | 
 691 | [[package]]
 692 | name = "percent-encoding"
 693 | version = "2.3.2"
 694 | source = "registry+https://github.com/rust-lang/crates.io-index"
 695 | checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 696 | 
 697 | [[package]]
 698 | name = "pkg-config"
 699 | version = "0.3.32"
 700 | source = "registry+https://github.com/rust-lang/crates.io-index"
 701 | checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
 702 | 
 703 | [[package]]
 704 | name = "platform-dirs"
 705 | version = "0.3.0"
 706 | source = "registry+https://github.com/rust-lang/crates.io-index"
 707 | checksum = "e188d043c1a692985f78b5464853a263f1a27e5bd6322bad3a4078ee3c998a38"
 708 | dependencies = [
 709 |  "dirs-next",
 710 | ]
 711 | 
 712 | [[package]]
 713 | name = "potential_utf"
 714 | version = "0.1.4"
 715 | source = "registry+https://github.com/rust-lang/crates.io-index"
 716 | checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
 717 | dependencies = [
 718 |  "zerovec",
 719 | ]
 720 | 
 721 | [[package]]
 722 | name = "proc-macro2"
 723 | version = "1.0.103"
 724 | source = "registry+https://github.com/rust-lang/crates.io-index"
 725 | checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
 726 | dependencies = [
 727 |  "unicode-ident",
 728 | ]
 729 | 
 730 | [[package]]
 731 | name = "quote"
 732 | version = "1.0.42"
 733 | source = "registry+https://github.com/rust-lang/crates.io-index"
 734 | checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
 735 | dependencies = [
 736 |  "proc-macro2",
 737 | ]
 738 | 
 739 | [[package]]
 740 | name = "r-efi"
 741 | version = "5.3.0"
 742 | source = "registry+https://github.com/rust-lang/crates.io-index"
 743 | checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 744 | 
 745 | [[package]]
 746 | name = "redox_syscall"
 747 | version = "0.5.18"
 748 | source = "registry+https://github.com/rust-lang/crates.io-index"
 749 | checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
 750 | dependencies = [
 751 |  "bitflags",
 752 | ]
 753 | 
 754 | [[package]]
 755 | name = "redox_users"
 756 | version = "0.4.6"
 757 | source = "registry+https://github.com/rust-lang/crates.io-index"
 758 | checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
 759 | dependencies = [
 760 |  "getrandom 0.2.16",
 761 |  "libredox",
 762 |  "thiserror",
 763 | ]
 764 | 
 765 | [[package]]
 766 | name = "regex"
 767 | version = "1.12.2"
 768 | source = "registry+https://github.com/rust-lang/crates.io-index"
 769 | checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4"
 770 | dependencies = [
 771 |  "aho-corasick",
 772 |  "memchr",
 773 |  "regex-automata",
 774 |  "regex-syntax",
 775 | ]
 776 | 
 777 | [[package]]
 778 | name = "regex-automata"
 779 | version = "0.4.13"
 780 | source = "registry+https://github.com/rust-lang/crates.io-index"
 781 | checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
 782 | dependencies = [
 783 |  "aho-corasick",
 784 |  "memchr",
 785 |  "regex-syntax",
 786 | ]
 787 | 
 788 | [[package]]
 789 | name = "regex-syntax"
 790 | version = "0.8.8"
 791 | source = "registry+https://github.com/rust-lang/crates.io-index"
 792 | checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
 793 | 
 794 | [[package]]
 795 | name = "rustix"
 796 | version = "1.1.2"
 797 | source = "registry+https://github.com/rust-lang/crates.io-index"
 798 | checksum = "cd15f8a2c5551a84d56efdc1cd049089e409ac19a3072d5037a17fd70719ff3e"
 799 | dependencies = [
 800 |  "bitflags",
 801 |  "errno",
 802 |  "libc",
 803 |  "linux-raw-sys",
 804 |  "windows-sys 0.60.2",
 805 | ]
 806 | 
 807 | [[package]]
 808 | name = "rustversion"
 809 | version = "1.0.22"
 810 | source = "registry+https://github.com/rust-lang/crates.io-index"
 811 | checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
 812 | 
 813 | [[package]]
 814 | name = "scopeguard"
 815 | version = "1.2.0"
 816 | source = "registry+https://github.com/rust-lang/crates.io-index"
 817 | checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 818 | 
 819 | [[package]]
 820 | name = "serde"
 821 | version = "1.0.228"
 822 | source = "registry+https://github.com/rust-lang/crates.io-index"
 823 | checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
 824 | dependencies = [
 825 |  "serde_core",
 826 |  "serde_derive",
 827 | ]
 828 | 
 829 | [[package]]
 830 | name = "serde_core"
 831 | version = "1.0.228"
 832 | source = "registry+https://github.com/rust-lang/crates.io-index"
 833 | checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
 834 | dependencies = [
 835 |  "serde_derive",
 836 | ]
 837 | 
 838 | [[package]]
 839 | name = "serde_derive"
 840 | version = "1.0.228"
 841 | source = "registry+https://github.com/rust-lang/crates.io-index"
 842 | checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 843 | dependencies = [
 844 |  "proc-macro2",
 845 |  "quote",
 846 |  "syn",
 847 | ]
 848 | 
 849 | [[package]]
 850 | name = "serde_spanned"
 851 | version = "1.0.3"
 852 | source = "registry+https://github.com/rust-lang/crates.io-index"
 853 | checksum = "e24345aa0fe688594e73770a5f6d1b216508b4f93484c0026d521acd30134392"
 854 | dependencies = [
 855 |  "serde_core",
 856 | ]
 857 | 
 858 | [[package]]
 859 | name = "shlex"
 860 | version = "1.3.0"
 861 | source = "registry+https://github.com/rust-lang/crates.io-index"
 862 | checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 863 | 
 864 | [[package]]
 865 | name = "signal-hook"
 866 | version = "0.3.18"
 867 | source = "registry+https://github.com/rust-lang/crates.io-index"
 868 | checksum = "d881a16cf4426aa584979d30bd82cb33429027e42122b169753d6ef1085ed6e2"
 869 | dependencies = [
 870 |  "libc",
 871 |  "signal-hook-registry",
 872 | ]
 873 | 
 874 | [[package]]
 875 | name = "signal-hook-mio"
 876 | version = "0.2.5"
 877 | source = "registry+https://github.com/rust-lang/crates.io-index"
 878 | checksum = "b75a19a7a740b25bc7944bdee6172368f988763b744e3d4dfe753f6b4ece40cc"
 879 | dependencies = [
 880 |  "libc",
 881 |  "mio",
 882 |  "signal-hook",
 883 | ]
 884 | 
 885 | [[package]]
 886 | name = "signal-hook-registry"
 887 | version = "1.4.6"
 888 | source = "registry+https://github.com/rust-lang/crates.io-index"
 889 | checksum = "b2a4719bff48cee6b39d12c020eeb490953ad2443b7055bd0b21fca26bd8c28b"
 890 | dependencies = [
 891 |  "libc",
 892 | ]
 893 | 
 894 | [[package]]
 895 | name = "smallvec"
 896 | version = "1.15.1"
 897 | source = "registry+https://github.com/rust-lang/crates.io-index"
 898 | checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 899 | 
 900 | [[package]]
 901 | name = "stable_deref_trait"
 902 | version = "1.2.1"
 903 | source = "registry+https://github.com/rust-lang/crates.io-index"
 904 | checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 905 | 
 906 | [[package]]
 907 | name = "strsim"
 908 | version = "0.11.1"
 909 | source = "registry+https://github.com/rust-lang/crates.io-index"
 910 | checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 911 | 
 912 | [[package]]
 913 | name = "svg"
 914 | version = "0.18.0"
 915 | source = "registry+https://github.com/rust-lang/crates.io-index"
 916 | checksum = "94afda9cd163c04f6bee8b4bf2501c91548deae308373c436f36aeff3cf3c4a3"
 917 | 
 918 | [[package]]
 919 | name = "syn"
 920 | version = "2.0.110"
 921 | source = "registry+https://github.com/rust-lang/crates.io-index"
 922 | checksum = "a99801b5bd34ede4cf3fc688c5919368fea4e4814a4664359503e6015b280aea"
 923 | dependencies = [
 924 |  "proc-macro2",
 925 |  "quote",
 926 |  "unicode-ident",
 927 | ]
 928 | 
 929 | [[package]]
 930 | name = "synstructure"
 931 | version = "0.13.2"
 932 | source = "registry+https://github.com/rust-lang/crates.io-index"
 933 | checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
 934 | dependencies = [
 935 |  "proc-macro2",
 936 |  "quote",
 937 |  "syn",
 938 | ]
 939 | 
 940 | [[package]]
 941 | name = "textwrap"
 942 | version = "0.16.2"
 943 | source = "registry+https://github.com/rust-lang/crates.io-index"
 944 | checksum = "c13547615a44dc9c452a8a534638acdf07120d4b6847c8178705da06306a3057"
 945 | dependencies = [
 946 |  "unicode-width",
 947 | ]
 948 | 
 949 | [[package]]
 950 | name = "thiserror"
 951 | version = "1.0.69"
 952 | source = "registry+https://github.com/rust-lang/crates.io-index"
 953 | checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
 954 | dependencies = [
 955 |  "thiserror-impl",
 956 | ]
 957 | 
 958 | [[package]]
 959 | name = "thiserror-impl"
 960 | version = "1.0.69"
 961 | source = "registry+https://github.com/rust-lang/crates.io-index"
 962 | checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 963 | dependencies = [
 964 |  "proc-macro2",
 965 |  "quote",
 966 |  "syn",
 967 | ]
 968 | 
 969 | [[package]]
 970 | name = "tinystr"
 971 | version = "0.8.2"
 972 | source = "registry+https://github.com/rust-lang/crates.io-index"
 973 | checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
 974 | dependencies = [
 975 |  "displaydoc",
 976 |  "zerovec",
 977 | ]
 978 | 
 979 | [[package]]
 980 | name = "toml"
 981 | version = "0.9.8"
 982 | source = "registry+https://github.com/rust-lang/crates.io-index"
 983 | checksum = "f0dc8b1fb61449e27716ec0e1bdf0f6b8f3e8f6b05391e8497b8b6d7804ea6d8"
 984 | dependencies = [
 985 |  "indexmap",
 986 |  "serde_core",
 987 |  "serde_spanned",
 988 |  "toml_datetime",
 989 |  "toml_parser",
 990 |  "toml_writer",
 991 |  "winnow",
 992 | ]
 993 | 
 994 | [[package]]
 995 | name = "toml_datetime"
 996 | version = "0.7.3"
 997 | source = "registry+https://github.com/rust-lang/crates.io-index"
 998 | checksum = "f2cdb639ebbc97961c51720f858597f7f24c4fc295327923af55b74c3c724533"
 999 | dependencies = [
1000 |  "serde_core",
1001 | ]
1002 | 
1003 | [[package]]
1004 | name = "toml_parser"
1005 | version = "1.0.4"
1006 | source = "registry+https://github.com/rust-lang/crates.io-index"
1007 | checksum = "c0cbe268d35bdb4bb5a56a2de88d0ad0eb70af5384a99d648cd4b3d04039800e"
1008 | dependencies = [
1009 |  "winnow",
1010 | ]
1011 | 
1012 | [[package]]
1013 | name = "toml_writer"
1014 | version = "1.0.4"
1015 | source = "registry+https://github.com/rust-lang/crates.io-index"
1016 | checksum = "df8b2b54733674ad286d16267dcfc7a71ed5c776e4ac7aa3c3e2561f7c637bf2"
1017 | 
1018 | [[package]]
1019 | name = "unicode-ident"
1020 | version = "1.0.22"
1021 | source = "registry+https://github.com/rust-lang/crates.io-index"
1022 | checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
1023 | 
1024 | [[package]]
1025 | name = "unicode-segmentation"
1026 | version = "1.12.0"
1027 | source = "registry+https://github.com/rust-lang/crates.io-index"
1028 | checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
1029 | 
1030 | [[package]]
1031 | name = "unicode-width"
1032 | version = "0.2.2"
1033 | source = "registry+https://github.com/rust-lang/crates.io-index"
1034 | checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
1035 | 
1036 | [[package]]
1037 | name = "url"
1038 | version = "2.5.7"
1039 | source = "registry+https://github.com/rust-lang/crates.io-index"
1040 | checksum = "08bc136a29a3d1758e07a9cca267be308aeebf5cfd5a10f3f67ab2097683ef5b"
1041 | dependencies = [
1042 |  "form_urlencoded",
1043 |  "idna",
1044 |  "percent-encoding",
1045 |  "serde",
1046 | ]
1047 | 
1048 | [[package]]
1049 | name = "utf8_iter"
1050 | version = "1.0.4"
1051 | source = "registry+https://github.com/rust-lang/crates.io-index"
1052 | checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
1053 | 
1054 | [[package]]
1055 | name = "utf8parse"
1056 | version = "0.2.2"
1057 | source = "registry+https://github.com/rust-lang/crates.io-index"
1058 | checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
1059 | 
1060 | [[package]]
1061 | name = "vcpkg"
1062 | version = "0.2.15"
1063 | source = "registry+https://github.com/rust-lang/crates.io-index"
1064 | checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
1065 | 
1066 | [[package]]
1067 | name = "wasi"
1068 | version = "0.11.1+wasi-snapshot-preview1"
1069 | source = "registry+https://github.com/rust-lang/crates.io-index"
1070 | checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
1071 | 
1072 | [[package]]
1073 | name = "wasip2"
1074 | version = "1.0.1+wasi-0.2.4"
1075 | source = "registry+https://github.com/rust-lang/crates.io-index"
1076 | checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
1077 | dependencies = [
1078 |  "wit-bindgen",
1079 | ]
1080 | 
1081 | [[package]]
1082 | name = "wasm-bindgen"
1083 | version = "0.2.105"
1084 | source = "registry+https://github.com/rust-lang/crates.io-index"
1085 | checksum = "da95793dfc411fbbd93f5be7715b0578ec61fe87cb1a42b12eb625caa5c5ea60"
1086 | dependencies = [
1087 |  "cfg-if",
1088 |  "once_cell",
1089 |  "rustversion",
1090 |  "wasm-bindgen-macro",
1091 |  "wasm-bindgen-shared",
1092 | ]
1093 | 
1094 | [[package]]
1095 | name = "wasm-bindgen-macro"
1096 | version = "0.2.105"
1097 | source = "registry+https://github.com/rust-lang/crates.io-index"
1098 | checksum = "04264334509e04a7bf8690f2384ef5265f05143a4bff3889ab7a3269adab59c2"
1099 | dependencies = [
1100 |  "quote",
1101 |  "wasm-bindgen-macro-support",
1102 | ]
1103 | 
1104 | [[package]]
1105 | name = "wasm-bindgen-macro-support"
1106 | version = "0.2.105"
1107 | source = "registry+https://github.com/rust-lang/crates.io-index"
1108 | checksum = "420bc339d9f322e562942d52e115d57e950d12d88983a14c79b86859ee6c7ebc"
1109 | dependencies = [
1110 |  "bumpalo",
1111 |  "proc-macro2",
1112 |  "quote",
1113 |  "syn",
1114 |  "wasm-bindgen-shared",
1115 | ]
1116 | 
1117 | [[package]]
1118 | name = "wasm-bindgen-shared"
1119 | version = "0.2.105"
1120 | source = "registry+https://github.com/rust-lang/crates.io-index"
1121 | checksum = "76f218a38c84bcb33c25ec7059b07847d465ce0e0a76b995e134a45adcb6af76"
1122 | dependencies = [
1123 |  "unicode-ident",
1124 | ]
1125 | 
1126 | [[package]]
1127 | name = "winapi"
1128 | version = "0.3.9"
1129 | source = "registry+https://github.com/rust-lang/crates.io-index"
1130 | checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
1131 | dependencies = [
1132 |  "winapi-i686-pc-windows-gnu",
1133 |  "winapi-x86_64-pc-windows-gnu",
1134 | ]
1135 | 
1136 | [[package]]
1137 | name = "winapi-i686-pc-windows-gnu"
1138 | version = "0.4.0"
1139 | source = "registry+https://github.com/rust-lang/crates.io-index"
1140 | checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
1141 | 
1142 | [[package]]
1143 | name = "winapi-x86_64-pc-windows-gnu"
1144 | version = "0.4.0"
1145 | source = "registry+https://github.com/rust-lang/crates.io-index"
1146 | checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
1147 | 
1148 | [[package]]
1149 | name = "windows-core"
1150 | version = "0.62.2"
1151 | source = "registry+https://github.com/rust-lang/crates.io-index"
1152 | checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
1153 | dependencies = [
1154 |  "windows-implement",
1155 |  "windows-interface",
1156 |  "windows-link",
1157 |  "windows-result",
1158 |  "windows-strings",
1159 | ]
1160 | 
1161 | [[package]]
1162 | name = "windows-implement"
1163 | version = "0.60.2"
1164 | source = "registry+https://github.com/rust-lang/crates.io-index"
1165 | checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
1166 | dependencies = [
1167 |  "proc-macro2",
1168 |  "quote",
1169 |  "syn",
1170 | ]
1171 | 
1172 | [[package]]
1173 | name = "windows-interface"
1174 | version = "0.59.3"
1175 | source = "registry+https://github.com/rust-lang/crates.io-index"
1176 | checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
1177 | dependencies = [
1178 |  "proc-macro2",
1179 |  "quote",
1180 |  "syn",
1181 | ]
1182 | 
1183 | [[package]]
1184 | name = "windows-link"
1185 | version = "0.2.1"
1186 | source = "registry+https://github.com/rust-lang/crates.io-index"
1187 | checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
1188 | 
1189 | [[package]]
1190 | name = "windows-result"
1191 | version = "0.4.1"
1192 | source = "registry+https://github.com/rust-lang/crates.io-index"
1193 | checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
1194 | dependencies = [
1195 |  "windows-link",
1196 | ]
1197 | 
1198 | [[package]]
1199 | name = "windows-strings"
1200 | version = "0.5.1"
1201 | source = "registry+https://github.com/rust-lang/crates.io-index"
1202 | checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
1203 | dependencies = [
1204 |  "windows-link",
1205 | ]
1206 | 
1207 | [[package]]
1208 | name = "windows-sys"
1209 | version = "0.60.2"
1210 | source = "registry+https://github.com/rust-lang/crates.io-index"
1211 | checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
1212 | dependencies = [
1213 |  "windows-targets",
1214 | ]
1215 | 
1216 | [[package]]
1217 | name = "windows-sys"
1218 | version = "0.61.2"
1219 | source = "registry+https://github.com/rust-lang/crates.io-index"
1220 | checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
1221 | dependencies = [
1222 |  "windows-link",
1223 | ]
1224 | 
1225 | [[package]]
1226 | name = "windows-targets"
1227 | version = "0.53.5"
1228 | source = "registry+https://github.com/rust-lang/crates.io-index"
1229 | checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
1230 | dependencies = [
1231 |  "windows-link",
1232 |  "windows_aarch64_gnullvm",
1233 |  "windows_aarch64_msvc",
1234 |  "windows_i686_gnu",
1235 |  "windows_i686_gnullvm",
1236 |  "windows_i686_msvc",
1237 |  "windows_x86_64_gnu",
1238 |  "windows_x86_64_gnullvm",
1239 |  "windows_x86_64_msvc",
1240 | ]
1241 | 
1242 | [[package]]
1243 | name = "windows_aarch64_gnullvm"
1244 | version = "0.53.1"
1245 | source = "registry+https://github.com/rust-lang/crates.io-index"
1246 | checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
1247 | 
1248 | [[package]]
1249 | name = "windows_aarch64_msvc"
1250 | version = "0.53.1"
1251 | source = "registry+https://github.com/rust-lang/crates.io-index"
1252 | checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
1253 | 
1254 | [[package]]
1255 | name = "windows_i686_gnu"
1256 | version = "0.53.1"
1257 | source = "registry+https://github.com/rust-lang/crates.io-index"
1258 | checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
1259 | 
1260 | [[package]]
1261 | name = "windows_i686_gnullvm"
1262 | version = "0.53.1"
1263 | source = "registry+https://github.com/rust-lang/crates.io-index"
1264 | checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
1265 | 
1266 | [[package]]
1267 | name = "windows_i686_msvc"
1268 | version = "0.53.1"
1269 | source = "registry+https://github.com/rust-lang/crates.io-index"
1270 | checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
1271 | 
1272 | [[package]]
1273 | name = "windows_x86_64_gnu"
1274 | version = "0.53.1"
1275 | source = "registry+https://github.com/rust-lang/crates.io-index"
1276 | checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
1277 | 
1278 | [[package]]
1279 | name = "windows_x86_64_gnullvm"
1280 | version = "0.53.1"
1281 | source = "registry+https://github.com/rust-lang/crates.io-index"
1282 | checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
1283 | 
1284 | [[package]]
1285 | name = "windows_x86_64_msvc"
1286 | version = "0.53.1"
1287 | source = "registry+https://github.com/rust-lang/crates.io-index"
1288 | checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
1289 | 
1290 | [[package]]
1291 | name = "winnow"
1292 | version = "0.7.13"
1293 | source = "registry+https://github.com/rust-lang/crates.io-index"
1294 | checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
1295 | 
1296 | [[package]]
1297 | name = "wit-bindgen"
1298 | version = "0.46.0"
1299 | source = "registry+https://github.com/rust-lang/crates.io-index"
1300 | checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
1301 | 
1302 | [[package]]
1303 | name = "writeable"
1304 | version = "0.6.2"
1305 | source = "registry+https://github.com/rust-lang/crates.io-index"
1306 | checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
1307 | 
1308 | [[package]]
1309 | name = "yansi"
1310 | version = "1.0.1"
1311 | source = "registry+https://github.com/rust-lang/crates.io-index"
1312 | checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
1313 | 
1314 | [[package]]
1315 | name = "yoke"
1316 | version = "0.8.1"
1317 | source = "registry+https://github.com/rust-lang/crates.io-index"
1318 | checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
1319 | dependencies = [
1320 |  "stable_deref_trait",
1321 |  "yoke-derive",
1322 |  "zerofrom",
1323 | ]
1324 | 
1325 | [[package]]
1326 | name = "yoke-derive"
1327 | version = "0.8.1"
1328 | source = "registry+https://github.com/rust-lang/crates.io-index"
1329 | checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
1330 | dependencies = [
1331 |  "proc-macro2",
1332 |  "quote",
1333 |  "syn",
1334 |  "synstructure",
1335 | ]
1336 | 
1337 | [[package]]
1338 | name = "zerofrom"
1339 | version = "0.1.6"
1340 | source = "registry+https://github.com/rust-lang/crates.io-index"
1341 | checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
1342 | dependencies = [
1343 |  "zerofrom-derive",
1344 | ]
1345 | 
1346 | [[package]]
1347 | name = "zerofrom-derive"
1348 | version = "0.1.6"
1349 | source = "registry+https://github.com/rust-lang/crates.io-index"
1350 | checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
1351 | dependencies = [
1352 |  "proc-macro2",
1353 |  "quote",
1354 |  "syn",
1355 |  "synstructure",
1356 | ]
1357 | 
1358 | [[package]]
1359 | name = "zerotrie"
1360 | version = "0.2.3"
1361 | source = "registry+https://github.com/rust-lang/crates.io-index"
1362 | checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
1363 | dependencies = [
1364 |  "displaydoc",
1365 |  "yoke",
1366 |  "zerofrom",
1367 | ]
1368 | 
1369 | [[package]]
1370 | name = "zerovec"
1371 | version = "0.11.5"
1372 | source = "registry+https://github.com/rust-lang/crates.io-index"
1373 | checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
1374 | dependencies = [
1375 |  "yoke",
1376 |  "zerofrom",
1377 |  "zerovec-derive",
1378 | ]
1379 | 
1380 | [[package]]
1381 | name = "zerovec-derive"
1382 | version = "0.11.2"
1383 | source = "registry+https://github.com/rust-lang/crates.io-index"
1384 | checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
1385 | dependencies = [
1386 |  "proc-macro2",
1387 |  "quote",
1388 |  "syn",
1389 | ]
1390 | 


--------------------------------------------------------------------------------
/src/graph.rs:
--------------------------------------------------------------------------------
   1 | //! A graph structure representing the history of a Git repository.
   2 | //!
   3 | //! To generate a graph, call [GitGraph::new()].
   4 | //!
   5 | //! ### Visualization of branches
   6 | //! git-graph uses the term *branch* a little different from how git uses it.
   7 | //! In git-lingo this means "a label on some commit", whereas in git-graph
   8 | //! it means "a path in the ancestor graph of a repository". Nodes are
   9 | //! commits, edges are directed from a child to its parents.
  10 | //!
  11 | //! In the text below, the term
  12 | //! - *git-branch* is a label on a commit.
  13 | //! - *branch* is the visualization of an ancestor path.
  14 | //!
  15 | //! git-graph visualizes branches as a vertical line. Only
  16 | //! the primary parent of a commit can be on the same branch as the
  17 | //! commit. Horizontal lines represent forks (multiple children) or
  18 | //! merges (multiple parents), and show the remaining parent relations.
  19 | 
  20 | use crate::print::colors::to_terminal_color;
  21 | use crate::settings::{BranchOrder, BranchSettings, MergePatterns, Settings};
  22 | use git2::{BranchType, Commit, Error, Oid, Reference, Repository};
  23 | use regex::Regex;
  24 | use std::collections::{HashMap, HashSet};
  25 | 
  26 | const ORIGIN: &str = "origin/";
  27 | const FORK: &str = "fork/";
  28 | 
  29 | /// Represents a git history graph.
  30 | pub struct GitGraph {
  31 |     pub repository: Repository,
  32 |     pub commits: Vec<CommitInfo>,
  33 |     /// Mapping from commit id to index in `commits`
  34 |     pub indices: HashMap<Oid, usize>,
  35 |     /// All detected branches and tags, including merged and deleted
  36 |     pub all_branches: Vec<BranchInfo>,
  37 |     /// The current HEAD
  38 |     pub head: HeadInfo,
  39 | }
  40 | 
  41 | impl GitGraph {
  42 |     /// Generate a branch graph for a repository
  43 |     pub fn new(
  44 |         mut repository: Repository,
  45 |         settings: &Settings,
  46 |         start_point: Option<String>,
  47 |         max_count: Option<usize>,
  48 |     ) -> Result<Self, String> {
  49 |         #![doc = include_str!("../docs/branch_assignment.md")]
  50 |         let mut stashes = HashSet::new();
  51 |         repository
  52 |             .stash_foreach(|_, _, oid| {
  53 |                 stashes.insert(*oid);
  54 |                 true
  55 |             })
  56 |             .map_err(|err| err.message().to_string())?;
  57 | 
  58 |         let mut walk = repository
  59 |             .revwalk()
  60 |             .map_err(|err| err.message().to_string())?;
  61 | 
  62 |         walk.set_sorting(git2::Sort::TOPOLOGICAL | git2::Sort::TIME)
  63 |             .map_err(|err| err.message().to_string())?;
  64 | 
  65 |         // Use starting point if specified
  66 |         if let Some(start) = start_point {
  67 |             let object = repository
  68 |                 .revparse_single(&start)
  69 |                 .map_err(|err| format!("Failed to resolve start point '{}': {}", start, err))?;
  70 |             walk.push(object.id())
  71 |                 .map_err(|err| err.message().to_string())?;
  72 |         } else {
  73 |             walk.push_glob("*")
  74 |                 .map_err(|err| err.message().to_string())?;
  75 |         }
  76 | 
  77 |         if repository.is_shallow() {
  78 |             return Err("ERROR: git-graph does not support shallow clones due to a missing feature in the underlying libgit2 library.".to_string());
  79 |         }
  80 | 
  81 |         let head = HeadInfo::new(&repository.head().map_err(|err| err.message().to_string())?)?;
  82 | 
  83 |         // commits will hold the CommitInfo for all commits covered
  84 |         // indices maps git object id to an index into commits.
  85 |         let mut commits = Vec::new();
  86 |         let mut indices = HashMap::new();
  87 |         let mut idx = 0;
  88 |         for oid in walk {
  89 |             if let Some(max) = max_count {
  90 |                 if idx >= max {
  91 |                     break;
  92 |                 }
  93 |             }
  94 |             if let Ok(oid) = oid {
  95 |                 if !stashes.contains(&oid) {
  96 |                     let commit = repository.find_commit(oid).unwrap();
  97 | 
  98 |                     commits.push(CommitInfo::new(&commit));
  99 |                     indices.insert(oid, idx);
 100 |                     idx += 1;
 101 |                 }
 102 |             }
 103 |         }
 104 | 
 105 |         assign_children(&mut commits, &indices);
 106 | 
 107 |         let mut all_branches = assign_branches(&repository, &mut commits, &indices, settings)?;
 108 |         correct_fork_merges(&commits, &indices, &mut all_branches, settings)?;
 109 |         assign_sources_targets(&commits, &indices, &mut all_branches);
 110 | 
 111 |         let (shortest_first, forward) = match settings.branch_order {
 112 |             BranchOrder::ShortestFirst(fwd) => (true, fwd),
 113 |             BranchOrder::LongestFirst(fwd) => (false, fwd),
 114 |         };
 115 | 
 116 |         assign_branch_columns(
 117 |             &commits,
 118 |             &indices,
 119 |             &mut all_branches,
 120 |             &settings.branches,
 121 |             shortest_first,
 122 |             forward,
 123 |         );
 124 | 
 125 |         // Remove commits not on a branch. This will give all commits a new index.
 126 |         let filtered_commits: Vec<CommitInfo> = commits
 127 |             .into_iter()
 128 |             .filter(|info| info.branch_trace.is_some())
 129 |             .collect();
 130 | 
 131 |         // Create indices from git object id into the filtered commits
 132 |         let filtered_indices: HashMap<Oid, usize> = filtered_commits
 133 |             .iter()
 134 |             .enumerate()
 135 |             .map(|(idx, info)| (info.oid, idx))
 136 |             .collect();
 137 | 
 138 |         // Map from old index to new index. None, if old index was removed
 139 |         let index_map: HashMap<usize, Option<&usize>> = indices
 140 |             .iter()
 141 |             .map(|(oid, index)| (*index, filtered_indices.get(oid)))
 142 |             .collect();
 143 | 
 144 |         // Update branch.range from old to new index. Shrink if endpoints were removed.
 145 |         for branch in all_branches.iter_mut() {
 146 |             if let Some(mut start_idx) = branch.range.0 {
 147 |                 let mut idx0 = index_map[&start_idx];
 148 |                 while idx0.is_none() {
 149 |                     start_idx += 1;
 150 |                     idx0 = index_map[&start_idx];
 151 |                 }
 152 |                 branch.range.0 = Some(*idx0.unwrap());
 153 |             }
 154 |             if let Some(mut end_idx) = branch.range.1 {
 155 |                 let mut idx0 = index_map[&end_idx];
 156 |                 while idx0.is_none() {
 157 |                     end_idx -= 1;
 158 |                     idx0 = index_map[&end_idx];
 159 |                 }
 160 |                 branch.range.1 = Some(*idx0.unwrap());
 161 |             }
 162 |         }
 163 | 
 164 |         Ok(GitGraph {
 165 |             repository,
 166 |             commits: filtered_commits,
 167 |             indices: filtered_indices,
 168 |             all_branches,
 169 |             head,
 170 |         })
 171 |     }
 172 | 
 173 |     pub fn take_repository(self) -> Repository {
 174 |         self.repository
 175 |     }
 176 | 
 177 |     pub fn commit(&self, id: Oid) -> Result<Commit<'_>, Error> {
 178 |         self.repository.find_commit(id)
 179 |     }
 180 | }
 181 | 
 182 | /// Information about the current HEAD
 183 | pub struct HeadInfo {
 184 |     pub oid: Oid,
 185 |     pub name: String,
 186 |     pub is_branch: bool,
 187 | }
 188 | impl HeadInfo {
 189 |     fn new(head: &Reference) -> Result<Self, String> {
 190 |         let name = head.name().ok_or_else(|| "No name for HEAD".to_string())?;
 191 |         let name = if name == "HEAD" {
 192 |             name.to_string()
 193 |         } else {
 194 |             name[11..].to_string()
 195 |         };
 196 | 
 197 |         let h = HeadInfo {
 198 |             oid: head.target().ok_or_else(|| "No id for HEAD".to_string())?,
 199 |             name,
 200 |             is_branch: head.is_branch(),
 201 |         };
 202 |         Ok(h)
 203 |     }
 204 | }
 205 | 
 206 | /// Represents a commit.
 207 | pub struct CommitInfo {
 208 |     pub oid: Oid,
 209 |     pub is_merge: bool,
 210 |     pub parents: [Option<Oid>; 2],
 211 |     pub children: Vec<Oid>,
 212 |     pub branches: Vec<usize>,
 213 |     pub tags: Vec<usize>,
 214 |     pub branch_trace: Option<usize>,
 215 | }
 216 | 
 217 | impl CommitInfo {
 218 |     fn new(commit: &Commit) -> Self {
 219 |         CommitInfo {
 220 |             oid: commit.id(),
 221 |             is_merge: commit.parent_count() > 1,
 222 |             parents: [commit.parent_id(0).ok(), commit.parent_id(1).ok()],
 223 |             children: Vec::new(),
 224 |             branches: Vec::new(),
 225 |             tags: Vec::new(),
 226 |             branch_trace: None,
 227 |         }
 228 |     }
 229 | }
 230 | 
 231 | /// Represents a branch (real or derived from merge summary).
 232 | pub struct BranchInfo {
 233 |     pub target: Oid,
 234 |     pub merge_target: Option<Oid>,
 235 |     pub source_branch: Option<usize>,
 236 |     pub target_branch: Option<usize>,
 237 |     pub name: String,
 238 |     pub persistence: u8,
 239 |     pub is_remote: bool,
 240 |     pub is_merged: bool,
 241 |     pub is_tag: bool,
 242 |     pub visual: BranchVis,
 243 |     pub range: (Option<usize>, Option<usize>),
 244 | }
 245 | impl BranchInfo {
 246 |     #[allow(clippy::too_many_arguments)]
 247 |     fn new(
 248 |         target: Oid,
 249 |         merge_target: Option<Oid>,
 250 |         name: String,
 251 |         persistence: u8,
 252 |         is_remote: bool,
 253 |         is_merged: bool,
 254 |         is_tag: bool,
 255 |         visual: BranchVis,
 256 |         end_index: Option<usize>,
 257 |     ) -> Self {
 258 |         BranchInfo {
 259 |             target,
 260 |             merge_target,
 261 |             target_branch: None,
 262 |             source_branch: None,
 263 |             name,
 264 |             persistence,
 265 |             is_remote,
 266 |             is_merged,
 267 |             is_tag,
 268 |             visual,
 269 |             range: (end_index, None),
 270 |         }
 271 |     }
 272 | }
 273 | 
 274 | /// Branch properties for visualization.
 275 | pub struct BranchVis {
 276 |     /// The branch's column group (left to right)
 277 |     pub order_group: usize,
 278 |     /// The branch's merge target column group (left to right)
 279 |     pub target_order_group: Option<usize>,
 280 |     /// The branch's source branch column group (left to right)
 281 |     pub source_order_group: Option<usize>,
 282 |     /// The branch's terminal color (index in 256-color palette)
 283 |     pub term_color: u8,
 284 |     /// SVG color (name or RGB in hex annotation)
 285 |     pub svg_color: String,
 286 |     /// The column the branch is located in
 287 |     pub column: Option<usize>,
 288 | }
 289 | 
 290 | impl BranchVis {
 291 |     fn new(order_group: usize, term_color: u8, svg_color: String) -> Self {
 292 |         BranchVis {
 293 |             order_group,
 294 |             target_order_group: None,
 295 |             source_order_group: None,
 296 |             term_color,
 297 |             svg_color,
 298 |             column: None,
 299 |         }
 300 |     }
 301 | }
 302 | 
 303 | /// Walks through the commits and adds each commit's Oid to the children of its parents.
 304 | fn assign_children(commits: &mut [CommitInfo], indices: &HashMap<Oid, usize>) {
 305 |     for idx in 0..commits.len() {
 306 |         let (oid, parents) = {
 307 |             let info = &commits[idx];
 308 |             (info.oid, info.parents)
 309 |         };
 310 |         for par_oid in &parents {
 311 |             if let Some(par_idx) = par_oid.and_then(|oid| indices.get(&oid)) {
 312 |                 commits[*par_idx].children.push(oid);
 313 |             }
 314 |         }
 315 |     }
 316 | }
 317 | 
 318 | /// Extracts branches from repository and merge summaries, assigns branches and branch traces to commits.
 319 | ///
 320 | /// Algorithm:
 321 | /// * Find all actual branches (incl. target oid) and all extract branches from merge summaries (incl. parent oid)
 322 | /// * Sort all branches by persistence
 323 | /// * Iterating over all branches in persistence order, trace back over commit parents until a trace is already assigned
 324 | fn assign_branches(
 325 |     repository: &Repository,
 326 |     commits: &mut [CommitInfo],
 327 |     indices: &HashMap<Oid, usize>,
 328 |     settings: &Settings,
 329 | ) -> Result<Vec<BranchInfo>, String> {
 330 |     let mut branch_idx = 0;
 331 | 
 332 |     let mut branches = extract_branches(repository, commits, indices, settings)?;
 333 | 
 334 |     let mut index_map: Vec<_> = (0..branches.len())
 335 |         .map(|old_idx| {
 336 |             let (target, is_tag, is_merged) = {
 337 |                 let branch = &branches[old_idx];
 338 |                 (branch.target, branch.is_tag, branch.is_merged)
 339 |             };
 340 |             if let Some(&idx) = &indices.get(&target) {
 341 |                 let info = &mut commits[idx];
 342 |                 if is_tag {
 343 |                     info.tags.push(old_idx);
 344 |                 } else if !is_merged {
 345 |                     info.branches.push(old_idx);
 346 |                 }
 347 |                 let oid = info.oid;
 348 |                 let any_assigned =
 349 |                     trace_branch(repository, commits, indices, &mut branches, oid, old_idx)
 350 |                         .unwrap_or(false);
 351 | 
 352 |                 if any_assigned || !is_merged {
 353 |                     branch_idx += 1;
 354 |                     Some(branch_idx - 1)
 355 |                 } else {
 356 |                     None
 357 |                 }
 358 |             } else {
 359 |                 None
 360 |             }
 361 |         })
 362 |         .collect();
 363 | 
 364 |     let mut commit_count = vec![0; branches.len()];
 365 |     for info in commits.iter_mut() {
 366 |         if let Some(trace) = info.branch_trace {
 367 |             commit_count[trace] += 1;
 368 |         }
 369 |     }
 370 | 
 371 |     let mut count_skipped = 0;
 372 |     for (idx, branch) in branches.iter().enumerate() {
 373 |         if let Some(mapped) = index_map[idx] {
 374 |             if commit_count[idx] == 0 && branch.is_merged && !branch.is_tag {
 375 |                 index_map[idx] = None;
 376 |                 count_skipped += 1;
 377 |             } else {
 378 |                 index_map[idx] = Some(mapped - count_skipped);
 379 |             }
 380 |         }
 381 |     }
 382 | 
 383 |     for info in commits.iter_mut() {
 384 |         if let Some(trace) = info.branch_trace {
 385 |             info.branch_trace = index_map[trace];
 386 |             for br in info.branches.iter_mut() {
 387 |                 *br = index_map[*br].unwrap();
 388 |             }
 389 |             for tag in info.tags.iter_mut() {
 390 |                 *tag = index_map[*tag].unwrap();
 391 |             }
 392 |         }
 393 |     }
 394 | 
 395 |     let branches: Vec<_> = branches
 396 |         .into_iter()
 397 |         .enumerate()
 398 |         .filter_map(|(arr_index, branch)| {
 399 |             if index_map[arr_index].is_some() {
 400 |                 Some(branch)
 401 |             } else {
 402 |                 None
 403 |             }
 404 |         })
 405 |         .collect();
 406 | 
 407 |     Ok(branches)
 408 | }
 409 | 
 410 | fn correct_fork_merges(
 411 |     commits: &[CommitInfo],
 412 |     indices: &HashMap<Oid, usize>,
 413 |     branches: &mut [BranchInfo],
 414 |     settings: &Settings,
 415 | ) -> Result<(), String> {
 416 |     for idx in 0..branches.len() {
 417 |         if let Some(merge_target) = branches[idx]
 418 |             .merge_target
 419 |             .and_then(|oid| indices.get(&oid))
 420 |             .and_then(|idx| commits.get(*idx))
 421 |             .and_then(|info| info.branch_trace)
 422 |             .and_then(|trace| branches.get(trace))
 423 |         {
 424 |             if branches[idx].name == merge_target.name {
 425 |                 let name = format!("{}{}", FORK, branches[idx].name);
 426 |                 let term_col = to_terminal_color(
 427 |                     &branch_color(
 428 |                         &name,
 429 |                         &settings.branches.terminal_colors[..],
 430 |                         &settings.branches.terminal_colors_unknown,
 431 |                         idx,
 432 |                     )[..],
 433 |                 )?;
 434 |                 let pos = branch_order(&name, &settings.branches.order);
 435 |                 let svg_col = branch_color(
 436 |                     &name,
 437 |                     &settings.branches.svg_colors,
 438 |                     &settings.branches.svg_colors_unknown,
 439 |                     idx,
 440 |                 );
 441 | 
 442 |                 branches[idx].name = format!("{}{}", FORK, branches[idx].name);
 443 |                 branches[idx].visual.order_group = pos;
 444 |                 branches[idx].visual.term_color = term_col;
 445 |                 branches[idx].visual.svg_color = svg_col;
 446 |             }
 447 |         }
 448 |     }
 449 |     Ok(())
 450 | }
 451 | fn assign_sources_targets(
 452 |     commits: &[CommitInfo],
 453 |     indices: &HashMap<Oid, usize>,
 454 |     branches: &mut [BranchInfo],
 455 | ) {
 456 |     for idx in 0..branches.len() {
 457 |         let target_branch_idx = branches[idx]
 458 |             .merge_target
 459 |             .and_then(|oid| indices.get(&oid))
 460 |             .and_then(|idx| commits.get(*idx))
 461 |             .and_then(|info| info.branch_trace);
 462 | 
 463 |         branches[idx].target_branch = target_branch_idx;
 464 | 
 465 |         let group = target_branch_idx
 466 |             .and_then(|trace| branches.get(trace))
 467 |             .map(|br| br.visual.order_group);
 468 | 
 469 |         branches[idx].visual.target_order_group = group;
 470 |     }
 471 |     for info in commits {
 472 |         let mut max_par_order = None;
 473 |         let mut source_branch_id = None;
 474 |         for par_oid in info.parents.iter() {
 475 |             let par_info = par_oid
 476 |                 .and_then(|oid| indices.get(&oid))
 477 |                 .and_then(|idx| commits.get(*idx));
 478 |             if let Some(par_info) = par_info {
 479 |                 if par_info.branch_trace != info.branch_trace {
 480 |                     if let Some(trace) = par_info.branch_trace {
 481 |                         source_branch_id = Some(trace);
 482 |                     }
 483 | 
 484 |                     let group = par_info
 485 |                         .branch_trace
 486 |                         .and_then(|trace| branches.get(trace))
 487 |                         .map(|br| br.visual.order_group);
 488 |                     if let Some(gr) = max_par_order {
 489 |                         if let Some(p_group) = group {
 490 |                             if p_group > gr {
 491 |                                 max_par_order = group;
 492 |                             }
 493 |                         }
 494 |                     } else {
 495 |                         max_par_order = group;
 496 |                     }
 497 |                 }
 498 |             }
 499 |         }
 500 |         let branch = info.branch_trace.and_then(|trace| branches.get_mut(trace));
 501 |         if let Some(branch) = branch {
 502 |             if let Some(order) = max_par_order {
 503 |                 branch.visual.source_order_group = Some(order);
 504 |             }
 505 |             if let Some(source_id) = source_branch_id {
 506 |                 branch.source_branch = Some(source_id);
 507 |             }
 508 |         }
 509 |     }
 510 | }
 511 | 
 512 | /// Extracts and processes actual Git branches (local and remote) from the repository.
 513 | ///
 514 | /// This function iterates through the branches found in the Git repository,
 515 | /// filters them based on the `include_remote` setting, and constructs `BranchInfo`
 516 | /// objects for each valid branch. It assigns properties like name, type (local/remote),
 517 | /// visual order, and colors based on the provided settings.
 518 | ///
 519 | /// Arguments:
 520 | /// - `repository`: A reference to the Git `Repository` object.
 521 | /// - `indices`: A HashMap mapping commit OIDs to their corresponding indices in the `commits` list.
 522 | /// - `settings`: A reference to the application `Settings` containing branch configuration.
 523 | /// - `counter`: A mutable reference to a counter, incremented for each processed branch to aid in color assignment.
 524 | ///
 525 | /// Returns:
 526 | /// A `Result` containing a `Vec<BranchInfo>` on success, or a `String` error message on failure.
 527 | fn extract_actual_branches(
 528 |     repository: &Repository,
 529 |     indices: &HashMap<Oid, usize>,
 530 |     settings: &Settings,
 531 |     counter: &mut usize,
 532 | ) -> Result<Vec<BranchInfo>, String> {
 533 |     // Determine if remote branches should be included based on settings.
 534 |     let filter = if settings.include_remote {
 535 |         None
 536 |     } else {
 537 |         Some(BranchType::Local)
 538 |     };
 539 | 
 540 |     // Retrieve branches from the repository, handling potential errors.
 541 |     let actual_branches = repository
 542 |         .branches(filter)
 543 |         .map_err(|err| err.message().to_string())?
 544 |         .collect::<Result<Vec<_>, Error>>()
 545 |         .map_err(|err| err.message().to_string())?;
 546 | 
 547 |     // Process each actual branch to create `BranchInfo` objects.
 548 |     let valid_branches = actual_branches
 549 |         .iter()
 550 |         .filter_map(|(br, tp)| {
 551 |             br.get().name().and_then(|n| {
 552 |                 br.get().target().map(|t| {
 553 |                     *counter += 1; // Increment counter for unique branch identification/coloring.
 554 | 
 555 |                     // Determine the starting index for slicing the branch name string.
 556 |                     let start_index = match tp {
 557 |                         BranchType::Local => 11,  // "refs/heads/"
 558 |                         BranchType::Remote => 13, // "refs/remotes/"
 559 |                     };
 560 |                     let name = &n[start_index..];
 561 |                     let end_index = indices.get(&t).cloned();
 562 | 
 563 |                     // Convert branch color to a terminal-compatible format.
 564 |                     let term_color = match to_terminal_color(
 565 |                         &branch_color(
 566 |                             name,
 567 |                             &settings.branches.terminal_colors[..],
 568 |                             &settings.branches.terminal_colors_unknown,
 569 |                             *counter,
 570 |                         )[..],
 571 |                     ) {
 572 |                         Ok(col) => col,
 573 |                         Err(err) => return Err(err), // Propagate color conversion errors.
 574 |                     };
 575 | 
 576 |                     // Create and return the BranchInfo object.
 577 |                     Ok(BranchInfo::new(
 578 |                         t,
 579 |                         None, // No merge OID for actual branches.
 580 |                         name.to_string(),
 581 |                         branch_order(name, &settings.branches.persistence) as u8,
 582 |                         &BranchType::Remote == tp, // Check if it's a remote branch.
 583 |                         false,                     // Not a derived merge branch.
 584 |                         false,                     // Not a tag.
 585 |                         BranchVis::new(
 586 |                             branch_order(name, &settings.branches.order),
 587 |                             term_color,
 588 |                             branch_color(
 589 |                                 name,
 590 |                                 &settings.branches.svg_colors,
 591 |                                 &settings.branches.svg_colors_unknown,
 592 |                                 *counter,
 593 |                             ),
 594 |                         ),
 595 |                         end_index,
 596 |                     ))
 597 |                 })
 598 |             })
 599 |         })
 600 |         .collect::<Result<Vec<_>, String>>()?; // Collect results, propagating any errors.
 601 | 
 602 |     Ok(valid_branches)
 603 | }
 604 | 
 605 | /// Iterates through commits, identifies merge commits, and derives branch information
 606 | /// from their summaries.
 607 | ///
 608 | /// This function processes each commit in the provided list. If a commit is identified
 609 | /// as a merge commit and has a summary, it attempts to parse a branch name from the summary.
 610 | /// A `BranchInfo` object is then created for this derived branch, representing the merge
 611 | /// point and its properties.
 612 | ///
 613 | /// Arguments:
 614 | /// - `repository`: A reference to the Git `Repository` object.
 615 | /// - `commits`: A slice of `CommitInfo` objects, representing the commits to process.
 616 | /// - `settings`: A reference to the application `Settings` containing branch and merge pattern configuration.
 617 | /// - `counter`: A mutable reference to a counter, incremented for each processed merge branch.
 618 | ///
 619 | /// Returns:
 620 | /// A `Result` containing a `Vec<BranchInfo>` on success, or a `String` error message on failure.
 621 | fn extract_merge_branches(
 622 |     repository: &Repository,
 623 |     commits: &[CommitInfo],
 624 |     settings: &Settings,
 625 |     counter: &mut usize,
 626 | ) -> Result<Vec<BranchInfo>, String> {
 627 |     let mut merge_branches = Vec::new();
 628 | 
 629 |     for (idx, info) in commits.iter().enumerate() {
 630 |         // Only process if the commit is a merge.
 631 |         if info.is_merge {
 632 |             let commit = repository
 633 |                 .find_commit(info.oid)
 634 |                 .map_err(|err| err.message().to_string())?;
 635 | 
 636 |             // Attempt to get the commit summary.
 637 |             if let Some(summary) = commit.summary() {
 638 |                 *counter += 1; // Increment counter for unique branch identification/coloring.
 639 | 
 640 |                 let parent_oid = commit
 641 |                     .parent_id(1)
 642 |                     .map_err(|err| err.message().to_string())?;
 643 | 
 644 |                 // Parse the branch name from the merge summary using configured patterns.
 645 |                 let branch_name = parse_merge_summary(summary, &settings.merge_patterns)
 646 |                     .unwrap_or_else(|| "unknown".to_string());
 647 | 
 648 |                 // Determine persistence and order for the derived branch.
 649 |                 let persistence = branch_order(&branch_name, &settings.branches.persistence) as u8;
 650 |                 let pos = branch_order(&branch_name, &settings.branches.order);
 651 | 
 652 |                 // Get terminal and SVG colors for the branch.
 653 |                 let term_col = to_terminal_color(
 654 |                     &branch_color(
 655 |                         &branch_name,
 656 |                         &settings.branches.terminal_colors[..],
 657 |                         &settings.branches.terminal_colors_unknown,
 658 |                         *counter,
 659 |                     )[..],
 660 |                 )?;
 661 |                 let svg_col = branch_color(
 662 |                     &branch_name,
 663 |                     &settings.branches.svg_colors,
 664 |                     &settings.branches.svg_colors_unknown,
 665 |                     *counter,
 666 |                 );
 667 | 
 668 |                 // Create and add the BranchInfo for the derived merge branch.
 669 |                 let branch_info = BranchInfo::new(
 670 |                     parent_oid,     // Target is the parent of the merge.
 671 |                     Some(info.oid), // The merge commit itself.
 672 |                     branch_name,
 673 |                     persistence,
 674 |                     false, // Not a remote branch.
 675 |                     true,  // This is a derived merge branch.
 676 |                     false, // Not a tag.
 677 |                     BranchVis::new(pos, term_col, svg_col),
 678 |                     Some(idx + 1), // End index typically points to the commit after the merge.
 679 |                 );
 680 |                 merge_branches.push(branch_info);
 681 |             }
 682 |         }
 683 |     }
 684 |     Ok(merge_branches)
 685 | }
 686 | 
 687 | /// Extracts Git tags and treats them as branches, assigning appropriate properties.
 688 | ///
 689 | /// This function iterates through all tags in the repository, resolves their target
 690 | /// commit OID, and if the target commit is found within the `commits` list,
 691 | /// a `BranchInfo` object is created for the tag. Tags are assigned a higher
 692 | /// persistence value to ensure they are displayed prominently.
 693 | ///
 694 | /// Arguments:
 695 | /// - `repository`: A reference to the Git `Repository` object.
 696 | /// - `indices`: A HashMap mapping commit OIDs to their corresponding indices in the `commits` list.
 697 | /// - `settings`: A reference to the application `Settings` containing branch configuration.
 698 | /// - `counter`: A mutable reference to a counter, incremented for each processed tag.
 699 | ///
 700 | /// Returns:
 701 | /// A `Result` containing a `Vec<BranchInfo>` on success, or a `String` error message on failure.
 702 | fn extract_tags_as_branches(
 703 |     repository: &Repository,
 704 |     indices: &HashMap<Oid, usize>,
 705 |     settings: &Settings,
 706 |     counter: &mut usize,
 707 | ) -> Result<Vec<BranchInfo>, String> {
 708 |     let mut tags_info = Vec::new();
 709 |     let mut tags_raw = Vec::new();
 710 | 
 711 |     // Iterate over all tags in the repository.
 712 |     repository
 713 |         .tag_foreach(|oid, name| {
 714 |             tags_raw.push((oid, name.to_vec()));
 715 |             true // Continue iteration.
 716 |         })
 717 |         .map_err(|err| err.message().to_string())?;
 718 | 
 719 |     for (oid, name_bytes) in tags_raw {
 720 |         // Convert tag name bytes to a UTF-8 string. Tags typically start with "refs/tags/".
 721 |         let name = std::str::from_utf8(&name_bytes[5..]).map_err(|err| err.to_string())?;
 722 | 
 723 |         // Resolve the target OID of the tag. It could be a tag object or directly a commit.
 724 |         let target = repository
 725 |             .find_tag(oid)
 726 |             .map(|tag| tag.target_id())
 727 |             .or_else(|_| repository.find_commit(oid).map(|_| oid)); // If not a tag object, try as a direct commit.
 728 | 
 729 |         if let Ok(target_oid) = target {
 730 |             // If the target commit is within our processed commits, create a BranchInfo.
 731 |             if let Some(target_index) = indices.get(&target_oid) {
 732 |                 *counter += 1; // Increment counter for unique tag identification/coloring.
 733 | 
 734 |                 // Get terminal and SVG colors for the tag.
 735 |                 let term_col = to_terminal_color(
 736 |                     &branch_color(
 737 |                         name,
 738 |                         &settings.branches.terminal_colors[..],
 739 |                         &settings.branches.terminal_colors_unknown,
 740 |                         *counter,
 741 |                     )[..],
 742 |                 )?;
 743 |                 let pos = branch_order(name, &settings.branches.order);
 744 |                 let svg_col = branch_color(
 745 |                     name,
 746 |                     &settings.branches.svg_colors,
 747 |                     &settings.branches.svg_colors_unknown,
 748 |                     *counter,
 749 |                 );
 750 | 
 751 |                 // Create the BranchInfo object for the tag.
 752 |                 let tag_info = BranchInfo::new(
 753 |                     target_oid,
 754 |                     None, // No merge OID for tags.
 755 |                     name.to_string(),
 756 |                     settings.branches.persistence.len() as u8 + 1, // Tags usually have highest persistence.
 757 |                     false,                                         // Not a remote branch.
 758 |                     false,                                         // Not a derived merge branch.
 759 |                     true,                                          // This is a tag.
 760 |                     BranchVis::new(pos, term_col, svg_col),
 761 |                     Some(*target_index),
 762 |                 );
 763 |                 tags_info.push(tag_info);
 764 |             }
 765 |         }
 766 |     }
 767 |     Ok(tags_info)
 768 | }
 769 | 
 770 | /// Extracts (real or derived from merge summary) and assigns basic properties to branches and tags.
 771 | ///
 772 | /// This function orchestrates the extraction of branch information from various sources:
 773 | /// 1. Actual Git branches (local and remote).
 774 | /// 2. Branches derived from merge commit summaries.
 775 | /// 3. Git tags, treated as branches for visualization purposes.
 776 | ///
 777 | /// It combines the results from these extraction steps, sorts them based on
 778 | /// persistence and merge status, and returns a comprehensive list of `BranchInfo` objects.
 779 | ///
 780 | /// Arguments:
 781 | /// - `repository`: A reference to the Git `Repository` object.
 782 | /// - `commits`: A slice of `CommitInfo` objects, representing all relevant commits.
 783 | /// - `indices`: A HashMap mapping commit OIDs to their corresponding indices in the `commits` list.
 784 | /// - `settings`: A reference to the application `Settings` containing all necessary configuration.
 785 | ///
 786 | /// Returns:
 787 | /// A `Result` containing a `Vec<BranchInfo>` on success, or a `String` error message on failure.
 788 | fn extract_branches(
 789 |     repository: &Repository,
 790 |     commits: &[CommitInfo],
 791 |     indices: &HashMap<Oid, usize>,
 792 |     settings: &Settings,
 793 | ) -> Result<Vec<BranchInfo>, String> {
 794 |     let mut counter = 0; // Counter for unique branch/tag identification, especially for coloring.
 795 |     let mut all_branches: Vec<BranchInfo> = Vec::new();
 796 | 
 797 |     // 1. Extract actual local and remote branches.
 798 |     let actual_branches = extract_actual_branches(repository, indices, settings, &mut counter)?;
 799 |     all_branches.extend(actual_branches);
 800 | 
 801 |     // 2. Extract branches derived from merge commit summaries.
 802 |     let merge_branches = extract_merge_branches(repository, commits, settings, &mut counter)?;
 803 |     all_branches.extend(merge_branches);
 804 | 
 805 |     // 3. Extract tags and treat them as branches for visualization.
 806 |     let tags_as_branches = extract_tags_as_branches(repository, indices, settings, &mut counter)?;
 807 |     all_branches.extend(tags_as_branches);
 808 | 
 809 |     // Sort all collected branches and tags.
 810 |     // Sorting criteria: first by persistence, then by whether they are merged (unmerged first).
 811 |     all_branches.sort_by_cached_key(|branch| (branch.persistence, !branch.is_merged));
 812 | 
 813 |     Ok(all_branches)
 814 | }
 815 | 
 816 | /// Traces back branches by following 1st commit parent,
 817 | /// until a commit is reached that already has a trace.
 818 | fn trace_branch(
 819 |     repository: &Repository,
 820 |     commits: &mut [CommitInfo],
 821 |     indices: &HashMap<Oid, usize>,
 822 |     branches: &mut [BranchInfo],
 823 |     oid: Oid,
 824 |     branch_index: usize,
 825 | ) -> Result<bool, Error> {
 826 |     let mut curr_oid = oid;
 827 |     let mut prev_index: Option<usize> = None;
 828 |     let mut start_index: Option<i32> = None;
 829 |     let mut any_assigned = false;
 830 |     while let Some(index) = indices.get(&curr_oid) {
 831 |         let info = &mut commits[*index];
 832 |         if let Some(old_trace) = info.branch_trace {
 833 |             let (old_name, old_term, old_svg, old_range) = {
 834 |                 let old_branch = &branches[old_trace];
 835 |                 (
 836 |                     &old_branch.name.clone(),
 837 |                     old_branch.visual.term_color,
 838 |                     old_branch.visual.svg_color.clone(),
 839 |                     old_branch.range,
 840 |                 )
 841 |             };
 842 |             let new_name = &branches[branch_index].name;
 843 |             let old_end = old_range.0.unwrap_or(0);
 844 |             let new_end = branches[branch_index].range.0.unwrap_or(0);
 845 |             if new_name == old_name && old_end >= new_end {
 846 |                 let old_branch = &mut branches[old_trace];
 847 |                 if let Some(old_end) = old_range.1 {
 848 |                     if index > &old_end {
 849 |                         old_branch.range = (None, None);
 850 |                     } else {
 851 |                         old_branch.range = (Some(*index), old_branch.range.1);
 852 |                     }
 853 |                 } else {
 854 |                     old_branch.range = (Some(*index), old_branch.range.1);
 855 |                 }
 856 |             } else {
 857 |                 let branch = &mut branches[branch_index];
 858 |                 if branch.name.starts_with(ORIGIN) && branch.name[7..] == old_name[..] {
 859 |                     branch.visual.term_color = old_term;
 860 |                     branch.visual.svg_color = old_svg;
 861 |                 }
 862 |                 match prev_index {
 863 |                     None => start_index = Some(*index as i32 - 1),
 864 |                     Some(prev_index) => {
 865 |                         // TODO: in cases where no crossings occur, the rule for merge commits can also be applied to normal commits
 866 |                         // see also print::get_deviate_index()
 867 |                         if commits[prev_index].is_merge {
 868 |                             let mut temp_index = prev_index;
 869 |                             for sibling_oid in &commits[*index].children {
 870 |                                 if sibling_oid != &curr_oid {
 871 |                                     let sibling_index = indices[sibling_oid];
 872 |                                     if sibling_index > temp_index {
 873 |                                         temp_index = sibling_index;
 874 |                                     }
 875 |                                 }
 876 |                             }
 877 |                             start_index = Some(temp_index as i32);
 878 |                         } else {
 879 |                             start_index = Some(*index as i32 - 1);
 880 |                         }
 881 |                     }
 882 |                 }
 883 |                 break;
 884 |             }
 885 |         }
 886 | 
 887 |         info.branch_trace = Some(branch_index);
 888 |         any_assigned = true;
 889 | 
 890 |         let commit = repository.find_commit(curr_oid)?;
 891 |         if commit.parent_count() == 0 {
 892 |             // If no parents, this is the root commit, set `start_index` and break.
 893 |             start_index = Some(*index as i32);
 894 |             break;
 895 |         }
 896 |         // Set `prev_index` to the current commit's index and move to the first parent.
 897 |         prev_index = Some(*index);
 898 |         curr_oid = commit.parent_id(0)?;
 899 |     }
 900 | 
 901 |     let branch = &mut branches[branch_index];
 902 |     if let Some(end) = branch.range.0 {
 903 |         if let Some(start_index) = start_index {
 904 |             if start_index < end as i32 {
 905 |                 // TODO: find a better solution (bool field?) to identify non-deleted branches that were not assigned to any commits, and thus should not occupy a column.
 906 |                 branch.range = (None, None);
 907 |             } else {
 908 |                 branch.range = (branch.range.0, Some(start_index as usize));
 909 |             }
 910 |         } else {
 911 |             branch.range = (branch.range.0, None);
 912 |         }
 913 |     } else {
 914 |         branch.range = (branch.range.0, start_index.map(|si| si as usize));
 915 |     }
 916 |     Ok(any_assigned)
 917 | }
 918 | 
 919 | /// Sorts branches into columns for visualization, that all branches can be
 920 | /// visualizes linearly and without overlaps. Uses Shortest-First scheduling.
 921 | fn assign_branch_columns(
 922 |     commits: &[CommitInfo],
 923 |     indices: &HashMap<Oid, usize>,
 924 |     branches: &mut [BranchInfo],
 925 |     settings: &BranchSettings,
 926 |     shortest_first: bool,
 927 |     forward: bool,
 928 | ) {
 929 |     let mut occupied: Vec<Vec<Vec<(usize, usize)>>> = vec![vec![]; settings.order.len() + 1];
 930 | 
 931 |     let length_sort_factor = if shortest_first { 1 } else { -1 };
 932 |     let start_sort_factor = if forward { 1 } else { -1 };
 933 | 
 934 |     let mut branches_sort: Vec<_> = branches
 935 |         .iter()
 936 |         .enumerate()
 937 |         .filter(|(_idx, br)| br.range.0.is_some() || br.range.1.is_some())
 938 |         .map(|(idx, br)| {
 939 |             (
 940 |                 idx,
 941 |                 br.range.0.unwrap_or(0),
 942 |                 br.range.1.unwrap_or(branches.len() - 1),
 943 |                 br.visual
 944 |                     .source_order_group
 945 |                     .unwrap_or(settings.order.len() + 1),
 946 |                 br.visual
 947 |                     .target_order_group
 948 |                     .unwrap_or(settings.order.len() + 1),
 949 |             )
 950 |         })
 951 |         .collect();
 952 | 
 953 |     branches_sort.sort_by_cached_key(|tup| {
 954 |         (
 955 |             std::cmp::max(tup.3, tup.4),
 956 |             (tup.2 as i32 - tup.1 as i32) * length_sort_factor,
 957 |             tup.1 as i32 * start_sort_factor,
 958 |         )
 959 |     });
 960 | 
 961 |     for (branch_idx, start, end, _, _) in branches_sort {
 962 |         let branch = &branches[branch_idx];
 963 |         let group = branch.visual.order_group;
 964 |         let group_occ = &mut occupied[group];
 965 | 
 966 |         let align_right = branch
 967 |             .source_branch
 968 |             .map(|src| branches[src].visual.order_group > branch.visual.order_group)
 969 |             .unwrap_or(false)
 970 |             || branch
 971 |                 .target_branch
 972 |                 .map(|trg| branches[trg].visual.order_group > branch.visual.order_group)
 973 |                 .unwrap_or(false);
 974 | 
 975 |         let len = group_occ.len();
 976 |         let mut found = len;
 977 |         for i in 0..len {
 978 |             let index = if align_right { len - i - 1 } else { i };
 979 |             let column_occ = &group_occ[index];
 980 |             let mut occ = false;
 981 |             for (s, e) in column_occ {
 982 |                 if start <= *e && end >= *s {
 983 |                     occ = true;
 984 |                     break;
 985 |                 }
 986 |             }
 987 |             if !occ {
 988 |                 if let Some(merge_trace) = branch
 989 |                     .merge_target
 990 |                     .and_then(|t| indices.get(&t))
 991 |                     .and_then(|t_idx| commits[*t_idx].branch_trace)
 992 |                 {
 993 |                     let merge_branch = &branches[merge_trace];
 994 |                     if merge_branch.visual.order_group == branch.visual.order_group {
 995 |                         if let Some(merge_column) = merge_branch.visual.column {
 996 |                             if merge_column == index {
 997 |                                 occ = true;
 998 |                             }
 999 |                         }
1000 |                     }
1001 |                 }
1002 |             }
1003 |             if !occ {
1004 |                 found = index;
1005 |                 break;
1006 |             }
1007 |         }
1008 | 
1009 |         let branch = &mut branches[branch_idx];
1010 |         branch.visual.column = Some(found);
1011 |         if found == group_occ.len() {
1012 |             group_occ.push(vec![]);
1013 |         }
1014 |         group_occ[found].push((start, end));
1015 |     }
1016 | 
1017 |     // Compute start column of each group
1018 |     let mut group_offset: Vec<usize> = vec![];
1019 |     let mut acc = 0;
1020 |     for group in occupied {
1021 |         group_offset.push(acc);
1022 |         acc += group.len();
1023 |     }
1024 | 
1025 |     // Compute branch column. Up till now we have computed the branch group
1026 |     // and the column offset within that group. This was to make it easy to
1027 |     // insert columns between groups. Now it is time to convert offset relative
1028 |     // to the group the final column.
1029 |     for branch in branches {
1030 |         if let Some(column) = branch.visual.column {
1031 |             let offset = group_offset[branch.visual.order_group];
1032 |             branch.visual.column = Some(column + offset);
1033 |         }
1034 |     }
1035 | }
1036 | 
1037 | /// Finds the index for a branch name from a slice of prefixes
1038 | fn branch_order(name: &str, order: &[Regex]) -> usize {
1039 |     order
1040 |         .iter()
1041 |         .position(|b| (name.starts_with(ORIGIN) && b.is_match(&name[7..])) || b.is_match(name))
1042 |         .unwrap_or(order.len())
1043 | }
1044 | 
1045 | /// Finds the svg color for a branch name.
1046 | fn branch_color<T: Clone>(
1047 |     name: &str,
1048 |     order: &[(Regex, Vec<T>)],
1049 |     unknown: &[T],
1050 |     counter: usize,
1051 | ) -> T {
1052 |     let stripped_name = name.strip_prefix(ORIGIN).unwrap_or(name);
1053 | 
1054 |     for (regex, colors) in order {
1055 |         if regex.is_match(stripped_name) {
1056 |             return colors[counter % colors.len()].clone();
1057 |         }
1058 |     }
1059 | 
1060 |     unknown[counter % unknown.len()].clone()
1061 | }
1062 | 
1063 | /// Tries to extract the name of a merged-in branch from the merge commit summary.
1064 | pub fn parse_merge_summary(summary: &str, patterns: &MergePatterns) -> Option<String> {
1065 |     for regex in &patterns.patterns {
1066 |         if let Some(captures) = regex.captures(summary) {
1067 |             if captures.len() == 2 && captures.get(1).is_some() {
1068 |                 return captures.get(1).map(|m| m.as_str().to_string());
1069 |             }
1070 |         }
1071 |     }
1072 |     None
1073 | }
1074 | 
1075 | #[cfg(test)]
1076 | mod tests {
1077 |     use crate::settings::MergePatterns;
1078 | 
1079 |     #[test]
1080 |     fn parse_merge_summary() {
1081 |         let patterns = MergePatterns::default();
1082 | 
1083 |         let gitlab_pull = "Merge branch 'feature/my-feature' into 'master'";
1084 |         let git_default = "Merge branch 'feature/my-feature' into dev";
1085 |         let git_master = "Merge branch 'feature/my-feature'";
1086 |         let github_pull = "Merge pull request #1 from user-x/feature/my-feature";
1087 |         let github_pull_2 = "Merge branch 'feature/my-feature' of github.com:user-x/repo";
1088 |         let bitbucket_pull = "Merged in feature/my-feature (pull request #1)";
1089 | 
1090 |         assert_eq!(
1091 |             super::parse_merge_summary(gitlab_pull, &patterns),
1092 |             Some("feature/my-feature".to_string()),
1093 |         );
1094 |         assert_eq!(
1095 |             super::parse_merge_summary(git_default, &patterns),
1096 |             Some("feature/my-feature".to_string()),
1097 |         );
1098 |         assert_eq!(
1099 |             super::parse_merge_summary(git_master, &patterns),
1100 |             Some("feature/my-feature".to_string()),
1101 |         );
1102 |         assert_eq!(
1103 |             super::parse_merge_summary(github_pull, &patterns),
1104 |             Some("feature/my-feature".to_string()),
1105 |         );
1106 |         assert_eq!(
1107 |             super::parse_merge_summary(github_pull_2, &patterns),
1108 |             Some("feature/my-feature".to_string()),
1109 |         );
1110 |         assert_eq!(
1111 |             super::parse_merge_summary(bitbucket_pull, &patterns),
1112 |             Some("feature/my-feature".to_string()),
1113 |         );
1114 |     }
1115 | }
1116 | 


--------------------------------------------------------------------------------