git.iko.soy/bat
on v0.21.0 help sign in
bat/src/input.rs
352 lines 10 kB history raw
1use std::convert::TryFrom;
2use std::fs;
3use std::fs::File;
4use std::io::{self, BufRead, BufReader, Read};
5use std::path::{Path, PathBuf};
7use clircle::{Clircle, Identifier};
8use content_inspector::{self, ContentType};
10use crate::error::*;
12/// A description of an Input source.
13/// This tells bat how to refer to the input.
14#[derive(Clone)]
15pub struct InputDescription {
16 pub(crate) name: String,
18 /// The input title.
19 /// This replaces the name if provided.
20 title: Option<String>,
22 /// The input kind.
23 kind: Option<String>,
25 /// A summary description of the input.
26 /// Defaults to "{kind} '{name}'"
27 summary: Option<String>,
30impl InputDescription {
31 /// Creates a description for an input.
32 pub fn new(name: impl Into<String>) -> Self {
33 InputDescription {
34 name: name.into(),
35 title: None,
36 kind: None,
37 summary: None,
38 }
39 }
41 pub fn set_kind(&mut self, kind: Option<String>) {
42 self.kind = kind;
43 }
45 pub fn set_summary(&mut self, summary: Option<String>) {
46 self.summary = summary;
47 }
49 pub fn set_title(&mut self, title: Option<String>) {
50 self.title = title;
51 }
53 pub fn title(&self) -> &String {
54 match &self.title {
55 Some(title) => title,
56 None => &self.name,
57 }
58 }
60 pub fn kind(&self) -> Option<&String> {
61 self.kind.as_ref()
62 }
64 pub fn summary(&self) -> String {
65 self.summary.clone().unwrap_or_else(|| match &self.kind {
66 None => self.name.clone(),
67 Some(kind) => format!("{} '{}'", kind.to_lowercase(), self.name),
68 })
69 }
72pub(crate) enum InputKind<'a> {
73 OrdinaryFile(PathBuf),
74 StdIn,
75 CustomReader(Box<dyn Read + 'a>),
78impl<'a> InputKind<'a> {
79 pub fn description(&self) -> InputDescription {
80 match self {
81 InputKind::OrdinaryFile(ref path) => InputDescription::new(path.to_string_lossy()),
82 InputKind::StdIn => InputDescription::new("STDIN"),
83 InputKind::CustomReader(_) => InputDescription::new("READER"),
84 }
85 }
88#[derive(Clone, Default)]
89pub(crate) struct InputMetadata {
90 pub(crate) user_provided_name: Option<PathBuf>,
91 pub(crate) size: Option<u64>,
94pub struct Input<'a> {
95 pub(crate) kind: InputKind<'a>,
96 pub(crate) metadata: InputMetadata,
97 pub(crate) description: InputDescription,
100pub(crate) enum OpenedInputKind {
101 OrdinaryFile(PathBuf),
102 StdIn,
103 CustomReader,
106pub(crate) struct OpenedInput<'a> {
107 pub(crate) kind: OpenedInputKind,
108 pub(crate) metadata: InputMetadata,
109 pub(crate) reader: InputReader<'a>,
110 pub(crate) description: InputDescription,
113impl OpenedInput<'_> {
114 /// Get the path of the file:
115 /// If this was set by the metadata, that will take priority.
116 /// If it wasn't, it will use the real file path (if available).
117 pub(crate) fn path(&self) -> Option<&PathBuf> {
118 self.metadata
119 .user_provided_name
120 .as_ref()
121 .or(match self.kind {
122 OpenedInputKind::OrdinaryFile(ref path) => Some(path),
123 _ => None,
124 })
125 }
128impl<'a> Input<'a> {
129 pub fn ordinary_file(path: impl AsRef<Path>) -> Self {
130 Self::_ordinary_file(path.as_ref())
131 }
133 fn _ordinary_file(path: &Path) -> Self {
134 let kind = InputKind::OrdinaryFile(path.to_path_buf());
135 let metadata = InputMetadata {
136 size: fs::metadata(path).map(|m| m.len()).ok(),
137 ..InputMetadata::default()
138 };
140 Input {
141 description: kind.description(),
142 metadata,
143 kind,
144 }
145 }
147 pub fn stdin() -> Self {
148 let kind = InputKind::StdIn;
149 Input {
150 description: kind.description(),
151 metadata: InputMetadata::default(),
152 kind,
153 }
154 }
156 pub fn from_reader(reader: Box<dyn Read + 'a>) -> Self {
157 let kind = InputKind::CustomReader(reader);
158 Input {
159 description: kind.description(),
160 metadata: InputMetadata::default(),
161 kind,
162 }
163 }
165 pub fn is_stdin(&self) -> bool {
166 matches!(self.kind, InputKind::StdIn)
167 }
169 pub fn with_name(self, provided_name: Option<impl AsRef<Path>>) -> Self {
170 self._with_name(provided_name.as_ref().map(|it| it.as_ref()))
171 }
173 fn _with_name(mut self, provided_name: Option<&Path>) -> Self {
174 if let Some(name) = provided_name {
175 self.description.name = name.to_string_lossy().to_string()
176 }
178 self.metadata.user_provided_name = provided_name.map(|n| n.to_owned());
179 self
180 }
182 pub fn description(&self) -> &InputDescription {
183 &self.description
184 }
186 pub fn description_mut(&mut self) -> &mut InputDescription {
187 &mut self.description
188 }
190 pub(crate) fn open<R: BufRead + 'a>(
191 self,
192 stdin: R,
193 stdout_identifier: Option<&Identifier>,
194 ) -> Result<OpenedInput<'a>> {
195 let description = self.description().clone();
196 match self.kind {
197 InputKind::StdIn => {
198 if let Some(stdout) = stdout_identifier {
199 let input_identifier = Identifier::try_from(clircle::Stdio::Stdin)
200 .map_err(|e| format!("Stdin: Error identifying file: {}", e))?;
201 if stdout.surely_conflicts_with(&input_identifier) {
202 return Err("IO circle detected. The input from stdin is also an output. Aborting to avoid infinite loop.".into());
203 }
204 }
206 Ok(OpenedInput {
207 kind: OpenedInputKind::StdIn,
208 description,
209 metadata: self.metadata,
210 reader: InputReader::new(stdin),
211 })
212 }
214 InputKind::OrdinaryFile(path) => Ok(OpenedInput {
215 kind: OpenedInputKind::OrdinaryFile(path.clone()),
216 description,
217 metadata: self.metadata,
218 reader: {
219 let mut file = File::open(&path)
220 .map_err(|e| format!("'{}': {}", path.to_string_lossy(), e))?;
221 if file.metadata()?.is_dir() {
222 return Err(format!("'{}' is a directory.", path.to_string_lossy()).into());
223 }
225 if let Some(stdout) = stdout_identifier {
226 let input_identifier = Identifier::try_from(file).map_err(|e| {
227 format!("{}: Error identifying file: {}", path.to_string_lossy(), e)
228 })?;
229 if stdout.surely_conflicts_with(&input_identifier) {
230 return Err(format!(
231 "IO circle detected. The input from '{}' is also an output. Aborting to avoid infinite loop.",
232 path.to_string_lossy()
233 )
234 .into());
235 }
236 file = input_identifier.into_inner().expect("The file was lost in the clircle::Identifier, this should not have happened...");
237 }
239 InputReader::new(BufReader::new(file))
240 },
241 }),
242 InputKind::CustomReader(reader) => Ok(OpenedInput {
243 description,
244 kind: OpenedInputKind::CustomReader,
245 metadata: self.metadata,
246 reader: InputReader::new(BufReader::new(reader)),
247 }),
248 }
249 }
252pub(crate) struct InputReader<'a> {
253 inner: Box<dyn BufRead + 'a>,
254 pub(crate) first_line: Vec<u8>,
255 pub(crate) content_type: Option<ContentType>,
258impl<'a> InputReader<'a> {
259 fn new<R: BufRead + 'a>(mut reader: R) -> InputReader<'a> {
260 let mut first_line = vec![];
261 reader.read_until(b'\n', &mut first_line).ok();
263 let content_type = if first_line.is_empty() {
264 None
265 } else {
266 Some(content_inspector::inspect(&first_line[..]))
267 };
269 if content_type == Some(ContentType::UTF_16LE) {
270 reader.read_until(0x00, &mut first_line).ok();
271 }
273 InputReader {
274 inner: Box::new(reader),
275 first_line,
276 content_type,
277 }
278 }
280 pub(crate) fn read_line(&mut self, buf: &mut Vec<u8>) -> io::Result<bool> {
281 if !self.first_line.is_empty() {
282 buf.append(&mut self.first_line);
283 return Ok(true);
284 }
286 let res = self.inner.read_until(b'\n', buf).map(|size| size > 0)?;
288 if self.content_type == Some(ContentType::UTF_16LE) {
289 let _ = self.inner.read_until(0x00, buf);
290 }
292 Ok(res)
293 }
296#[test]
297fn basic() {
298 let content = b"#!/bin/bash\necho hello";
299 let mut reader = InputReader::new(&content[..]);
301 assert_eq!(b"#!/bin/bash\n", &reader.first_line[..]);
303 let mut buffer = vec![];
305 let res = reader.read_line(&mut buffer);
306 assert!(res.is_ok());
307 assert!(res.unwrap());
308 assert_eq!(b"#!/bin/bash\n", &buffer[..]);
310 buffer.clear();
312 let res = reader.read_line(&mut buffer);
313 assert!(res.is_ok());
314 assert!(res.unwrap());
315 assert_eq!(b"echo hello", &buffer[..]);
317 buffer.clear();
319 let res = reader.read_line(&mut buffer);
320 assert!(res.is_ok());
321 assert!(!res.unwrap());
322 assert!(buffer.is_empty());
325#[test]
326fn utf16le() {
327 let content = b"\xFF\xFE\x73\x00\x0A\x00\x64\x00";
328 let mut reader = InputReader::new(&content[..]);
330 assert_eq!(b"\xFF\xFE\x73\x00\x0A\x00", &reader.first_line[..]);
332 let mut buffer = vec![];
334 let res = reader.read_line(&mut buffer);
335 assert!(res.is_ok());
336 assert!(res.unwrap());
337 assert_eq!(b"\xFF\xFE\x73\x00\x0A\x00", &buffer[..]);
339 buffer.clear();
341 let res = reader.read_line(&mut buffer);
342 assert!(res.is_ok());
343 assert!(res.unwrap());
344 assert_eq!(b"\x64\x00", &buffer[..]);
346 buffer.clear();
348 let res = reader.read_line(&mut buffer);
349 assert!(res.is_ok());
350 assert!(!res.unwrap());
351 assert!(buffer.is_empty());