Check result of read_until, and return Error if 0, which indicates EO…

…F was found before delimeter.

src/controller.rs

@@ -45,7 +45,10 @@ impl<'b> Controller<'b> {
             match input_file.get_reader(&stdin) {
                 Err(error) => {
                     handle_error(&error);
-                    no_errors = false;
+                    match error {
+                        Error(ErrorKind::ImmediateEOF, _) => (),
+                        _ => no_errors = false
+                    }
                 }
                 Ok(mut reader) => {
                     let result = if self.config.loop_through {

src/inputfile.rs

@@ -14,21 +14,23 @@ pub struct InputFileReader<'a> {
 }
 
 impl<'a> InputFileReader<'a> {
-    fn new<R: BufRead + 'a>(mut reader: R) -> InputFileReader<'a> {
+    fn new<R: BufRead + 'a>(mut reader: R) -> Result<InputFileReader<'a>> {
         let mut first_line = vec![];
-        reader.read_until(b'\n', &mut first_line).ok();
+        if reader.read_until(b'\n', &mut first_line)? == 0 {
+            return Err(ErrorKind::ImmediateEOF.into())
+        }
 
         let content_type = content_inspector::inspect(&first_line[..]);
 
         if content_type == ContentType::UTF_16LE {
             reader.read_until(0x00, &mut first_line).ok();
         }
 
-        InputFileReader {
+        Ok(InputFileReader {
             inner: Box::new(reader),
             first_line,
             content_type,
-        }
+        })
     }
 
     pub fn read_line(&mut self, buf: &mut Vec<u8>) -> io::Result<bool> {
@@ -57,25 +59,25 @@ pub enum InputFile<'a> {
 impl<'a> InputFile<'a> {
     pub fn get_reader(&self, stdin: &'a io::Stdin) -> Result<InputFileReader> {
         match self {
-            InputFile::StdIn => Ok(InputFileReader::new(stdin.lock())),
+            InputFile::StdIn => InputFileReader::new(stdin.lock()),
             InputFile::Ordinary(filename) => {
                 let file = File::open(filename).map_err(|e| format!("'{}': {}", filename, e))?;
 
                 if file.metadata()?.is_dir() {
                     return Err(format!("'{}' is a directory.", filename).into());
                 }
 
-                Ok(InputFileReader::new(BufReader::new(file)))
+                InputFileReader::new(BufReader::new(file))
             }
-            InputFile::ThemePreviewFile => Ok(InputFileReader::new(THEME_PREVIEW_FILE)),
+            InputFile::ThemePreviewFile => InputFileReader::new(THEME_PREVIEW_FILE),
         }
     }
 }
 
 #[test]
 fn basic() {
     let content = b"#!/bin/bash\necho hello";
-    let mut reader = InputFileReader::new(&content[..]);
+    let mut reader = InputFileReader::new(&content[..]).unwrap();
 
     assert_eq!(b"#!/bin/bash\n", &reader.first_line[..]);
 
@@ -104,7 +106,7 @@ fn basic() {
 #[test]
 fn utf16le() {
     let content = b"\xFF\xFE\x73\x00\x0A\x00\x64\x00";
-    let mut reader = InputFileReader::new(&content[..]);
+    let mut reader = InputFileReader::new(&content[..]).unwrap();
 
     assert_eq!(b"\xFF\xFE\x73\x00\x0A\x00", &reader.first_line[..]);
 

src/main.rs

@@ -63,6 +63,9 @@ mod errors {
             SyntectError(::syntect::LoadingError);
             ParseIntError(::std::num::ParseIntError);
         }
+        errors {
+            ImmediateEOF
+        }
     }
 
     pub fn handle_error(error: &Error) {
@@ -72,6 +75,7 @@ mod errors {
             {
                 super::process::exit(0);
             }
+            &Error(ErrorKind::ImmediateEOF, _) => { () }
             _ => {
                 use ansi_term::Colour::Red;
                 eprintln!("{}: {}", Red.paint("[bat error]"), error);