edward
/
git-config
Archived
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

pendantic clippy lints

master
Edward Shen 2021-02-27 23:19:25 -05:00
parent 3ff68bfaf8
commit 0ce311a1eb
Signed by: edward
GPG Key ID: 19182661E818369F
5 changed files with 42 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.toml
View File

@ -6,6 +6,8 @@ description = "A git-config file parser and editor from the gitoxide project"
license = "MIT OR Apache-2.0"
authors = ["Edward Shen <code@eddie.sh>"]
edition = "2018"
keywords = ["git-config", "git", "config", "gitoxide"]
categories = ["config", "parser-implementations"]
exclude = ["fuzz/**/*", ".vscode/**/*"]
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

10
src/config.rs
View File

@ -1,7 +1,6 @@
use crate::parser::{parse_from_bytes, Event, ParsedSectionHeader, Parser, ParserError};
use crate::parser::{parse_from_bytes, Error, Event, ParsedSectionHeader, Parser};
use std::collections::{HashMap, VecDeque};
use std::convert::TryFrom;
use std::error::Error;
use std::{borrow::Cow, fmt::Display};
#[derive(PartialEq, Eq, Hash, Copy, Clone, PartialOrd, Ord, Debug)]
@ -30,7 +29,7 @@ impl Display for GitConfigError<'_> {
}
}
impl Error for GitConfigError<'_> {}
impl std::error::Error for GitConfigError<'_> {}
/// The section ID is a monotonically increasing ID used to refer to sections.
/// This value does not imply any ordering between sections, as new sections
@ -51,6 +50,7 @@ enum LookupTreeNode<'a> {
Terminal(Vec<SectionId>),
NonTerminal(HashMap<Cow<'a, str>, Vec<SectionId>>),
}
/// High level `git-config` reader and writer.
///
/// Internally, this uses various acceleration data structures to improve
@ -537,7 +537,7 @@ impl<'a> GitConfig<'a> {
}
impl<'a> TryFrom<&'a str> for GitConfig<'a> {
type Error = ParserError<'a>;
type Error = Error<'a>;
/// Convenience constructor. Attempts to parse the provided string into a
/// [`GitConfig`]. See [`parse_from_str`] for more information.
@ -549,7 +549,7 @@ impl<'a> TryFrom<&'a str> for GitConfig<'a> {
}
impl<'a> TryFrom<&'a [u8]> for GitConfig<'a> {
type Error = ParserError<'a>;
type Error = Error<'a>;
/// Convenience constructor. Attempts to parse the provided byte string into
//// a [`GitConfig`]. See [`parse_from_bytes`] for more information.

5
src/lib.rs
View File

@ -1,6 +1,9 @@
#![forbid(unsafe_code)]
// #![deny(missing_docs)]
#![warn(clippy::pedantic, clippy::nursery, clippy::cargo)]
#![allow(clippy::must_use_candidate, clippy::shadow_unrelated)]
//! # git_config
//! # `git_config`
//!
//! This crate is a high performance `git-config` file reader and writer. It
//! exposes a high level API to parse, read, and write [`git-config` files],

67
src/parser.rs
View File

