delta-gitu 0.1.5

An experimental fork of gitu (a git client inspired by Magit), published as a library for delta to embed
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use crate::items::RenderParams;
use std::{iter, rc::Rc, sync::Arc};

use crate::{
    Res,
    config::Config,
    git,
    item_data::{ItemData, SectionHeader},
    items::{self, Item, RenderedRow, hash},
};
use git2::Repository;

use super::Screen;

pub(crate) fn create(
    config: Arc<Config>,
    repo: Rc<Repository>,
    params: RenderParams,
    reference: String,
    target: Option<(String, u32)>,
) -> Res<Screen> {
    let mut screen = Screen::new(
        Arc::clone(&config),
        params,
        Box::new(move |params: RenderParams| {
            let commit = git::show_summary(repo.as_ref(), &reference)?;
            let show = git::show(repo.as_ref(), &reference, params.context.as_deref())?;

            // The header as the user's show command draws it, its first row
            // heading the commit; or gitu's own.
            let (heading, details): (Option<RenderedRow>, Vec<Item>) =
                match items::rendered_show_header(&config, &repo, &params, &commit.hash) {
                    Some(rows) => {
                        let mut rows = rows.into_iter();
                        let heading = rows.next();
                        let details = rows
                            .map(|row| Item {
                                id: hash(["commit", &commit.hash]),
                                depth: 1,
                                unselectable: true,
                                rendered: Some(Rc::new(row)),
                                ..Default::default()
                            })
                            .collect();
                        (heading, details)
                    }
                    None => (
                        None,
                        commit
                            .details
                            .lines()
                            .map(|line| Item {
                                id: hash(["commit", &commit.hash]),
                                depth: 1,
                                unselectable: true,
                                data: ItemData::Raw(line.to_string()),
                                ..Default::default()
                            })
                            .collect(),
                    ),
                };

            Ok(iter::once(Item {
                id: hash(["commit_section", &commit.hash]),
                depth: 0,
                data: ItemData::Header(SectionHeader::Commit(commit.hash.clone())),
                rendered: heading.map(Rc::new),
                ..Default::default()
            })
            .chain(details)
            .chain([items::blank_line()])
            .chain(items::create_diff_items(
                &config,
                &params,
                &Rc::new(show),
                0,
                false,
                Some(commit.hash.clone()),
            ))
            .collect())
        }),
    )?;

    if let Some((file, line_num)) = target {
        let found = screen.select_matching(|data| {
            if let ItemData::HunkLine {
                diff,
                file_i,
                hunk_i,
                line_i,
                line_range,
                ..
            } = data
            {
                if diff.file_diffs[*file_i].header.new_file.fmt(&diff.text) != file {
                    return false;
                }
                let line = &diff.hunk_content(*file_i, *hunk_i)[line_range.clone()];
                !line.starts_with('-')
                    && diff.hunk_line_new_file_num(*file_i, *hunk_i, *line_i) == line_num
            } else {
                false
            }
        });
        if !found {
            screen.select_matching(|data| {
                matches!(data, ItemData::Delta { diff, file_i, .. }
                    if diff.file_diffs[*file_i].header.new_file.fmt(&diff.text) == file)
            });
        }
    }

    Ok(screen)
}