nexedit 0.2.2

A vim-like text editor, with simple shortcuts.
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
115
116
117
118
119
120
121
122
123
124
125
126
127

use crate::commands::{self, Result};
use crate::errors;
use crate::errors::*;
use crate::models::application::{Application, ClipboardContent, Mode};
use git2;
use regex::Regex;
use std::cmp::Ordering;

pub fn add(app: &mut Application) -> Result {
    let repo = app.repository.as_ref().ok_or("No repository available")?;
    let buffer = app
        .workspace
        .current_buffer
        .as_ref()
        .ok_or(BUFFER_MISSING)?;
    let mut index = repo
        .index()
        .chain_err(|| "Couldn't get the repository index")?;
    let buffer_path = buffer.path.as_ref().ok_or(BUFFER_PATH_MISSING)?;
    let repo_path = repo.workdir().ok_or("No path found for the repository")?;
    let relative_path = buffer_path
        .strip_prefix(repo_path)
        .chain_err(|| "Failed to build a relative buffer path")?;

    index
        .add_path(relative_path)
        .chain_err(|| "Failed to add path to index.")?;
    index.write().chain_err(|| "Failed to write index.")
}

pub fn copy_remote_url(app: &mut Application) -> Result {
    if let Some(ref mut repo) = app.repository {
        let buffer = app
            .workspace
            .current_buffer
            .as_ref()
            .ok_or(BUFFER_MISSING)?;
        let buffer_path = buffer.path.as_ref().ok_or(BUFFER_PATH_MISSING)?;
        let remote = repo
            .find_remote("origin")
            .chain_err(|| "Couldn't find a remote \"origin\"")?;
        let url = remote.url().ok_or("No URL for remote/origin")?;

        let gh_path = get_gh_path(url)?;

        let repo_path = repo.workdir().ok_or("No path found for the repository")?;
        let relative_path = buffer_path
            .strip_prefix(repo_path)
            .chain_err(|| "Failed to build a relative buffer path")?;

        let status = repo
            .status_file(relative_path)
            .chain_err(|| "Couldn't get status info for the specified path")?;
        if status.contains(git2::Status::WT_NEW) || status.contains(git2::Status::INDEX_NEW) {
            bail!("The provided path doesn't exist in the repository");
        }

        let mut revisions = repo
            .revwalk()
            .chain_err(|| "Couldn't build a list of revisions for the repository")?;

        revisions
            .push_head()
            .chain_err(|| "Failed to push HEAD to commit graph.")?;

        let last_oid = revisions
            .next()
            .and_then(|revision| revision.ok())
            .ok_or("Couldn't find a git object ID for this file")?;

        let line_range = match app.mode {
            Mode::SelectLine(ref s) => {
                let line_1 = buffer.cursor.line + 1;
                let line_2 = s.anchor + 1;

                match line_1.cmp(&line_2) {
                    Ordering::Less => format!("#L{}-L{}", line_1, line_2),
                    Ordering::Greater => format!("#L{}-L{}", line_2, line_1),
                    Ordering::Equal => format!("#L{}", line_1),
                }
            }
            _ => String::new(),
        };

        let gh_url = format!(
            "https://github.com/{}/blob/{:?}/{}{}",
            gh_path,
            last_oid,
            relative_path.to_string_lossy(),
            line_range
        );

        app.clipboard
            .set_content(ClipboardContent::Inline(gh_url))?;
    } else {
        bail!("No repository available");
    }

    commands::application::switch_to_normal_mode(app)?;

    Ok(())
}

fn get_gh_path(url: &str) -> errors::Result<&str> {
    lazy_static! {
        static ref REGEX: Regex =
            Regex::new(r"^(?:https://|git@)github.com(?::|/)(.*?)(?:.git)?$").unwrap();
    }
    REGEX
        .captures(url)
        .and_then(|c| c.get(1))
        .map(|c| c.as_str())
        .chain_err(|| "Failed to capture remote repo path")
}

#[test]
fn test_get_gh_path() {
    let cases = [
        ("git@github.com:d3vboi/nexedit.git", "d3vboi/nexedit"),
        ("https://github.com/d3vboi/nexedit.git", "d3vboi/nexedit"),
        ("https://github.com/d3vboi/nexedit", "d3vboi/nexedit"),
    ];

    cases.iter().for_each(|(url, expected_gh_path)| {
        assert_eq!(&get_gh_path(url).unwrap(), expected_gh_path)
    })
}