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
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
// SPDX MIT Bernhard Guillon 2025
//
// As this project is currently in research please just ignore
// all clones and memory copies ^^ As on all my rust projects
// I follow the copy all and fix it later approach. To make
// rust a nice prototyping languague. If you don't like that
// approach you do yours and I do mine ^^
use serde::{Deserialize, Serialize};
use std::time::{SystemTime, UNIX_EPOCH};
use std::{
env::{temp_dir, var},
fs::File,
io::Read,
process::Command,
process::Stdio,
};
use std::fs;
use std::fmt;
use std::num::ParseIntError;
use std::io::Write;
use std::collections::HashMap;
use chrono::{NaiveDateTime, Utc, TimeZone};
#[derive(Serialize, Deserialize, Debug, Default, Clone)]
struct BugReport {
timestamp: String,
status: String,
title: String,
description: Vec<String>,
tags: Option<String>,
version: String
}
fn new_bug() {
let editor = var("EDITOR").unwrap();
let mut file_path = temp_dir(); // TODO: figgure out how to get .git dir in a save manner
file_path.push("NEW_BUG_REPORT");
File::create(&file_path).expect("Could not create file");
Command::new(editor)
.arg(&file_path)
.status()
.expect("Something went wrong");
let mut new_bug_report = String::new();
let _ = File::open(&file_path)
.expect("Could not open file")
.read_to_string(&mut new_bug_report);
let _ = fs::remove_file(&file_path);
let mut header = "";
let mut description: Vec::<String> = Vec::new();
for (i, line) in new_bug_report.lines().enumerate() {
match i {
0 => header = line,
1 => (),
_ => description.push(line.to_string()),
}
}
let report = BugReport {
timestamp: SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs().to_string(),
title: header.to_owned(),
description: description.to_owned(),
status: "new".to_owned(),
tags: None,
version: "v1".to_owned(),
};
let j = serde_json::to_string(&report).unwrap();
print!("{}", j);
}
#[derive(Debug)]
enum GitError {
GitLog(String),
Parse(ParseIntError)
}
impl fmt::Display for GitError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
GitError::GitLog(s) => write!(f, "{}", s),
GitError::Parse(s) => write!(f, "{}", s),
}
}
}
impl From<ParseIntError> for GitError {
fn from(err: ParseIntError) -> GitError {
GitError::Parse(err)
}
}
impl std::error::Error for GitError {}
#[derive(Debug, Default, Clone)]
struct GitLog{
timestamp: u64,
hash: String,
author_name: String,
author_email: String,
blob_object: String,
}
fn collect_reachable_objects() -> Result<(Vec<GitLog>, String), GitError> {
// TODO: until we have the need for archiving old stuff to archive
// we can guarantee that all objects collected exist and are
// unchanged. As soon as we support archives we might need to
// change this approach a bit.
// As we use the first two chars of a git hash as directory name and
// the other part as file name we are able to regenerate the hash
// from the changed file path. Git log can provide the file path
// as well as all other needed information.
let mut git_logs: Vec<GitLog> = Vec::new();
let mut blobs = String::default();
let logs = Command::new("git")
.arg("log")
.arg("--pretty=format:%H#%an#%ae#%at")
.arg("--name-only")
.arg("refs/notes/devtools/future-me")
.output()
.expect("Error with git log");
if !logs.status.success() {
GitError::GitLog(String::from_utf8_lossy(&logs.stderr).to_string());
}
let lines = String::from_utf8_lossy(&logs.stdout);
let mut git_log = GitLog::default();
for (i, line) in lines.lines().enumerate() {
match i%3 {
0 => {
let parts = line.split("#");
for (i, part) in parts.enumerate() {
match i%4 {
0 => git_log.hash=part.to_string(),
1 => git_log.author_name = part.to_string(),
2 => git_log.author_email = part.to_string(),
3 => git_log.timestamp = part.parse::<u64>()?,
_ => todo!(), // TODO: why we need this?
}
}
},
1 => {
git_log.blob_object = line.replace("/", "");
if blobs.len() > 0 {
blobs = blobs + "\n" + &git_log.blob_object;
}
else {
blobs = blobs + &git_log.blob_object;
}
},
2 => (), // commit seperator
_ => todo!(), // TODO: why we need this?
}
if i>=1 && i%3 ==1 {
git_logs.push(git_log.clone());
}
}
return Ok((git_logs, blobs));
}
fn show() {
// TODO: split this function to collect the reports and to show them
// in the desired format.
// For a short log we don't need to do all this extra work ^^
let (logs, blobs) = collect_reachable_objects().unwrap();
let mut files = Command::new("git")
.arg("cat-file")
.arg("--batch")
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.spawn()
.expect("Error with git cat-files --batch");
let mut stdin = files.stdin.take().expect("Failed to open stdin");
std::thread::spawn(move || {
stdin.write_all(blobs.as_bytes()).expect("Failed to write to stdin");
});
let output = files.wait_with_output().expect("Failed to write to stdout");
let objects = String::from_utf8_lossy(&output.stdout);
let mut map: HashMap<String, BugReport> = HashMap::new();
let mut bug_report: BugReport = BugReport::default();
let mut hash: String = String::default();
for (i, object) in objects.lines().enumerate() {
match i%3 {
0 => hash = object.split(" ").next().unwrap().to_string(),
1 => bug_report = serde_json::from_str(&object).unwrap(),
2 => (),
_ => todo!(),
}
if i>=1 && i%3 ==1 {
map.insert(hash.clone(), bug_report.clone());
}
}
for log in logs {
let entry = map[&log.blob_object].clone();
let datetime = Utc.timestamp_opt(log.timestamp as i64, 0).unwrap();
// TODO: do we really need to be able to convert times? Or should we just
// collect the git time with the possibilites git gives us?
// I don't like the chrono dependency :/
println!("-------------------------------------------------------------------------");
println!{"{} {} {} {}\t{}", &log.hash[0..7], entry.status, log.author_name, entry.title, datetime.format("%Y-%m-%d %H:%M:%S")};
for line in entry.description {
println!("{}", line);
}
}
}
fn main() {
//new_bug();
show();
}
|