@ -18,8 +18,8 @@ use nom::error::{Error as NomError, ErrorKind};
use nom::multi::{many0, many1};
use nom::sequence::delimited;
use nom::IResult;
use std::borrow::Cow;
use std::iter::FusedIterator;
use std::{borrow::Cow, error::Error};
use std::{convert::TryFrom, fmt::Display};
/// Syntactic events that occurs in the config. Despite all these variants
@ -74,23 +74,15 @@ impl Display for Event<'_> {
/// as read. Consider [`Event::as_bytes`] for one-to-one reading.
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Value(e) | Self::ValueNotDone(e) | Self::ValueDone(e) => {
match std::str::from_utf8(e) {
Ok(e) => e.fmt(f),
Err(_) => write!(f, "{:02x?}", e),
}
}
Self::Comment(e) => e.fmt(f),
Self::SectionHeader(e) => e.fmt(f),
Self::Key(e) => e.fmt(f),
Self::Value(e) => match std::str::from_utf8(e) {
Ok(e) => e.fmt(f),
Err(_) => write!(f, "{:02x?}", e),
},
Self::Newline(e) => e.fmt(f),
Self::ValueNotDone(e) => match std::str::from_utf8(e) {
Ok(e) => e.fmt(f),
Err(_) => write!(f, "{:02x?}", e),
},
Self::ValueDone(e) => match std::str::from_utf8(e) {
Ok(e) => e.fmt(f),
Err(_) => write!(f, "{:02x?}", e),
},
Self::Whitespace(e) => e.fmt(f),
Self::Key(e) | Self::Newline(e) | Self::Whitespace(e) => e.fmt(f),
Self::KeyValueSeparator => write!(f, "="),
}
}
@ -186,26 +178,26 @@ impl Display for ParsedComment<'_> {
/// occurred, as well as the last parser node and the remaining data to be
/// parsed.
#[derive(PartialEq, Debug)]
pub struct ParserError<'a> {
pub struct Error<'a> {
line_number: usize,
last_attempted_parser: ParserNode,
parsed_until: &'a [u8],
}
impl ParserError<'_> {
impl Error<'_> {
/// The one-indexed line number where the error occurred. This is determined
/// by the number of newlines that were successfully parsed.
pub fn line_number(&self) -> usize {
pub const fn line_number(&self) -> usize {
self.line_number + 1
}
/// The remaining data that was left unparsed.
pub fn remaining_data(&self) -> &[u8] {
pub const fn remaining_data(&self) -> &[u8] {
self.parsed_until
}
}
impl Display for ParserError<'_> {
impl Display for Error<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let data_size = self.parsed_until.len();
let data = std::str::from_utf8(self.parsed_until);
@ -235,7 +227,7 @@ impl Display for ParserError<'_> {
}
}
impl Error for ParserError<'_> {}
impl std::error::Error for Error<'_> {}
/// A list of parsers that parsing can fail on. This is used for pretty-printing
/// errors
@ -510,24 +502,21 @@ impl<'a> Parser<'a> {
/// Consumes the parser to produce an iterator of Events.
#[must_use = "iterators are lazy and do nothing unless consumed"]
#[allow(clippy::should_implement_trait)]
pub fn into_iter(self) -> impl Iterator<Item = Event<'a>> + FusedIterator {
// Can't impl IntoIter without allocating.and using a generic associated type
// TODO: try harder?
let section_iter = self
.sections
.into_iter()
.map(|section| {
vec![Event::SectionHeader(section.section_header)]
.into_iter()
.chain(section.events)
})
.flatten();
let section_iter = self.sections.into_iter().flat_map(|section| {
vec![Event::SectionHeader(section.section_header)]
.into_iter()
.chain(section.events)
});
self.frontmatter.into_iter().chain(section_iter)
}
}
impl<'a> TryFrom<&'a str> for Parser<'a> {
type Error = ParserError<'a>;
type Error = Error<'a>;
fn try_from(value: &'a str) -> Result<Self, Self::Error> {
parse_from_str(value)
@ -535,7 +524,7 @@ impl<'a> TryFrom<&'a str> for Parser<'a> {
}
impl<'a> TryFrom<&'a [u8]> for Parser<'a> {
type Error = ParserError<'a>;
type Error = Error<'a>;
fn try_from(value: &'a [u8]) -> Result<Self, Self::Error> {
parse_from_bytes(value)
@ -552,7 +541,7 @@ impl<'a> TryFrom<&'a [u8]> for Parser<'a> {
/// Returns an error if the string provided is not a valid `git-config`.
/// This generally is due to either invalid names or if there's extraneous
/// data succeeding valid `git-config` data.
pub fn parse_from_str(input: &str) -> Result<Parser<'_>, ParserError> {
pub fn parse_from_str(input: &str) -> Result<Parser<'_>, Error> {
parse_from_bytes(input.as_bytes())
}
@ -566,7 +555,7 @@ pub fn parse_from_str(input: &str) -> Result<Parser<'_>, ParserError> {
/// Returns an error if the string provided is not a valid `git-config`.
/// This generally is due to either invalid names or if there's extraneous
/// data succeeding valid `git-config` data.
pub fn parse_from_bytes(input: &[u8]) -> Result<Parser<'_>, ParserError> {
pub fn parse_from_bytes(input: &[u8]) -> Result<Parser<'_>, Error> {
let mut newlines = 0;
let (i, frontmatter) = many0(alt((
map(comment, Event::Comment),
@ -595,7 +584,7 @@ pub fn parse_from_bytes(input: &[u8]) -> Result<Parser<'_>, ParserError> {
let mut node = ParserNode::SectionHeader;
let maybe_sections = many1(|i| section(i, &mut node))(i);
let (i, sections) = maybe_sections.map_err(|_| ParserError {
let (i, sections) = maybe_sections.map_err(|_| Error {
line_number: newlines,
last_attempted_parser: node,
parsed_until: i,
@ -612,7 +601,7 @@ pub fn parse_from_bytes(input: &[u8]) -> Result<Parser<'_>, ParserError> {
// This needs to happen after we collect sections, otherwise the line number
// will be off.
if !i.is_empty() {
return Err(ParserError {
return Err(Error {
line_number: newlines,
last_attempted_parser: node,
parsed_until: i,
@ -714,7 +703,7 @@ fn section_header(i: &[u8]) -> IResult<&[u8], ParsedSectionHeader> {
let header = match find_legacy_subsection_separator(name) {
Some(index) => ParsedSectionHeader {
name: Cow::Borrowed(&name[..index]),
separator: name.get(index..index + 1).map(|slice| Cow::Borrowed(slice)),
separator: name.get(index..=index).map(|slice| Cow::Borrowed(slice)),
subsection_name: name.get(index + 1..).map(|slice| Cow::Borrowed(slice)),
},
None => ParsedSectionHeader {
@ -859,7 +848,7 @@ fn value_impl<'a, 'b>(i: &'a [u8], events: &'b mut Vec<Event<'a>>) -> IResult<&'
partial_value_found = true;
events.push(Event::ValueNotDone(Cow::Borrowed(&i[offset..index - 1])));
events.push(Event::Newline(Cow::Borrowed(
std::str::from_utf8(&i[index..index + 1]).unwrap(),
std::str::from_utf8(&i[index..=index]).unwrap(),
)));
offset = index + 1;
parsed_index = 0;

6
src/values.rs
View File

@ -391,7 +391,7 @@ pub enum IntegerSuffix {
impl IntegerSuffix {
/// Returns the number of bits that the suffix shifts left by.
pub fn bitwise_offset(&self) -> usize {
pub const fn bitwise_offset(self) -> usize {
match self {
Self::Kibi => 10,
Self::Mebi => 20,
@ -461,12 +461,12 @@ pub struct Color {
impl Color {
/// Returns the foreground color, if any.
pub fn foreground(&self) -> Option<ColorValue> {
pub const fn foreground(&self) -> Option<ColorValue> {
self.foreground
}
/// Returns the background color, if any.
pub fn background(&self) -> Option<ColorValue> {
pub const fn background(&self) -> Option<ColorValue> {
self.background
}