pijul 0.3.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
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
128
129
130
131
132
133
134
135
136
137

use commands::StaticSubcommand;
use clap::{SubCommand, ArgMatches, Arg};
use commands::get_wd;
use error;
use std::path::{PathBuf, Path};
use std::fs::{rename, metadata};

use libpijul::fs_representation::{pristine_dir, find_repo_root};
use libpijul::Repository;

use std;
use rand;
pub fn invocation() -> StaticSubcommand {
    return SubCommand::with_name("mv")
        .about("Change file names")
        .arg(Arg::with_name("files")
            .multiple(true)
            .help("Files to move.")
            .required(true)
            .min_values(2))
        .arg(Arg::with_name("repository")
            .long("repository")
            .help("Repository where the files are."));
}

#[derive(Debug)]
pub enum Movement {
    IntoDir { from: Vec<PathBuf>, to: PathBuf },
    FileToFile { from: PathBuf, to: PathBuf },
}

#[derive(Debug)]
pub struct Params<'a> {
    pub repository: Option<&'a Path>,
    pub movement: Movement,
}

pub fn parse_args<'a>(args: &'a ArgMatches) -> Params<'a> {
    let repository = args.value_of("repository").map(Path::new);
    let wd = get_wd(repository).unwrap();
    debug!("wd = {:?}", wd);
    let repo_root = find_repo_root(&wd).unwrap();
    debug!("repo_root = {:?}", repo_root);
    let mut repo_paths = Vec::new();
    for fname in args.values_of("files").unwrap() {
        debug!("fname: {:?}", fname);
        // if fname is absolute, erases current_dir.
        let mut path = std::env::current_dir().unwrap();
        path.push(fname);
        debug!("path = {:?}", path);
        let path = if let Ok(f) = std::fs::canonicalize(&path) {
            f
        } else {
            std::fs::canonicalize(&path.parent().unwrap()).unwrap().join(&path.file_name().unwrap())
        };
        debug!("path = {:?}", path);
        let path = path.strip_prefix(&repo_root).unwrap();
        debug!("path = {:?}", path);

        repo_paths.push(path.to_path_buf());
    }
    debug!("parse_args: done");
    let repo_paths = repo_paths;
    let (dest, origs) = repo_paths.split_last().unwrap();
    let target_path = repo_root.join(&dest);
    let to_dir = target_path.exists() && target_path.is_dir();

    if to_dir {
        Params {
            repository: repository,
            movement: Movement::IntoDir {
                from: Vec::from(origs),
                to: dest.clone(),
            },
        }
    } else {
        if origs.len() == 1 {
            Params {
                repository: repository,
                movement: Movement::FileToFile {
                    from: origs[0].clone(),
                    to: dest.clone(),
                },
            }
        } else {
            panic!("Cannot move files into {}: it is not a valid directory",
                   dest.to_string_lossy());
        }
    }
}


pub fn run<'a>(args: &Params<'a>) -> Result<(), error::Error> {
    let repo_root = try!(get_wd(args.repository));
    let pristine = pristine_dir(&repo_root);
    let repo = try!(Repository::open(&pristine, None).map_err(error::Error::Repository));
    let mut txn = try!(repo.mut_txn_begin(rand::thread_rng()));
    match args.movement {
        Movement::FileToFile { from: ref orig_path, to: ref dest_path } => {
            try!(txn.move_file(orig_path.as_path(), dest_path.as_path(), false));
            debug!("1 renaming {:?} into {:?}",
                   repo_root.join(orig_path.as_path()),
                   repo_root.join(dest_path.as_path()));
            try!(rename(repo_root.join(orig_path.as_path()),
                        repo_root.join(dest_path.as_path())));
            try!(txn.commit());
            Ok(())
        }
        Movement::IntoDir { from: ref orig_paths, to: ref dest_dir } => {
            for file in orig_paths {
                let f = &file.as_path();
                let repo_target_name = {
                    let target_basename = try!(f.file_name()
                        .ok_or(error::Error::InvalidPath(f.to_string_lossy().into_owned())));
                    dest_dir.as_path().join(&target_basename)
                };
                let is_dir = try!(metadata(&repo_root.join(f))).is_dir();
                try!(txn.move_file(f, &repo_target_name.as_path(), is_dir));
            }
            for file in orig_paths {
                let f = &file.as_path();
                let full_target_name = {
                    let target_basename = try!(f.file_name()
                        .ok_or(error::Error::InvalidPath(f.to_string_lossy().into_owned())));
                    dest_dir.as_path().join(&target_basename)
                };
                debug!("2 renaming {:?} into {:?}",
                       repo_root.join(f),
                       repo_root.join(full_target_name.as_path()));
                try!(rename(&repo_root.join(f),
                            repo_root.join(full_target_name.as_path())));
            }
            try!(txn.commit());
            Ok(())
        }
    }
}