twin/ripgrep
1
0
Fork 0
mirror of https://github.com/BurntSushi/ripgrep.git synced 2025-05-19 09:40:22 -07:00
Code Issues Packages Projects Releases Wiki Activity

cleanup: replace try! with ?

Browse Source
This commit is contained in:
Balaji Sivaraman 2018-01-01 19:52:35 +05:30 committed by Andrew Gallant
parent ba1023e1e4
commit b6177f0459
16 changed files with 160 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
globset/README.md
View File

@ -36,7 +36,7 @@ This example shows how to match a single glob against a single file path.
```rust ```rust
use globset::Glob; use globset::Glob;
let glob = try!(Glob::new("*.rs")).compile_matcher(); let glob = Glob::new("*.rs")?.compile_matcher();
assert!(glob.is_match("foo.rs")); assert!(glob.is_match("foo.rs"));
assert!(glob.is_match("foo/bar.rs")); assert!(glob.is_match("foo/bar.rs"));
@ -51,8 +51,8 @@ semantics. In this example, we prevent wildcards from matching path separators.
```rust ```rust
use globset::GlobBuilder; use globset::GlobBuilder;
let glob = try!(GlobBuilder::new("*.rs") let glob = GlobBuilder::new("*.rs")
.literal_separator(true).build()).compile_matcher(); .literal_separator(true).build()?.compile_matcher();
assert!(glob.is_match("foo.rs")); assert!(glob.is_match("foo.rs"));
assert!(!glob.is_match("foo/bar.rs")); // no longer matches assert!(!glob.is_match("foo/bar.rs")); // no longer matches
@ -69,10 +69,10 @@ use globset::{Glob, GlobSetBuilder};
let mut builder = GlobSetBuilder::new(); let mut builder = GlobSetBuilder::new();
// A GlobBuilder can be used to configure each glob's match semantics // A GlobBuilder can be used to configure each glob's match semantics
// independently. // independently.
builder.add(try!(Glob::new("*.rs"))); builder.add(Glob::new("*.rs")?);
builder.add(try!(Glob::new("src/lib.rs"))); builder.add(Glob::new("src/lib.rs")?);
builder.add(try!(Glob::new("src/**/foo.rs"))); builder.add(Glob::new("src/**/foo.rs")?);
let set = try!(builder.build()); let set = builder.build()?;
assert_eq!(set.matches("src/bar/baz/foo.rs"), vec![0, 2]); assert_eq!(set.matches("src/bar/baz/foo.rs"), vec![0, 2]);
``` ```

32
globset/src/glob.rs
View File

