awpack 0.1.0

A package manager for the Awesome tiling window manager
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

pub use self::error::Error;
pub use self::package::{Package, PackagePath, PackageError};
pub use self::package_manager::PackageManager;

mod package_manager;
mod package;
mod error;

extern crate git2;
extern crate toml;
extern crate walkdir;
extern crate clap;

use std::{env, process};

use clap::{Arg, App, SubCommand};

fn main() {
    let directory = env::home_dir().unwrap().
        join(".config").
        join("awesome").
        join("awpack");

    let mut package_manager = match PackageManager::new(directory) {
        Ok(pacman) => pacman,
        Err(e) => {
            println!("error: {}", e);
            process::exit(1);
        },
    };

    let matches = App::new("awpack")
                              .version("0.1")
                              .author("Dylan McKay <dylanmckay34@gmail.com>")
                              .about("Manage packages for the Awesome window manager")
                              .subcommand(SubCommand::with_name("install")
                                          .about("installs a new package")
                                          .arg_from_usage("-d, --debug 'Print debug information'")
                                          .arg(Arg::with_name("package")
                                               .required(true)
                                               .help("the package to install")))
                              .subcommand(SubCommand::with_name("uninstall")
                                          .about("uninstalls a new package")
                                          .arg(Arg::with_name("package")
                                               .required(true)
                                               .help("the package to uninstall")))
                              .subcommand(SubCommand::with_name("info")
                                          .about("queries install packages")
                                          .arg(Arg::with_name("package")
                                               .required(false)
                                               .help("the package to show")))
                              .subcommand(SubCommand::with_name("update")
                                          .about("updates packages")
                                          .arg(Arg::with_name("package")
                                               .required(false)
                                               .help("the package to updae")))
                              .get_matches();

    match matches.subcommand() {
        ("install", Some(submatch)) => {
            let package_path = self::parse_package_path(submatch.value_of("package"));

            match package_manager.install(&package_path) {
                Ok(..) => println!("installed {}", package_path),
                Err(e) => println!("error: {}", e),
            }
        },
        ("uninstall", Some(submatch)) => {
            let package_path = self::parse_package_path(submatch.value_of("package"));

            match package_manager.uninstall(&package_path) {
                Ok(..) => println!("uninstalled {}", package_path),
                Err(e) => println!("error: {}", e),
            }
        },
        ("update", Some(submatch)) => {
            if let Some(package_path) = submatch.value_of("package") {
                let package_path = self::parse_package_path(Some(package_path));

                match package_manager.lookup_mut(&package_path) {
                    Some(package) => self::update_package(package),
                    None => {
                        println!("package is not installed");
                        process::exit(1);
                    },
                }
            } else {
                for package in package_manager.packages.values_mut() {
                    self::update_package(package);
                }
            }
        },
        ("info", Some(submatch)) => {

            if submatch.is_present("package") {
                let package_path = self::parse_package_path(submatch.value_of("package"));
                match package_manager.lookup(&package_path) {
                    Some(package) => {
                        println!("{} ({})", package.remote_path, package.revision);
                    },
                    None => {
                        println!("package is not installed");
                        process::exit(1);
                    },
                }
            } else {
                for package in package_manager.packages.values() {
                    println!("{}", package.name);
                }
            }

        },
        _ => (),
    }
}

fn update_package(package: &mut Package) {
    println!("updating {}", package.remote_path);

    match package.update() {
        Ok(was_changed) => {
            if was_changed {
                println!("updated to {}", package.revision);
            } else {
                println!("already up-to-date");
            }
        },
        Err(e) => {
            println!("error: {}", e);
            process::exit(1);
        },
    }
}

fn parse_package_path(name: Option<&str>) -> PackagePath {
    let text = match name {
        Some(package) => package,
        None => {
            println!("no package given");
            process::exit(1);
        },
    };

    match text.parse() {
        Ok(path) => path,
        Err(..) => {
            println!("'{}' is not a valid package", text);
            process::exit(1);
        },
    }
}