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
|
//! This file defines the binary for cheddar, which can be interacted
//! with in two different ways:
//!
//! 1. As a CLI tool that acts as a cgit filter.
//! 2. As a long-running HTTP server that handles rendering requests
//! (matching the SourceGraph protocol).
use clap::{App, Arg};
use rouille::{router, try_or_400, Response};
use serde::Deserialize;
use serde_json::json;
use std::collections::HashMap;
use std::io;
use cheddar::{format_code, format_markdown, THEMES};
// Server endpoint for rendering the syntax of source code. This
// replaces the 'syntect_server' component of Sourcegraph.
fn code_endpoint(request: &rouille::Request) -> rouille::Response {
#[derive(Deserialize)]
struct SourcegraphQuery {
filepath: String,
theme: String,
code: String,
}
let query: SourcegraphQuery = try_or_400!(rouille::input::json_input(request));
let mut buf: Vec<u8> = Vec::new();
// We don't use syntect with the sourcegraph themes bundled
// currently, so let's fall back to something that is kind of
// similar (tm).
let theme = &THEMES.themes[match query.theme.as_str() {
"Sourcegraph (light)" => "Solarized (light)",
_ => "Solarized (dark)",
}];
format_code(theme, &mut query.code.as_bytes(), &mut buf, &query.filepath);
Response::json(&json!({
"is_plaintext": false,
"data": String::from_utf8_lossy(&buf)
}))
}
// Server endpoint for rendering a Markdown file.
fn markdown_endpoint(request: &rouille::Request) -> rouille::Response {
let mut texts: HashMap<String, String> = try_or_400!(rouille::input::json_input(request));
for text in texts.values_mut() {
let mut buf: Vec<u8> = Vec::new();
format_markdown(&mut text.as_bytes(), &mut buf);
*text = String::from_utf8_lossy(&buf).to_string();
}
Response::json(&texts)
}
fn highlighting_server(listen: &str) {
println!("Starting syntax highlighting server on '{}'", listen);
rouille::start_server(listen, move |request| {
router!(request,
// Markdown rendering route
(POST) (/markdown) => {
markdown_endpoint(request)
},
// Code rendering route
(POST) (/) => {
code_endpoint(request)
},
_ => {
rouille::Response::empty_404()
},
)
});
}
fn main() {
// Parse the command-line flags passed to cheddar to determine
// whether it is running in about-filter mode (`--about-filter`)
// and what file extension has been supplied.
let matches = App::new("cheddar")
.about("TVL's syntax highlighter")
.arg(
Arg::with_name("about-filter")
.help("Run as a cgit about-filter (renders Markdown)")
.long("about-filter")
.takes_value(false),
)
.arg(
Arg::with_name("sourcegraph-server")
.help("Run as a Sourcegraph compatible web-server")
.long("sourcegraph-server")
.takes_value(false),
)
.arg(
Arg::with_name("listen")
.help("Address to listen on")
.long("listen")
.takes_value(true),
)
.arg(Arg::with_name("filename").help("File to render").index(1))
.get_matches();
if matches.is_present("sourcegraph-server") {
highlighting_server(
matches
.value_of("listen")
.expect("Listening address is required for server mode"),
);
return;
}
let filename = matches.value_of("filename").expect("filename is required");
let stdin = io::stdin();
let mut in_handle = stdin.lock();
let stdout = io::stdout();
let mut out_handle = stdout.lock();
if matches.is_present("about-filter") && filename.ends_with(".md") {
format_markdown(&mut in_handle, &mut out_handle);
} else {
format_code(
&THEMES.themes["InspiredGitHub"],
&mut in_handle,
&mut out_handle,
filename,
);
}
}
|
