git.iko.soy/bat
on 0f06d3b help sign in
bat/src/input.rs
300 lines 8.2 kB history raw
1use std::ffi::{OsStr, OsString};
2use std::fs::File;
3use std::io::{self, BufRead, BufReader, Read};
5use content_inspector::{self, ContentType};
7use crate::error::*;
9/// A description of an Input source.
10/// This tells bat how to refer to the input.
11#[derive(Clone)]
12pub struct InputDescription {
13 pub(crate) name: String,
15 /// The input title.
16 /// This replaces the name if provided.
17 title: Option<String>,
19 /// The input kind.
20 kind: Option<String>,
22 /// A summary description of the input.
23 /// Defaults to "{kind} '{name}'"
24 summary: Option<String>,
27impl InputDescription {
28 /// Creates a description for an input.
29 pub fn new(name: impl Into<String>) -> Self {
30 InputDescription {
31 name: name.into(),
32 title: None,
33 kind: None,
34 summary: None,
35 }
36 }
38 pub fn set_kind(&mut self, kind: Option<String>) -> () {
39 self.kind = kind;
40 }
42 pub fn set_summary(&mut self, summary: Option<String>) -> () {
43 self.summary = summary;
44 }
46 pub fn set_title(&mut self, title: Option<String>) -> () {
47 self.title = title;
48 }
50 pub fn title(&self) -> &String {
51 match self.title.as_ref() {
52 Some(ref title) => title,
53 None => &self.name,
54 }
55 }
57 pub fn kind(&self) -> Option<&String> {
58 self.kind.as_ref()
59 }
61 pub fn summary(&self) -> String {
62 self.summary.clone().unwrap_or_else(|| match &self.kind {
63 None => self.name.clone(),
64 Some(kind) => format!("{} '{}'", kind.to_lowercase(), self.name),
65 })
66 }
69pub(crate) enum InputKind<'a> {
70 OrdinaryFile(OsString),
71 StdIn,
72 CustomReader(Box<dyn Read + 'a>),
75impl<'a> InputKind<'a> {
76 pub fn description(&self) -> InputDescription {
77 match self {
78 InputKind::OrdinaryFile(ref path) => InputDescription::new(path.to_string_lossy()),
79 InputKind::StdIn => InputDescription::new("STDIN"),
80 InputKind::CustomReader(_) => InputDescription::new("READER"),
81 }
82 }
85#[derive(Clone, Default)]
86pub(crate) struct InputMetadata {
87 pub(crate) user_provided_name: Option<OsString>,
90pub struct Input<'a> {
91 pub(crate) kind: InputKind<'a>,
92 pub(crate) metadata: InputMetadata,
93 pub(crate) description: InputDescription,
96pub(crate) enum OpenedInputKind {
97 OrdinaryFile(OsString),
98 StdIn,
99 CustomReader,
102pub(crate) struct OpenedInput<'a> {
103 pub(crate) kind: OpenedInputKind,
104 pub(crate) metadata: InputMetadata,
105 pub(crate) reader: InputReader<'a>,
106 pub(crate) description: InputDescription,
109impl<'a> Input<'a> {
110 pub fn ordinary_file(path: &OsStr) -> Self {
111 let kind = InputKind::OrdinaryFile(path.to_os_string());
112 Input {
113 description: kind.description(),
114 metadata: InputMetadata::default(),
115 kind,
116 }
117 }
119 pub fn stdin() -> Self {
120 let kind = InputKind::StdIn;
121 Input {
122 description: kind.description(),
123 metadata: InputMetadata::default(),
124 kind,
125 }
126 }
128 pub fn from_reader(reader: Box<dyn Read + 'a>) -> Self {
129 let kind = InputKind::CustomReader(reader);
130 Input {
131 description: kind.description(),
132 metadata: InputMetadata::default(),
133 kind,
134 }
135 }
137 pub fn is_stdin(&self) -> bool {
138 if let InputKind::StdIn = self.kind {
139 true
140 } else {
141 false
142 }
143 }
145 pub fn with_name(mut self, provided_name: Option<&OsStr>) -> Self {
146 match provided_name {
147 Some(name) => self.description.name = name.to_string_lossy().to_string(),
148 None => {}
149 }
151 self.metadata.user_provided_name = provided_name.map(|n| n.to_owned());
152 self
153 }
155 pub fn as_file(mut self, provided_name: Option<&OsStr>) -> Self {
156 self.description.kind = Some("File".to_owned());
157 self.with_name(provided_name)
158 }
160 pub fn description(&self) -> &InputDescription {
161 &self.description
162 }
164 pub fn description_mut(&mut self) -> &mut InputDescription {
165 &mut self.description
166 }
168 pub(crate) fn open<R: BufRead + 'a>(self, stdin: R) -> Result<OpenedInput<'a>> {
169 let description = self.description().clone();
170 match self.kind {
171 InputKind::StdIn => Ok(OpenedInput {
172 kind: OpenedInputKind::StdIn,
173 description,
174 metadata: self.metadata,
175 reader: InputReader::new(stdin),
176 }),
177 InputKind::OrdinaryFile(path) => Ok(OpenedInput {
178 kind: OpenedInputKind::OrdinaryFile(path.clone()),
179 description,
180 metadata: self.metadata,
181 reader: {
182 let file = File::open(&path)
183 .map_err(|e| format!("'{}': {}", path.to_string_lossy(), e))?;
184 if file.metadata()?.is_dir() {
185 return Err(format!("'{}' is a directory.", path.to_string_lossy()).into());
186 }
187 InputReader::new(BufReader::new(file))
188 },
189 }),
190 InputKind::CustomReader(reader) => Ok(OpenedInput {
191 description,
192 kind: OpenedInputKind::CustomReader,
193 metadata: self.metadata,
194 reader: InputReader::new(BufReader::new(reader)),
195 }),
196 }
197 }
200pub(crate) struct InputReader<'a> {
201 inner: Box<dyn BufRead + 'a>,
202 pub(crate) first_line: Vec<u8>,
203 pub(crate) content_type: Option<ContentType>,
206impl<'a> InputReader<'a> {
207 fn new<R: BufRead + 'a>(mut reader: R) -> InputReader<'a> {
208 let mut first_line = vec![];
209 reader.read_until(b'\n', &mut first_line).ok();
211 let content_type = if first_line.is_empty() {
212 None
213 } else {
214 Some(content_inspector::inspect(&first_line[..]))
215 };
217 if content_type == Some(ContentType::UTF_16LE) {
218 reader.read_until(0x00, &mut first_line).ok();
219 }
221 InputReader {
222 inner: Box::new(reader),
223 first_line,
224 content_type,
225 }
226 }
228 pub(crate) fn read_line(&mut self, buf: &mut Vec<u8>) -> io::Result<bool> {
229 if self.first_line.is_empty() {
230 let res = self.inner.read_until(b'\n', buf).map(|size| size > 0)?;
232 if self.content_type == Some(ContentType::UTF_16LE) {
233 self.inner.read_until(0x00, buf).ok();
234 }
236 Ok(res)
237 } else {
238 buf.append(&mut self.first_line);
239 Ok(true)
240 }
241 }
244#[test]
245fn basic() {
246 let content = b"#!/bin/bash\necho hello";
247 let mut reader = InputReader::new(&content[..]);
249 assert_eq!(b"#!/bin/bash\n", &reader.first_line[..]);
251 let mut buffer = vec![];
253 let res = reader.read_line(&mut buffer);
254 assert!(res.is_ok());
255 assert_eq!(true, res.unwrap());
256 assert_eq!(b"#!/bin/bash\n", &buffer[..]);
258 buffer.clear();
260 let res = reader.read_line(&mut buffer);
261 assert!(res.is_ok());
262 assert_eq!(true, res.unwrap());
263 assert_eq!(b"echo hello", &buffer[..]);
265 buffer.clear();
267 let res = reader.read_line(&mut buffer);
268 assert!(res.is_ok());
269 assert_eq!(false, res.unwrap());
270 assert!(buffer.is_empty());
273#[test]
274fn utf16le() {
275 let content = b"\xFF\xFE\x73\x00\x0A\x00\x64\x00";
276 let mut reader = InputReader::new(&content[..]);
278 assert_eq!(b"\xFF\xFE\x73\x00\x0A\x00", &reader.first_line[..]);
280 let mut buffer = vec![];
282 let res = reader.read_line(&mut buffer);
283 assert!(res.is_ok());
284 assert_eq!(true, res.unwrap());
285 assert_eq!(b"\xFF\xFE\x73\x00\x0A\x00", &buffer[..]);
287 buffer.clear();
289 let res = reader.read_line(&mut buffer);
290 assert!(res.is_ok());
291 assert_eq!(true, res.unwrap());
292 assert_eq!(b"\x64\x00", &buffer[..]);
294 buffer.clear();
296 let res = reader.read_line(&mut buffer);
297 assert!(res.is_ok());
298 assert_eq!(false, res.unwrap());
299 assert!(buffer.is_empty());