pijul 0.5.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
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

use clap::{SubCommand, ArgMatches, Arg, Values};
use commands::{StaticSubcommand, default_explain};
use libpijul::{DEFAULT_BRANCH, Hash, apply_resize};
use libpijul::patch::Patch;
use libpijul::fs_representation::find_repo_root;

use error::Error;
use std::collections::HashSet;

use std::path::Path;
use std::io::{BufReader, stdin};
use super::{get_wd, get_current_branch};

pub fn invocation() -> StaticSubcommand {
    return SubCommand::with_name("apply")
        .about("apply a patch")
        .arg(Arg::with_name("patch")
            .help("Hash of the patch to apply, in base64. If no patch is given, patches are \
                   read from the standard input.")
            .takes_value(true)
            .multiple(true))
        .arg(Arg::with_name("repository")
            .long("repository")
            .help("Path to the repository where the patches will be applied.")
            .takes_value(true))
        .arg(Arg::with_name("branch")
            .long("branch")
            .help("The branch to which the patches will be applied.")
            .takes_value(true));
}

pub struct Params<'a> {
    pub repository: Option<&'a Path>,
    pub hashes: Option<Values<'a>>,
    pub branch: Option<&'a str>,
}

pub fn parse_args<'a>(args: &'a ArgMatches) -> Params<'a> {
    Params {
        repository: args.value_of("repository").map(|x| Path::new(x)),
        hashes: args.values_of("patch"),
        branch: args.value_of("branch"),
    }
}

pub fn run(params: &mut Params) -> Result<(), Error> {
    let wd = try!(get_wd(params.repository));
    match find_repo_root(&wd) {
        None => return Err(Error::NotInARepository),
        Some(ref target) => {
            debug!("applying");
            let branch_name = if let Some(b) = params.branch {
                b.to_string()
            } else if let Ok(b) = get_current_branch(target) {
                b
            } else {
                DEFAULT_BRANCH.to_string()
            };
            let remote: HashSet<Hash> = if let Some(hashes) = params.hashes.take() {
                hashes.map(|h| Hash::from_base64(&h).unwrap()).collect()
            } else {
                // Read patches in gz format from stdin.
                let mut hashes = HashSet::new();
                let mut buffered = BufReader::new(stdin());
                while let Ok((h, _, patch)) = Patch::from_reader_compressed(&mut buffered) {
                    debug!("{:?}", patch);
                    hashes.insert(h);
                    break;
                }
                hashes
            };

            debug!("remote={:?}", remote);
            loop {
                match apply_resize(&target, &branch_name, remote.iter()) {
                    Err(ref e) if e.lacks_space() => {}
                    Ok(()) => return Ok(()),
                    Err(e) => return Err(From::from(e)),
                }
            }
        }
    }
}

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