pijul 0.7.2

A patch-based distributed version control system, easy to use and fast. Command-line interface.
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

use clap::{SubCommand, ArgMatches, Arg};
use commands::{BasicOptions, StaticSubcommand, ask, default_explain};
use libpijul::fs_representation::{read_patch_nochanges, id_file};
use base64::URL_SAFE_NO_PAD;
use error::Error;
use std::fs::File;
use std::io::Read;
use std::str;
use term;

pub fn invocation() -> StaticSubcommand {
    SubCommand::with_name("changes")
        .about("List the patches applied to the given branch")
        .arg(Arg::with_name("repository")
            .long("repository")
            .help("Path to the repository to list.")
            .takes_value(true))
        .arg(Arg::with_name("branch")
            .long("branch")
            .help("The branch to list.")
             .takes_value(true))
        .arg(Arg::with_name("hash-only")
            .long("hash-only")
            .help("Only display the hash of each path."))
}

pub fn run(args: &ArgMatches) -> Result<(), Error> {
    let opts = BasicOptions::from_args(args)?;
    let hash_only = args.is_present("hash-only");
    if hash_only {
        // If in binary form, start with this repository's id.
        let id_file = id_file(&opts.repo_root);
        let mut f = File::open(&id_file)?;
        let mut s = String::new();
        f.read_to_string(&mut s)?;
        println!("{}", s.trim());
    }

    let repo = opts.open_repo()?;
    let txn = try!(repo.txn_begin());
    if let Some(branch) = txn.get_branch(&opts.branch()) {
        if hash_only {
            for (s, hash) in txn.iter_applied(&branch, None) {
                let hash_ext = txn.get_external(hash).unwrap();
                println!("{}:{}", hash_ext.to_base64(URL_SAFE_NO_PAD), s)
            }
        } else {
            for (_, hash) in txn.rev_iter_applied(&branch, None) {
                let hash_ext = txn.get_external(hash).unwrap();
                let patch = read_patch_nochanges(&opts.repo_root, hash_ext)?;
                let mut term = term::stdout();
                ask::print_patch_descr(&mut term, &hash_ext.to_owned(), Some(hash), &patch)
            }
        }
    }
    Ok(())
}

pub fn explain(r: Result<(), Error>) {
    default_explain(r)
}