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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
extern crate clap;
extern crate glob;
#[macro_use] extern crate log;
extern crate semver;
extern crate toml;
#[macro_use] extern crate version;
extern crate libimagrt;
extern crate libimagstore;
extern crate libimagutil;
use std::result::Result as RResult;
use std::process::exit;
use libimagrt::runtime::Runtime;
use libimagstore::store::FileLockEntry;
use libimagstore::store::Result as StoreResult;
use libimagutil::trace::trace_error;
mod error;
mod ui;
mod viewer;
use error::{ViewError, ViewErrorKind};
use ui::build_ui;
use viewer::Viewer;
use viewer::ViewInformation;
use viewer::stdout::StdoutViewer;
type Result<T> = RResult<T, ViewError>;
fn main() {
let name = "imag-view";
let version = &version!()[..];
let about = "View entries (readonly)";
let ui = build_ui(Runtime::get_default_cli_builder(name, version, about));
let rt = {
let rt = Runtime::new(ui);
if rt.is_ok() {
rt.unwrap()
} else {
println!("Could not set up Runtime");
println!("{:?}", rt.err().unwrap());
exit(1);
}
};
rt.init_logger();
debug!("Hello. Logging was just enabled");
debug!("I already set up the Runtime object and build the commandline interface parser.");
debug!("Lets get rollin' ...");
info!("No implementation yet");
let entry_id = rt.cli().value_of("id").unwrap(); // enforced by clap
if rt.cli().is_present("versions") {
view_versions_of(entry_id, &rt);
} else {
let entry_version = rt.cli().value_of("version");
let view_header = rt.cli().is_present("view-header");
let view_content = rt.cli().is_present("view-content");
let view_copy = rt.cli().is_present("view-copy");
let keep_copy = rt.cli().is_present("keep-copy");
let scmd = rt.cli().subcommand_matches("view-in");
if scmd.is_none() {
debug!("No commandline call");
exit(1);
}
let scmd = scmd.unwrap();
let viewer = {
if scmd.is_present("view-in-stdout") {
Box::new(StdoutViewer::new())
} else if scmd.is_present("view-in-ui") {
warn!("Viewing in UI is currently not supported, switch to stdout");
Box::new(StdoutViewer::new())
} else if scmd.is_present("view-in-browser") {
warn!("Viewing in browser is currently not supported, switch to stdout");
Box::new(StdoutViewer::new())
} else if scmd.is_present("view-in-texteditor") {
warn!("Viewing in texteditor is currently not supported, switch to stdout");
Box::new(StdoutViewer::new())
} else if scmd.is_present("view-in-custom") {
warn!("Viewing in custom is currently not supported, switch to stdout");
Box::new(StdoutViewer::new())
} else {
Box::new(StdoutViewer::new())
}
};
let entry = load_entry(entry_id, entry_version, &rt);
if entry.is_err() {
trace_error(&entry.err().unwrap());
exit(1);
}
let entry = entry.unwrap();
let view_info = ViewInformation {
entry: entry,
view_header: view_header,
view_content: view_content,
view_copy: view_copy,
keep_copy: keep_copy,
};
viewer.view(view_info);
}
}
// TODO: This is a shameless adaption of imag-store/src/util.rs
fn load_entry<'a>(id: &str,
version: Option<&str>,
rt: &'a Runtime)
-> StoreResult<FileLockEntry<'a>>
{
debug!("Checking path element for version");
let version = {
version.unwrap_or_else(|| {
id.split("~").last().unwrap_or_else(|| {
warn!("No version");
exit(1);
})
})
};
debug!("Building path from {:?} and {:?}", id, version);
let mut path = rt.store().path().clone();
if id.chars().next() == Some('/') {
path.push(format!("{}~{}", &id[1..id.len()], version));
} else {
path.push(format!("{}~{}", id, version));
}
// the above is the adaption...
rt.store().retrieve(path)
}
fn view_versions_of(id: &str, rt: &Runtime) {
use glob::glob;
let mut path = rt.store().path().clone();
if id.chars().next() == Some('/') {
path.push(format!("{}~*", &id[1..id.len()]));
} else {
path.push(format!("{}~*", id));
}
if let Some(path) = path.to_str() {
match glob(path) {
Ok(paths) =>
for entry in paths {
match entry {
Ok(path) => println!("{}", path.file_name().and_then(|s| s.to_str()).unwrap()),
Err(e) => trace_error(e.error()),
}
},
Err(e) => {
warn!("{}", e); // trace_error(&e); // error seems not to be implemented
debug!("Error in pattern");
exit(1);
},
}
} else {
warn!("Could not build glob() argument!");
}
}
|