@ -550,7 +550,7 @@ impl<'a> GlobBuilder<'a> {
prev: None, prev: None,
cur: None, cur: None,
}; };
try!(p.parse()); p.parse()?;
if p.stack.is_empty() { if p.stack.is_empty() {
Err(Error { Err(Error {
glob: Some(self.glob.to_string()), glob: Some(self.glob.to_string()),
@ -720,18 +720,18 @@ impl<'a> Parser<'a> {
fn parse(&mut self) -> Result<(), Error> { fn parse(&mut self) -> Result<(), Error> {
while let Some(c) = self.bump() { while let Some(c) = self.bump() {
match c { match c {
'?' => try!(self.push_token(Token::Any)), '?' => self.push_token(Token::Any)?,
'*' => try!(self.parse_star()), '*' => self.parse_star()?,
'[' => try!(self.parse_class()), '[' => self.parse_class()?,
'{' => try!(self.push_alternate()), '{' => self.push_alternate()?,
'}' => try!(self.pop_alternate()), '}' => self.pop_alternate()?,
',' => try!(self.parse_comma()), ',' => self.parse_comma()?,
c => { c => {
if is_separator(c) { if is_separator(c) {
// Normalize all patterns to use / as a separator. // Normalize all patterns to use / as a separator.
try!(self.push_token(Token::Literal('/'))) self.push_token(Token::Literal('/'))?
} else { } else {
try!(self.push_token(Token::Literal(c))) self.push_token(Token::Literal(c))?
} }
} }
} }
@ -789,19 +789,19 @@ impl<'a> Parser<'a> {
fn parse_star(&mut self) -> Result<(), Error> { fn parse_star(&mut self) -> Result<(), Error> {
let prev = self.prev; let prev = self.prev;
if self.chars.peek() != Some(&'*') { if self.chars.peek() != Some(&'*') {
try!(self.push_token(Token::ZeroOrMore)); self.push_token(Token::ZeroOrMore)?;
return Ok(()); return Ok(());
} }
assert!(self.bump() == Some('*')); assert!(self.bump() == Some('*'));
if !try!(self.have_tokens()) { if !self.have_tokens()? {
try!(self.push_token(Token::RecursivePrefix)); self.push_token(Token::RecursivePrefix)?;
let next = self.bump(); let next = self.bump();
if !next.map(is_separator).unwrap_or(true) { if !next.map(is_separator).unwrap_or(true) {
return Err(self.error(ErrorKind::InvalidRecursive)); return Err(self.error(ErrorKind::InvalidRecursive));
} }
return Ok(()); return Ok(());
} }
try!(self.pop_token()); self.pop_token()?;
if !prev.map(is_separator).unwrap_or(false) { if !prev.map(is_separator).unwrap_or(false) {
if self.stack.len() <= 1 if self.stack.len() <= 1
|| (prev != Some(',') && prev != Some('{')) { || (prev != Some(',') && prev != Some('{')) {
@ -873,7 +873,7 @@ impl<'a> Parser<'a> {
// invariant: in_range is only set when there is // invariant: in_range is only set when there is
// already at least one character seen. // already at least one character seen.
let r = ranges.last_mut().unwrap(); let r = ranges.last_mut().unwrap();
try!(add_to_last_range(&self.glob, r, '-')); add_to_last_range(&self.glob, r, '-')?;
in_range = false; in_range = false;
} else { } else {
assert!(!ranges.is_empty()); assert!(!ranges.is_empty());
@ -884,8 +884,8 @@ impl<'a> Parser<'a> {
if in_range { if in_range {
// invariant: in_range is only set when there is // invariant: in_range is only set when there is
// already at least one character seen. // already at least one character seen.
try!(add_to_last_range( add_to_last_range(
&self.glob, ranges.last_mut().unwrap(), c)); &self.glob, ranges.last_mut().unwrap(), c)?;
} else { } else {
ranges.push((c, c)); ranges.push((c, c));
} }

22
globset/src/lib.rs
View File

@ -22,7 +22,7 @@ This example shows how to match a single glob against a single file path.
# fn example() -> Result<(), globset::Error> { # fn example() -> Result<(), globset::Error> {
use globset::Glob; use globset::Glob;
let glob = try!(Glob::new("*.rs")).compile_matcher(); let glob = Glob::new("*.rs")?.compile_matcher();
assert!(glob.is_match("foo.rs")); assert!(glob.is_match("foo.rs"));
assert!(glob.is_match("foo/bar.rs")); assert!(glob.is_match("foo/bar.rs"));
@ -39,8 +39,8 @@ semantics. In this example, we prevent wildcards from matching path separators.
# fn example() -> Result<(), globset::Error> { # fn example() -> Result<(), globset::Error> {
use globset::GlobBuilder; use globset::GlobBuilder;
let glob = try!(GlobBuilder::new("*.rs") let glob = GlobBuilder::new("*.rs")
.literal_separator(true).build()).compile_matcher(); .literal_separator(true).build()?.compile_matcher();
assert!(glob.is_match("foo.rs")); assert!(glob.is_match("foo.rs"));
assert!(!glob.is_match("foo/bar.rs")); // no longer matches assert!(!glob.is_match("foo/bar.rs")); // no longer matches
@ -59,10 +59,10 @@ use globset::{Glob, GlobSetBuilder};
let mut builder = GlobSetBuilder::new(); let mut builder = GlobSetBuilder::new();
// A GlobBuilder can be used to configure each glob's match semantics // A GlobBuilder can be used to configure each glob's match semantics
// independently. // independently.
builder.add(try!(Glob::new("*.rs"))); builder.add(Glob::new("*.rs")?);
builder.add(try!(Glob::new("src/lib.rs"))); builder.add(Glob::new("src/lib.rs")?);
builder.add(try!(Glob::new("src/**/foo.rs"))); builder.add(Glob::new("src/**/foo.rs")?);
let set = try!(builder.build()); let set = builder.build()?;
assert_eq!(set.matches("src/bar/baz/foo.rs"), vec![0, 2]); assert_eq!(set.matches("src/bar/baz/foo.rs"), vec![0, 2]);
# Ok(()) } example().unwrap(); # Ok(()) } example().unwrap();
@ -412,8 +412,8 @@ impl GlobSet {
GlobSetMatchStrategy::Suffix(suffixes.suffix()), GlobSetMatchStrategy::Suffix(suffixes.suffix()),
GlobSetMatchStrategy::Prefix(prefixes.prefix()), GlobSetMatchStrategy::Prefix(prefixes.prefix()),
GlobSetMatchStrategy::RequiredExtension( GlobSetMatchStrategy::RequiredExtension(
try!(required_exts.build())), required_exts.build()?),
GlobSetMatchStrategy::Regex(try!(regexes.regex_set())), GlobSetMatchStrategy::Regex(regexes.regex_set()?),
], ],
}) })
} }
@ -767,7 +767,7 @@ impl MultiStrategyBuilder {
fn regex_set(self) -> Result<RegexSetStrategy, Error> { fn regex_set(self) -> Result<RegexSetStrategy, Error> {
Ok(RegexSetStrategy { Ok(RegexSetStrategy {
matcher: try!(new_regex_set(self.literals)), matcher: new_regex_set(self.literals)?,
map: self.map, map: self.map,
}) })
} }
@ -792,7 +792,7 @@ impl RequiredExtensionStrategyBuilder {
for (ext, regexes) in self.0.into_iter() { for (ext, regexes) in self.0.into_iter() {
exts.insert(ext.clone(), vec![]); exts.insert(ext.clone(), vec![]);
for (global_index, regex) in regexes { for (global_index, regex) in regexes {
let compiled = try!(new_regex(&regex)); let compiled = new_regex(&regex)?;
exts.get_mut(&ext).unwrap().push((global_index, compiled)); exts.get_mut(&ext).unwrap().push((global_index, compiled));
} }
} }

10
grep/src/nonl.rs
View File

@ -44,25 +44,23 @@ pub fn remove(expr: Expr, byte: u8) -> Result<Expr> {
} }
Group { e, i, name } => { Group { e, i, name } => {
Group { Group {
e: Box::new(try!(remove(*e, byte))), e: Box::new(remove(*e, byte)?),
i: i, i: i,
name: name, name: name,
} }
} }
Repeat { e, r, greedy } => { Repeat { e, r, greedy } => {
Repeat { Repeat {
e: Box::new(try!(remove(*e, byte))), e: Box::new(remove(*e, byte)?),
r: r, r: r,
greedy: greedy, greedy: greedy,
} }
} }
Concat(exprs) => { Concat(exprs) => {
Concat(try!( Concat(exprs.into_iter().map(|e| remove(e, byte)).collect::<Result<Vec<Expr>>>()?)
exprs.into_iter().map(|e| remove(e, byte)).collect()))
} }
Alternate(exprs) => { Alternate(exprs) => {
Alternate(try!( Alternate(exprs.into_iter().map(|e| remove(e, byte)).collect::<Result<Vec<Expr>>>()?)
exprs.into_iter().map(|e| remove(e, byte)).collect()))
} }
e => e, e => e,
}) })

14
grep/src/search.rs
View File

@ -141,11 +141,11 @@ impl GrepBuilder {
/// If there was a problem parsing or compiling the regex with the given /// If there was a problem parsing or compiling the regex with the given
/// options, then an error is returned. /// options, then an error is returned.
pub fn build(self) -> Result<Grep> { pub fn build(self) -> Result<Grep> {
let expr = try!(self.parse()); let expr = self.parse()?;
let literals = LiteralSets::create(&expr); let literals = LiteralSets::create(&expr);
let re = try!(self.regex(&expr)); let re = self.regex(&expr)?;
let required = match literals.to_regex_builder() { let required = match literals.to_regex_builder() {
Some(builder) => Some(try!(self.regex_build(builder))), Some(builder) => Some(self.regex_build(builder)?),
None => { None => {
match strip_unicode_word_boundaries(&expr) { match strip_unicode_word_boundaries(&expr) {
None => None, None => None,
@ -186,12 +186,12 @@ impl GrepBuilder {
/// the line terminator. /// the line terminator.
fn parse(&self) -> Result<syntax::Expr> { fn parse(&self) -> Result<syntax::Expr> {
let expr = let expr =
try!(syntax::ExprBuilder::new() syntax::ExprBuilder::new()
.allow_bytes(true) .allow_bytes(true)
.unicode(true) .unicode(true)
.case_insensitive(try!(self.is_case_insensitive())) .case_insensitive(self.is_case_insensitive()?)
.parse(&self.pattern)); .parse(&self.pattern)?;
let expr = try!(nonl::remove(expr, self.opts.line_terminator)); let expr = nonl::remove(expr, self.opts.line_terminator)?;
debug!("regex ast:\n{:#?}", expr); debug!("regex ast:\n{:#?}", expr);
Ok(expr) Ok(expr)
} }

10
ignore/src/gitignore.rs
View File

@ -322,13 +322,13 @@ impl GitignoreBuilder {
pub fn build(&self) -> Result<Gitignore, Error> { pub fn build(&self) -> Result<Gitignore, Error> {
let nignore = self.globs.iter().filter(|g| !g.is_whitelist()).count(); let nignore = self.globs.iter().filter(|g| !g.is_whitelist()).count();
let nwhite = self.globs.iter().filter(|g| g.is_whitelist()).count(); let nwhite = self.globs.iter().filter(|g| g.is_whitelist()).count();
let set = try!( let set =
self.builder.build().map_err(|err| { self.builder.build().map_err(|err| {
Error::Glob { Error::Glob {
glob: None, glob: None,
err: err.to_string(), err: err.to_string(),
} }
})); })?;
Ok(Gitignore { Ok(Gitignore {
set: set, set: set,
root: self.root.clone(), root: self.root.clone(),
@ -383,7 +383,7 @@ impl GitignoreBuilder {
gitignore: &str, gitignore: &str,
) -> Result<&mut GitignoreBuilder, Error> { ) -> Result<&mut GitignoreBuilder, Error> {
for line in gitignore.lines() { for line in gitignore.lines() {
try!(self.add_line(from.clone(), line)); self.add_line(from.clone(), line)?;
} }
Ok(self) Ok(self)
} }
@ -465,7 +465,7 @@ impl GitignoreBuilder {
if glob.actual.ends_with("/**") { if glob.actual.ends_with("/**") {
glob.actual = format!("{}/*", glob.actual); glob.actual = format!("{}/*", glob.actual);
} }
let parsed = try!( let parsed =
GlobBuilder::new(&glob.actual) GlobBuilder::new(&glob.actual)
.literal_separator(literal_separator) .literal_separator(literal_separator)
.case_insensitive(self.case_insensitive) .case_insensitive(self.case_insensitive)
@ -475,7 +475,7 @@ impl GitignoreBuilder {
glob: Some(glob.original.clone()), glob: Some(glob.original.clone()),
err: err.kind().to_string(), err: err.kind().to_string(),
} }
})); })?;
self.builder.add(parsed); self.builder.add(parsed);
self.globs.push(glob); self.globs.push(glob);
Ok(self) Ok(self)

6
ignore/src/overrides.rs
View File

@ -124,7 +124,7 @@ impl OverrideBuilder {
/// ///
/// Once a matcher is built, no new globs can be added to it. /// Once a matcher is built, no new globs can be added to it.
pub fn build(&self) -> Result<Override, Error> { pub fn build(&self) -> Result<Override, Error> {
Ok(Override(try!(self.builder.build()))) Ok(Override(self.builder.build()?))
} }
/// Add a glob to the set of overrides. /// Add a glob to the set of overrides.
@ -134,7 +134,7 @@ impl OverrideBuilder {
/// namely, `!` at the beginning of a glob will ignore a file. Without `!`, /// namely, `!` at the beginning of a glob will ignore a file. Without `!`,
/// all matches of the glob provided are treated as whitelist matches. /// all matches of the glob provided are treated as whitelist matches.
pub fn add(&mut self, glob: &str) -> Result<&mut OverrideBuilder, Error> { pub fn add(&mut self, glob: &str) -> Result<&mut OverrideBuilder, Error> {
try!(self.builder.add_line(None, glob)); self.builder.add_line(None, glob)?;
Ok(self) Ok(self)
} }
@ -144,7 +144,7 @@ impl OverrideBuilder {
pub fn case_insensitive( pub fn case_insensitive(
&mut self, yes: bool &mut self, yes: bool
) -> Result<&mut OverrideBuilder, Error> { ) -> Result<&mut OverrideBuilder, Error> {
try!(self.builder.case_insensitive(yes)); self.builder.case_insensitive(yes)?;
Ok(self) Ok(self)
} }
} }

10
ignore/src/types.rs
View File

@ -526,7 +526,7 @@ impl TypesBuilder {
} }
}; };
for (iglob, glob) in def.globs.iter().enumerate() { for (iglob, glob) in def.globs.iter().enumerate() {
build_set.add(try!( build_set.add(
GlobBuilder::new(glob) GlobBuilder::new(glob)
.literal_separator(true) .literal_separator(true)
.build() .build()
@ -535,14 +535,14 @@ impl TypesBuilder {
glob: Some(glob.to_string()), glob: Some(glob.to_string()),
err: err.kind().to_string(), err: err.kind().to_string(),
} }
}))); })?);
glob_to_selection.push((isel, iglob)); glob_to_selection.push((isel, iglob));
} }
selections.push(selection.clone().map(move |_| def)); selections.push(selection.clone().map(move |_| def));
} }
let set = try!(build_set.build().map_err(|err| { let set = build_set.build().map_err(|err| {
Error::Glob { glob: None, err: err.to_string() } Error::Glob { glob: None, err: err.to_string() }
})); })?;
Ok(Types { Ok(Types {
defs: defs, defs: defs,
selections: selections, selections: selections,
@ -655,7 +655,7 @@ impl TypesBuilder {
for type_name in types { for type_name in types {
let globs = self.types.get(type_name).unwrap().globs.clone(); let globs = self.types.get(type_name).unwrap().globs.clone();
for glob in globs { for glob in globs {
try!(self.add(name, &glob)); self.add(name, &glob)?;
} }
} }
Ok(()) Ok(())

12
ignore/src/walk.rs
View File

@ -279,13 +279,13 @@ impl DirEntryRaw {
depth: usize, depth: usize,
ent: &fs::DirEntry, ent: &fs::DirEntry,
) -> Result<DirEntryRaw, Error> { ) -> Result<DirEntryRaw, Error> {
let ty = try!(ent.file_type().map_err(|err| { let ty = ent.file_type().map_err(|err| {
let err = Error::Io(io::Error::from(err)).with_path(ent.path()); let err = Error::Io(io::Error::from(err)).with_path(ent.path());
Error::WithDepth { Error::WithDepth {
depth: depth, depth: depth,
err: Box::new(err), err: Box::new(err),
} }
})); })?;
Ok(DirEntryRaw::from_entry_os(depth, ent, ty)) Ok(DirEntryRaw::from_entry_os(depth, ent, ty))
} }
@ -322,9 +322,9 @@ impl DirEntryRaw {
#[cfg(not(unix))] #[cfg(not(unix))]
fn from_link(depth: usize, pb: PathBuf) -> Result<DirEntryRaw, Error> { fn from_link(depth: usize, pb: PathBuf) -> Result<DirEntryRaw, Error> {
let md = try!(fs::metadata(&pb).map_err(|err| { let md = fs::metadata(&pb).map_err(|err| {
Error::Io(err).with_path(&pb) Error::Io(err).with_path(&pb)
})); })?;
Ok(DirEntryRaw { Ok(DirEntryRaw {
path: pb, path: pb,
ty: md.file_type(), ty: md.file_type(),
@ -337,9 +337,9 @@ impl DirEntryRaw {
fn from_link(depth: usize, pb: PathBuf) -> Result<DirEntryRaw, Error> { fn from_link(depth: usize, pb: PathBuf) -> Result<DirEntryRaw, Error> {
use std::os::unix::fs::MetadataExt; use std::os::unix::fs::MetadataExt;
let md = try!(fs::metadata(&pb).map_err(|err| { let md = fs::metadata(&pb).map_err(|err| {
Error::Io(err).with_path(&pb) Error::Io(err).with_path(&pb)
})); })?;
Ok(DirEntryRaw { Ok(DirEntryRaw {
path: pb, path: pb,
ty: md.file_type(), ty: md.file_type(),

80
src/args.rs
View File

@ -312,27 +312,27 @@ impl<'a> ArgMatches<'a> {
fn to_args(&self) -> Result<Args> { fn to_args(&self) -> Result<Args> {
let paths = self.paths(); let paths = self.paths();
let line_number = self.line_number(&paths); let line_number = self.line_number(&paths);
let mmap = try!(self.mmap(&paths)); let mmap = self.mmap(&paths)?;
let with_filename = self.with_filename(&paths); let with_filename = self.with_filename(&paths);
let (before_context, after_context) = try!(self.contexts()); let (before_context, after_context) = self.contexts()?;
let quiet = self.is_present("quiet"); let quiet = self.is_present("quiet");
let args = Args { let args = Args {
paths: paths, paths: paths,
after_context: after_context, after_context: after_context,
before_context: before_context, before_context: before_context,
color_choice: self.color_choice(), color_choice: self.color_choice(),
colors: try!(self.color_specs()), colors: self.color_specs()?,
column: self.column(), column: self.column(),
context_separator: self.context_separator(), context_separator: self.context_separator(),
count: self.is_present("count"), count: self.is_present("count"),
encoding: try!(self.encoding()), encoding: self.encoding()?,
files_with_matches: self.is_present("files-with-matches"), files_with_matches: self.is_present("files-with-matches"),
files_without_matches: self.is_present("files-without-match"), files_without_matches: self.is_present("files-without-match"),
eol: b'\n', eol: b'\n',
files: self.is_present("files"), files: self.is_present("files"),
follow: self.is_present("follow"), follow: self.is_present("follow"),
glob_overrides: try!(self.overrides()), glob_overrides: self.overrides()?,
grep: try!(self.grep()), grep: self.grep()?,
heading: self.heading(), heading: self.heading(),
hidden: self.hidden(), hidden: self.hidden(),
ignore_files: self.ignore_files(), ignore_files: self.ignore_files(),
@ -340,10 +340,10 @@ impl<'a> ArgMatches<'a> {
line_number: line_number, line_number: line_number,
line_number_width: try!(self.usize_of("line-number-width")), line_number_width: try!(self.usize_of("line-number-width")),
line_per_match: self.is_present("vimgrep"), line_per_match: self.is_present("vimgrep"),
max_columns: try!(self.usize_of("max-columns")), max_columns: self.usize_of("max-columns")?,
max_count: try!(self.usize_of("max-count")).map(|max| max as u64), max_count: self.usize_of("max-count")?.map(|max| max as u64),
max_filesize: try!(self.max_filesize()), max_filesize: self.max_filesize()?,
maxdepth: try!(self.usize_of("maxdepth")), maxdepth: self.usize_of("maxdepth")?,
mmap: mmap, mmap: mmap,
no_ignore: self.no_ignore(), no_ignore: self.no_ignore(),
no_ignore_parent: self.no_ignore_parent(), no_ignore_parent: self.no_ignore_parent(),
@ -351,16 +351,16 @@ impl<'a> ArgMatches<'a> {
no_messages: self.is_present("no-messages"), no_messages: self.is_present("no-messages"),
null: self.is_present("null"), null: self.is_present("null"),
only_matching: self.is_present("only-matching"), only_matching: self.is_present("only-matching"),
path_separator: try!(self.path_separator()), path_separator: self.path_separator()?,
quiet: quiet, quiet: quiet,
quiet_matched: QuietMatched::new(quiet), quiet_matched: QuietMatched::new(quiet),
replace: self.replace(), replace: self.replace(),
sort_files: self.is_present("sort-files"), sort_files: self.is_present("sort-files"),
stdout_handle: self.stdout_handle(), stdout_handle: self.stdout_handle(),
text: self.text(), text: self.text(),
threads: try!(self.threads()), threads: self.threads()?,
type_list: self.is_present("type-list"), type_list: self.is_present("type-list"),
types: try!(self.types()), types: self.types()?,
with_filename: with_filename, with_filename: with_filename,
}; };
if args.mmap { if args.mmap {
@ -424,7 +424,7 @@ impl<'a> ArgMatches<'a> {
/// If any part of the pattern isn't valid UTF-8, then an error is /// If any part of the pattern isn't valid UTF-8, then an error is
/// returned. /// returned.
fn pattern(&self) -> Result<String> { fn pattern(&self) -> Result<String> {
Ok(try!(self.patterns()).join("|")) Ok(self.patterns()?.join("|"))
} }
/// Get a sequence of all available patterns from the command line. /// Get a sequence of all available patterns from the command line.
@ -445,13 +445,13 @@ impl<'a> ArgMatches<'a> {
None => { None => {
if self.values_of_os("file").is_none() { if self.values_of_os("file").is_none() {
if let Some(os_pat) = self.value_of_os("PATTERN") { if let Some(os_pat) = self.value_of_os("PATTERN") {
pats.push(try!(self.os_str_pattern(os_pat))); pats.push(self.os_str_pattern(os_pat)?);
} }
} }
} }
Some(os_pats) => { Some(os_pats) => {
for os_pat in os_pats { for os_pat in os_pats {
pats.push(try!(self.os_str_pattern(os_pat))); pats.push(self.os_str_pattern(os_pat)?);
} }
} }
} }
@ -460,12 +460,12 @@ impl<'a> ArgMatches<'a> {
if file == "-" { if file == "-" {
let stdin = io::stdin(); let stdin = io::stdin();
for line in stdin.lock().lines() { for line in stdin.lock().lines() {
pats.push(self.str_pattern(&try!(line))); pats.push(self.str_pattern(&line?));
} }
} else { } else {
let f = try!(fs::File::open(file)); let f = fs::File::open(file)?;
for line in io::BufReader::new(f).lines() { for line in io::BufReader::new(f).lines() {
pats.push(self.str_pattern(&try!(line))); pats.push(self.str_pattern(&line?));
} }
} }
} }
@ -481,7 +481,7 @@ impl<'a> ArgMatches<'a> {
/// ///
/// If the pattern is not valid UTF-8, then an error is returned. /// If the pattern is not valid UTF-8, then an error is returned.
fn os_str_pattern(&self, pat: &OsStr) -> Result<String> { fn os_str_pattern(&self, pat: &OsStr) -> Result<String> {
let s = try!(pattern_to_str(pat)); let s = pattern_to_str(pat)?;
Ok(self.str_pattern(s)) Ok(self.str_pattern(s))
} }
@ -581,8 +581,8 @@ impl<'a> ArgMatches<'a> {
/// `paths` should be a slice of all top-level file paths that ripgrep /// `paths` should be a slice of all top-level file paths that ripgrep
/// will need to search. /// will need to search.
fn mmap(&self, paths: &[PathBuf]) -> Result<bool> { fn mmap(&self, paths: &[PathBuf]) -> Result<bool> {
let (before, after) = try!(self.contexts()); let (before, after) = self.contexts()?;
let enc = try!(self.encoding()); let enc = self.encoding()?;
Ok(if before > 0 || after > 0 || self.is_present("no-mmap") { Ok(if before > 0 || after > 0 || self.is_present("no-mmap") {
false false
} else if self.is_present("mmap") { } else if self.is_present("mmap") {
@ -671,9 +671,9 @@ impl<'a> ArgMatches<'a> {
/// If there was a problem parsing the values from the user as an integer, /// If there was a problem parsing the values from the user as an integer,
/// then an error is returned. /// then an error is returned.
fn contexts(&self) -> Result<(usize, usize)> { fn contexts(&self) -> Result<(usize, usize)> {
let after = try!(self.usize_of("after-context")).unwrap_or(0); let after = self.usize_of("after-context")?.unwrap_or(0);
let before = try!(self.usize_of("before-context")).unwrap_or(0); let before = self.usize_of("before-context")?.unwrap_or(0);
let both = try!(self.usize_of("context")).unwrap_or(0); let both = self.usize_of("context")?.unwrap_or(0);
Ok(if both > 0 { Ok(if both > 0 {
(both, both) (both, both)
} else { } else {
@ -719,7 +719,7 @@ impl<'a> ArgMatches<'a> {
"match:style:bold".parse().unwrap(), "match:style:bold".parse().unwrap(),
]; ];
for spec_str in self.values_of_lossy_vec("colors") { for spec_str in self.values_of_lossy_vec("colors") {
specs.push(try!(spec_str.parse())); specs.push(spec_str.parse()?);
} }
Ok(ColorSpecs::new(&specs)) Ok(ColorSpecs::new(&specs))
} }
@ -752,7 +752,7 @@ impl<'a> ArgMatches<'a> {
if self.is_present("sort-files") { if self.is_present("sort-files") {
return Ok(1); return Ok(1);
} }
let threads = try!(self.usize_of("threads")).unwrap_or(0); let threads = self.usize_of("threads")?.unwrap_or(0);
Ok(if threads == 0 { Ok(if threads == 0 {
cmp::min(12, num_cpus::get()) cmp::min(12, num_cpus::get())
} else { } else {
@ -772,15 +772,15 @@ impl<'a> ArgMatches<'a> {
let casei = let casei =
self.is_present("ignore-case") self.is_present("ignore-case")
&& !self.is_present("case-sensitive"); && !self.is_present("case-sensitive");
let mut gb = GrepBuilder::new(&try!(self.pattern())) let mut gb = GrepBuilder::new(&self.pattern()?)
.case_smart(smart) .case_smart(smart)
.case_insensitive(casei) .case_insensitive(casei)
.line_terminator(b'\n'); .line_terminator(b'\n');
if let Some(limit) = try!(self.dfa_size_limit()) { if let Some(limit) = self.dfa_size_limit()? {
gb = gb.dfa_size_limit(limit); gb = gb.dfa_size_limit(limit);
} }
if let Some(limit) = try!(self.regex_size_limit()) { if let Some(limit) = self.regex_size_limit()? {
gb = gb.size_limit(limit); gb = gb.size_limit(limit);
} }
gb.build().map_err(From::from) gb.build().map_err(From::from)
@ -788,17 +788,17 @@ impl<'a> ArgMatches<'a> {
/// Builds the set of glob overrides from the command line flags. /// Builds the set of glob overrides from the command line flags.
fn overrides(&self) -> Result<Override> { fn overrides(&self) -> Result<Override> {
let mut ovr = OverrideBuilder::new(try!(env::current_dir())); let mut ovr = OverrideBuilder::new(env::current_dir()?);
for glob in self.values_of_lossy_vec("glob") { for glob in self.values_of_lossy_vec("glob") {
try!(ovr.add(&glob)); ovr.add(&glob)?;
} }
// this is smelly. In the long run it might make sense // this is smelly. In the long run it might make sense
// to change overridebuilder to be like globsetbuilder // to change overridebuilder to be like globsetbuilder
// but this would be a breaking change to the ignore crate // but this would be a breaking change to the ignore crate
// so it is being shelved for now... // so it is being shelved for now...
try!(ovr.case_insensitive(true)); ovr.case_insensitive(true)?;
for glob in self.values_of_lossy_vec("iglob") { for glob in self.values_of_lossy_vec("iglob") {
try!(ovr.add(&glob)); ovr.add(&glob)?;
} }
ovr.build().map_err(From::from) ovr.build().map_err(From::from)
} }
@ -811,7 +811,7 @@ impl<'a> ArgMatches<'a> {
btypes.clear(&ty); btypes.clear(&ty);
} }
for def in self.values_of_lossy_vec("type-add") { for def in self.values_of_lossy_vec("type-add") {
try!(btypes.add_def(&def)); btypes.add_def(&def)?;
} }
for ty in self.values_of_lossy_vec("type") { for ty in self.values_of_lossy_vec("type") {
btypes.select(&ty); btypes.select(&ty);
@ -835,12 +835,12 @@ impl<'a> ArgMatches<'a> {
None => return Ok(None) None => return Ok(None)
}; };
let re = regex::Regex::new("^([0-9]+)([KMG])?$").unwrap(); let re = regex::Regex::new("^([0-9]+)([KMG])?$").unwrap();
let caps = try!( let caps =
re.captures(&arg_value).ok_or_else(|| { re.captures(&arg_value).ok_or_else(|| {
format!("invalid format for {}", arg_name) format!("invalid format for {}", arg_name)
})); })?;
let value = try!(caps[1].parse::<u64>()); let value = caps[1].parse::<u64>()?;
let suffix = caps.get(2).map(|x| x.as_str()); let suffix = caps.get(2).map(|x| x.as_str());
let v_10 = value.checked_mul(1024); let v_10 = value.checked_mul(1024);
@ -865,13 +865,13 @@ impl<'a> ArgMatches<'a> {
/// Parse the dfa-size-limit argument option into a byte count. /// Parse the dfa-size-limit argument option into a byte count.
fn dfa_size_limit(&self) -> Result<Option<usize>> { fn dfa_size_limit(&self) -> Result<Option<usize>> {
let r = try!(self.parse_human_readable_size_arg("dfa-size-limit")); let r = self.parse_human_readable_size_arg("dfa-size-limit")?;
human_readable_to_usize("dfa-size-limit", r) human_readable_to_usize("dfa-size-limit", r)
} }
/// Parse the regex-size-limit argument option into a byte count. /// Parse the regex-size-limit argument option into a byte count.
fn regex_size_limit(&self) -> Result<Option<usize>> { fn regex_size_limit(&self) -> Result<Option<usize>> {
let r = try!(self.parse_human_readable_size_arg("regex-size-limit")); let r = self.parse_human_readable_size_arg("regex-size-limit")?;
human_readable_to_usize("regex-size-limit", r) human_readable_to_usize("regex-size-limit", r)
} }

16
src/decoder.rs
View File

@ -62,7 +62,7 @@ impl<R: io::Read> BomPeeker<R> {
} }
self.bom = Some(Bom { bytes: [0; 3], len: 0 }); self.bom = Some(Bom { bytes: [0; 3], len: 0 });
let mut buf = [0u8; 3]; let mut buf = [0u8; 3];
let bom_len = try!(read_full(&mut self.rdr, &mut buf)); let bom_len = read_full(&mut self.rdr, &mut buf)?;
self.bom = Some(Bom { bytes: buf, len: bom_len }); self.bom = Some(Bom { bytes: buf, len: bom_len });
Ok(self.bom.unwrap()) Ok(self.bom.unwrap())
} }
@ -71,7 +71,7 @@ impl<R: io::Read> BomPeeker<R> {
impl<R: io::Read> io::Read for BomPeeker<R> { impl<R: io::Read> io::Read for BomPeeker<R> {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
if self.nread < 3 { if self.nread < 3 {
let bom = try!(self.peek_bom()); let bom = self.peek_bom()?;
let bom = bom.as_slice(); let bom = bom.as_slice();
if self.nread < bom.len() { if self.nread < bom.len() {
let rest = &bom[self.nread..]; let rest = &bom[self.nread..];
@ -81,7 +81,7 @@ impl<R: io::Read> io::Read for BomPeeker<R> {
return Ok(len); return Ok(len);
} }
} }
let nread = try!(self.rdr.read(buf)); let nread = self.rdr.read(buf)?;
self.nread += nread; self.nread += nread;
Ok(nread) Ok(nread)
} }
@ -196,7 +196,7 @@ impl<R: io::Read, B: AsMut<[u8]>> DecodeReader<R, B> {
} }
self.pos = 0; self.pos = 0;
self.buflen += self.buflen +=
try!(self.rdr.read(&mut self.buf.as_mut()[self.buflen..])); self.rdr.read(&mut self.buf.as_mut()[self.buflen..])?;
Ok(()) Ok(())
} }
@ -219,7 +219,7 @@ impl<R: io::Read, B: AsMut<[u8]>> DecodeReader<R, B> {
return Ok(0); return Ok(0);
} }
if self.pos >= self.buflen { if self.pos >= self.buflen {
try!(self.fill()); self.fill()?;
} }
let mut nwrite = 0; let mut nwrite = 0;
loop { loop {
@ -235,7 +235,7 @@ impl<R: io::Read, B: AsMut<[u8]>> DecodeReader<R, B> {
} }
// Otherwise, we know that our internal buffer has insufficient // Otherwise, we know that our internal buffer has insufficient
// data to transcode at least one char, so we attempt to refill it. // data to transcode at least one char, so we attempt to refill it.
try!(self.fill()); self.fill()?;
// Quit on EOF. // Quit on EOF.
if self.buflen == 0 { if self.buflen == 0 {
self.pos = 0; self.pos = 0;
@ -251,7 +251,7 @@ impl<R: io::Read, B: AsMut<[u8]>> DecodeReader<R, B> {
#[inline(never)] // impacts perf... #[inline(never)] // impacts perf...
fn detect(&mut self) -> io::Result<()> { fn detect(&mut self) -> io::Result<()> {
let bom = try!(self.rdr.peek_bom()); let bom = self.rdr.peek_bom()?;
self.decoder = bom.decoder(); self.decoder = bom.decoder();
Ok(()) Ok(())
} }
@ -261,7 +261,7 @@ impl<R: io::Read, B: AsMut<[u8]>> io::Read for DecodeReader<R, B> {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
if self.first { if self.first {
self.first = false; self.first = false;
try!(self.detect()); self.detect()?;
} }
if self.decoder.is_none() { if self.decoder.is_none() {
return self.rdr.read(buf); return self.rdr.read(buf);

10
src/printer.rs
View File

@ -741,28 +741,28 @@ impl FromStr for Spec {
if pieces.len() <= 1 || pieces.len() > 3 { if pieces.len() <= 1 || pieces.len() > 3 {
return Err(Error::InvalidFormat(s.to_string())); return Err(Error::InvalidFormat(s.to_string()));
} }
let otype: OutType = try!(pieces[0].parse()); let otype: OutType = pieces[0].parse()?;
match try!(pieces[1].parse()) { match pieces[1].parse()? {
SpecType::None => Ok(Spec { ty: otype, value: SpecValue::None }), SpecType::None => Ok(Spec { ty: otype, value: SpecValue::None }),
SpecType::Style => { SpecType::Style => {
if pieces.len() < 3 { if pieces.len() < 3 {
return Err(Error::InvalidFormat(s.to_string())); return Err(Error::InvalidFormat(s.to_string()));
} }
let style: Style = try!(pieces[2].parse()); let style: Style = pieces[2].parse()?;
Ok(Spec { ty: otype, value: SpecValue::Style(style) }) Ok(Spec { ty: otype, value: SpecValue::Style(style) })
} }
SpecType::Fg => { SpecType::Fg => {
if pieces.len() < 3 { if pieces.len() < 3 {
return Err(Error::InvalidFormat(s.to_string())); return Err(Error::InvalidFormat(s.to_string()));
} }
let color: Color = try!(pieces[2].parse()); let color: Color = pieces[2].parse()?;
Ok(Spec { ty: otype, value: SpecValue::Fg(color) }) Ok(Spec { ty: otype, value: SpecValue::Fg(color) })
} }
SpecType::Bg => { SpecType::Bg => {
if pieces.len() < 3 { if pieces.len() < 3 {
return Err(Error::InvalidFormat(s.to_string())); return Err(Error::InvalidFormat(s.to_string()));
} }
let color: Color = try!(pieces[2].parse()); let color: Color = pieces[2].parse()?;
Ok(Spec { ty: otype, value: SpecValue::Bg(color) }) Ok(Spec { ty: otype, value: SpecValue::Bg(color) })
} }
} }

12
src/search_stream.rs
View File

@ -264,7 +264,7 @@ impl<'a, R: io::Read, W: WriteColor> Searcher<'a, R, W> {
while !self.terminate() { while !self.terminate() {
let upto = self.inp.lastnl; let upto = self.inp.lastnl;
self.print_after_context(upto); self.print_after_context(upto);
if !try!(self.fill()) { if !self.fill()? {
break; break;
} }
while !self.terminate() && self.inp.pos < self.inp.lastnl { while !self.terminate() && self.inp.pos < self.inp.lastnl {
@ -301,7 +301,7 @@ impl<'a, R: io::Read, W: WriteColor> Searcher<'a, R, W> {
} }
if self.after_context_remaining > 0 { if self.after_context_remaining > 0 {
if self.last_printed == self.inp.lastnl { if self.last_printed == self.inp.lastnl {
try!(self.fill()); self.fill()?;
} }
let upto = self.inp.lastnl; let upto = self.inp.lastnl;
if upto > 0 { if upto > 0 {
@ -349,9 +349,9 @@ impl<'a, R: io::Read, W: WriteColor> Searcher<'a, R, W> {
self.count_lines(keep); self.count_lines(keep);
self.last_line = 0; self.last_line = 0;
} }
let ok = try!(self.inp.fill(&mut self.haystack, keep).map_err(|err| { let ok = self.inp.fill(&mut self.haystack, keep).map_err(|err| {
Error::from_io(err, &self.path) Error::from_io(err, &self.path)
})); })?;
Ok(ok) Ok(ok)
} }
@ -595,8 +595,8 @@ impl InputBuffer {
let new_len = cmp::max(min_len, self.buf.len() * 2); let new_len = cmp::max(min_len, self.buf.len() * 2);
self.buf.resize(new_len, 0); self.buf.resize(new_len, 0);
} }
let n = try!(rdr.read( let n = rdr.read(
&mut self.buf[self.end..self.end + self.read_size])); &mut self.buf[self.end..self.end + self.read_size])?;
if !self.text { if !self.text {
if is_binary(&self.buf[self.end..self.end + n], self.first) { if is_binary(&self.buf[self.end..self.end + n], self.first) {
return Ok(false); return Ok(false);

4
src/worker.rs
View File

@ -282,7 +282,7 @@ impl Worker {
path: &Path, path: &Path,
file: &File, file: &File,
) -> Result<u64> { ) -> Result<u64> {
if try!(file.metadata()).len() == 0 { if file.metadata()?.len() == 0 {
// Opening a memory map with an empty file results in an error. // Opening a memory map with an empty file results in an error.
// However, this may not actually be an empty file! For example, // However, this may not actually be an empty file! For example,
// /proc/cpuinfo reports itself as an empty file, but it can // /proc/cpuinfo reports itself as an empty file, but it can
@ -290,7 +290,7 @@ impl Worker {
// regular read calls. // regular read calls.
return self.search(printer, path, file); return self.search(printer, path, file);
} }
let mmap = unsafe { try!(Mmap::map(file)) }; let mmap = unsafe { Mmap::map(file)? };
let buf = &*mmap; let buf = &*mmap;
if buf.len() >= 3 && Encoding::for_bom(buf).is_some() { if buf.len() >= 3 && Encoding::for_bom(buf).is_some() {
// If we have a UTF-16 bom in our memory map, then we need to fall // If we have a UTF-16 bom in our memory map, then we need to fall

10
termcolor/README.md
View File

@ -62,8 +62,8 @@ use std::io::Write;
use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor}; use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
let mut stdout = StandardStream::stdout(ColorChoice::Always); let mut stdout = StandardStream::stdout(ColorChoice::Always);
try!(stdout.set_color(ColorSpec::new().set_fg(Some(Color::Green)))); stdout.set_color(ColorSpec::new().set_fg(Some(Color::Green)))?;
try!(writeln!(&mut stdout, "green text!")); writeln!(&mut stdout, "green text!")?;
``` ```
### Example: using `BufferWriter` ### Example: using `BufferWriter`
@ -80,7 +80,7 @@ use termcolor::{BufferWriter, Color, ColorChoice, ColorSpec, WriteColor};
let mut bufwtr = BufferWriter::stderr(ColorChoice::Always); let mut bufwtr = BufferWriter::stderr(ColorChoice::Always);
let mut buffer = bufwtr.buffer(); let mut buffer = bufwtr.buffer();
try!(buffer.set_color(ColorSpec::new().set_fg(Some(Color::Green)))); buffer.set_color(ColorSpec::new().set_fg(Some(Color::Green)))?;
try!(writeln!(&mut buffer, "green text!")); writeln!(&mut buffer, "green text!")?;
try!(bufwtr.print(&buffer)); bufwtr.print(&buffer)?;
``` ```

56
termcolor/src/lib.rs
View File

@ -42,8 +42,8 @@ use std::io::Write;
use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor}; use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
let mut stdout = StandardStream::stdout(ColorChoice::Always); let mut stdout = StandardStream::stdout(ColorChoice::Always);
try!(stdout.set_color(ColorSpec::new().set_fg(Some(Color::Green)))); stdout.set_color(ColorSpec::new().set_fg(Some(Color::Green)))?;
try!(writeln!(&mut stdout, "green text!")); writeln!(&mut stdout, "green text!")?;
# Ok(()) } # Ok(()) }
``` ```
@ -62,9 +62,9 @@ use termcolor::{BufferWriter, Color, ColorChoice, ColorSpec, WriteColor};
let mut bufwtr = BufferWriter::stderr(ColorChoice::Always); let mut bufwtr = BufferWriter::stderr(ColorChoice::Always);
let mut buffer = bufwtr.buffer(); let mut buffer = bufwtr.buffer();
try!(buffer.set_color(ColorSpec::new().set_fg(Some(Color::Green)))); buffer.set_color(ColorSpec::new().set_fg(Some(Color::Green)))?;
try!(writeln!(&mut buffer, "green text!")); writeln!(&mut buffer, "green text!")?;
try!(bufwtr.print(&buffer)); bufwtr.print(&buffer)?;
# Ok(()) } # Ok(()) }
``` ```
*/ */
@ -486,7 +486,7 @@ impl<W: io::Write> WriteColor for WriterInner<W> {
WriterInner::Ansi(ref mut wtr) => wtr.set_color(spec), WriterInner::Ansi(ref mut wtr) => wtr.set_color(spec),
#[cfg(windows)] #[cfg(windows)]
WriterInner::Windows { ref mut wtr, ref console } => { WriterInner::Windows { ref mut wtr, ref console } => {
try!(wtr.flush()); wtr.flush()?;
let mut console = console.lock().unwrap(); let mut console = console.lock().unwrap();
spec.write_console(&mut *console) spec.write_console(&mut *console)
} }
@ -499,8 +499,8 @@ impl<W: io::Write> WriteColor for WriterInner<W> {
WriterInner::Ansi(ref mut wtr) => wtr.reset(), WriterInner::Ansi(ref mut wtr) => wtr.reset(),
#[cfg(windows)] #[cfg(windows)]
WriterInner::Windows { ref mut wtr, ref mut console } => { WriterInner::Windows { ref mut wtr, ref mut console } => {
try!(wtr.flush()); wtr.flush()?;
try!(console.lock().unwrap().reset()); console.lock().unwrap().reset()?;
Ok(()) Ok(())
} }
} }
@ -547,7 +547,7 @@ impl<'a, W: io::Write> WriteColor for WriterInnerLock<'a, W> {
WriterInnerLock::Ansi(ref mut wtr) => wtr.set_color(spec), WriterInnerLock::Ansi(ref mut wtr) => wtr.set_color(spec),
#[cfg(windows)] #[cfg(windows)]
WriterInnerLock::Windows { ref mut wtr, ref mut console } => { WriterInnerLock::Windows { ref mut wtr, ref mut console } => {
try!(wtr.flush()); wtr.flush()?;
spec.write_console(console) spec.write_console(console)
} }
} }
@ -560,8 +560,8 @@ impl<'a, W: io::Write> WriteColor for WriterInnerLock<'a, W> {
WriterInnerLock::Ansi(ref mut wtr) => wtr.reset(), WriterInnerLock::Ansi(ref mut wtr) => wtr.reset(),
#[cfg(windows)] #[cfg(windows)]
WriterInnerLock::Windows { ref mut wtr, ref mut console } => { WriterInnerLock::Windows { ref mut wtr, ref mut console } => {
try!(wtr.flush()); wtr.flush()?;
try!(console.reset()); console.reset()?;
Ok(()) Ok(())
} }
} }
@ -689,13 +689,13 @@ impl BufferWriter {
let mut stream = self.stream.wrap(self.stream.get_ref().lock()); let mut stream = self.stream.wrap(self.stream.get_ref().lock());
if let Some(ref sep) = self.separator { if let Some(ref sep) = self.separator {
if self.printed.load(Ordering::SeqCst) { if self.printed.load(Ordering::SeqCst) {
try!(stream.write_all(sep)); stream.write_all(sep)?;
try!(stream.write_all(b"\n")); stream.write_all(b"\n")?;
} }
} }
match buf.0 { match buf.0 {
BufferInner::NoColor(ref b) => try!(stream.write_all(&b.0)), BufferInner::NoColor(ref b) => stream.write_all(&b.0)?,
BufferInner::Ansi(ref b) => try!(stream.write_all(&b.0)), BufferInner::Ansi(ref b) => stream.write_all(&b.0)?,
#[cfg(windows)] #[cfg(windows)]
BufferInner::Windows(ref b) => { BufferInner::Windows(ref b) => {
// We guarantee by construction that we have a console here. // We guarantee by construction that we have a console here.
@ -703,7 +703,7 @@ impl BufferWriter {
let console_mutex = self.console.as_ref() let console_mutex = self.console.as_ref()
.expect("got Windows buffer but have no Console"); .expect("got Windows buffer but have no Console");
let mut console = console_mutex.lock().unwrap(); let mut console = console_mutex.lock().unwrap();
try!(b.print(&mut *console, &mut stream)); b.print(&mut *console, &mut stream)?;
} }
} }
self.printed.store(true, Ordering::SeqCst); self.printed.store(true, Ordering::SeqCst);
@ -959,15 +959,15 @@ impl<W: io::Write> WriteColor for Ansi<W> {
fn supports_color(&self) -> bool { true } fn supports_color(&self) -> bool { true }
fn set_color(&mut self, spec: &ColorSpec) -> io::Result<()> { fn set_color(&mut self, spec: &ColorSpec) -> io::Result<()> {
try!(self.reset()); self.reset()?;
if let Some(ref c) = spec.fg_color { if let Some(ref c) = spec.fg_color {
try!(self.write_color(true, c, spec.intense)); self.write_color(true, c, spec.intense)?;
} }
if let Some(ref c) = spec.bg_color { if let Some(ref c) = spec.bg_color {
try!(self.write_color(false, c, spec.intense)); self.write_color(false, c, spec.intense)?;
} }
if spec.bold { if spec.bold {
try!(self.write_str("\x1B[1m")); self.write_str("\x1B[1m")?;
} }
Ok(()) Ok(())
} }
@ -1090,15 +1090,15 @@ impl WindowsBuffer {
) -> io::Result<()> { ) -> io::Result<()> {
let mut last = 0; let mut last = 0;
for &(pos, ref spec) in &self.colors { for &(pos, ref spec) in &self.colors {
try!(stream.write_all(&self.buf[last..pos])); stream.write_all(&self.buf[last..pos])?;
try!(stream.flush()); stream.flush()?;
last = pos; last = pos;
match *spec { match *spec {
None => try!(console.reset()), None => console.reset()?,
Some(ref spec) => try!(spec.write_console(console)), Some(ref spec) => spec.write_console(console)?,
} }
} }
try!(stream.write_all(&self.buf[last..])); stream.write_all(&self.buf[last..])?;
stream.flush() stream.flush()
} }
@ -1213,10 +1213,10 @@ impl ColorSpec {
let intense = if self.intense { Intense::Yes } else { Intense::No }; let intense = if self.intense { Intense::Yes } else { Intense::No };
if let Some(color) = self.fg_color.as_ref().map(|c| c.to_windows()) { if let Some(color) = self.fg_color.as_ref().map(|c| c.to_windows()) {
try!(console.fg(intense, color)); console.fg(intense, color)?;
} }
if let Some(color) = self.bg_color.as_ref().map(|c| c.to_windows()) { if let Some(color) = self.bg_color.as_ref().map(|c| c.to_windows()) {
try!(console.bg(intense, color)); console.bg(intense, color)?;
} }
Ok(()) Ok(())
} }
@ -1368,7 +1368,7 @@ fn write_lossy_utf8<W: io::Write>(mut w: W, buf: &[u8]) -> io::Result<usize> {
match ::std::str::from_utf8(buf) { match ::std::str::from_utf8(buf) {
Ok(s) => w.write(s.as_bytes()), Ok(s) => w.write(s.as_bytes()),
Err(ref e) if e.valid_up_to() == 0 => { Err(ref e) if e.valid_up_to() == 0 => {
try!(w.write(b"\xEF\xBF\xBD")); w.write(b"\xEF\xBF\xBD")?;
Ok(1) Ok(1)
} }
Err(e) => w.write(&buf[..e.valid_up_to()]), Err(e) => w.write(&buf[..e.valid_up_to()]),