From 3ac087ae415eab3d4f36e8afed3f0f3fa5a9137a Mon Sep 17 00:00:00 2001 From: Niklas Mohrin Date: Wed, 8 Sep 2021 15:02:25 +0200 Subject: [PATCH] Final touches for formatting refactor - Rename: `yield_snippet` => `process_snippet` - Rename: `HighlightingSnippet` => `PageSnippet` --- src/formatter.rs | 48 ++++++++++++++++++++++++------------------------ src/output.rs | 10 +++++----- 2 files changed, 29 insertions(+), 29 deletions(-) diff --git a/src/formatter.rs b/src/formatter.rs index af33ae9..d1cfde4 100644 --- a/src/formatter.rs +++ b/src/formatter.rs @@ -6,8 +6,8 @@ use crate::types::LineType; use log::debug; #[derive(Debug, Clone, Copy, PartialEq, Eq)] -/// Represents a snippet from a page from a specific highlighting class. -pub enum HighlightingSnippet<'a> { +/// Represents a snippet from a page of a specific highlighting class. +pub enum PageSnippet<'a> { CommandName(&'a str), Variable(&'a str), NormalCode(&'a str), @@ -16,9 +16,9 @@ pub enum HighlightingSnippet<'a> { Linebreak, } -impl<'a> HighlightingSnippet<'a> { +impl<'a> PageSnippet<'a> { pub fn is_empty(&self) -> bool { - use HighlightingSnippet::*; + use PageSnippet::*; match self { CommandName(s) | Variable(s) | NormalCode(s) | Description(s) | Text(s) => s.is_empty(), @@ -30,19 +30,19 @@ impl<'a> HighlightingSnippet<'a> { /// Parse the content of each line yielded by `lines` and yield `HighLightingSnippet`s accordingly. pub fn highlight_lines( lines: L, - yield_snippet: &mut F, + process_snippet: &mut F, keep_empty_lines: bool, ) -> Result<(), E> where L: Iterator, - F: for<'snip> FnMut(HighlightingSnippet<'snip>) -> Result<(), E>, + F: for<'snip> FnMut(PageSnippet<'snip>) -> Result<(), E>, { let mut command = String::new(); for line in lines { match line { LineType::Empty => { if keep_empty_lines { - yield_snippet(HighlightingSnippet::Linebreak)?; + process_snippet(PageSnippet::Linebreak)?; } } LineType::Title(title) => { @@ -53,18 +53,18 @@ where command = title; debug!("Detected command name: {}", &command); } - LineType::Description(text) => yield_snippet(HighlightingSnippet::Description(&text))?, - LineType::ExampleText(text) => yield_snippet(HighlightingSnippet::Text(&text))?, + LineType::Description(text) => process_snippet(PageSnippet::Description(&text))?, + LineType::ExampleText(text) => process_snippet(PageSnippet::Text(&text))?, LineType::ExampleCode(text) => { - yield_snippet(HighlightingSnippet::NormalCode(" "))?; - highlight_code(&command, &text, yield_snippet)?; - yield_snippet(HighlightingSnippet::Linebreak)?; + process_snippet(PageSnippet::NormalCode(" "))?; + highlight_code(&command, &text, process_snippet)?; + process_snippet(PageSnippet::Linebreak)?; } LineType::Other(text) => debug!("Unknown line type: {:?}", text), } } - yield_snippet(HighlightingSnippet::Linebreak)?; + process_snippet(PageSnippet::Linebreak)?; Ok(()) } @@ -72,14 +72,14 @@ where fn highlight_code<'a, E>( command: &'a str, text: &'a str, - yield_snippet: &mut impl FnMut(HighlightingSnippet<'a>) -> Result<(), E>, + process_snippet: &mut impl FnMut(PageSnippet<'a>) -> Result<(), E>, ) -> Result<(), E> { let variable_splits = text .split("}}") .map(|s| s.split_once("{{").unwrap_or((s, ""))); for (code_segment, variable) in variable_splits { - highlight_code_segment(command, code_segment, yield_snippet)?; - yield_snippet(HighlightingSnippet::Variable(variable))?; + highlight_code_segment(command, code_segment, process_snippet)?; + process_snippet(PageSnippet::Variable(variable))?; } Ok(()) } @@ -90,15 +90,15 @@ fn highlight_code<'a, E>( fn highlight_code_segment<'a, E>( command_name: &'a str, mut segment: &'a str, - yield_snippet: &mut impl FnMut(HighlightingSnippet<'a>) -> Result<(), E>, + process_snippet: &mut impl FnMut(PageSnippet<'a>) -> Result<(), E>, ) -> Result<(), E> { if !command_name.is_empty() { let mut search_start = 0; while let Some(match_start) = segment.find_from(command_name, search_start) { let match_end = match_start + command_name.len(); if is_freestanding_substring(segment, (match_start, match_end)) { - yield_snippet(HighlightingSnippet::NormalCode(&segment[..match_start]))?; - yield_snippet(HighlightingSnippet::CommandName(command_name))?; + process_snippet(PageSnippet::NormalCode(&segment[..match_start]))?; + process_snippet(PageSnippet::CommandName(command_name))?; segment = &segment[match_end..]; search_start = 0; } else { @@ -109,7 +109,7 @@ fn highlight_code_segment<'a, E>( } } } - yield_snippet(HighlightingSnippet::NormalCode(segment))?; + process_snippet(PageSnippet::NormalCode(segment))?; Ok(()) } @@ -133,7 +133,7 @@ fn is_freestanding_substring(surrouding: &str, substring: (usize, usize)) -> boo #[cfg(test)] mod tests { use super::*; - use HighlightingSnippet::*; + use PageSnippet::*; #[test] fn test_is_freestanding_substring() { @@ -160,16 +160,16 @@ mod tests { )); } - fn run<'a>(cmd: &'a str, segment: &'a str) -> Vec> { + fn run<'a>(cmd: &'a str, segment: &'a str) -> Vec> { let mut yielded = Vec::new(); - let mut yield_snippet = |snip: HighlightingSnippet<'a>| { + let mut process_snippet = |snip: PageSnippet<'a>| { if !snip.is_empty() { yielded.push(snip); } Ok::<(), ()>(()) }; - highlight_code_segment(cmd, segment, &mut yield_snippet) + highlight_code_segment(cmd, segment, &mut process_snippet) .expect("highlight code segment failed"); yielded } diff --git a/src/output.rs b/src/output.rs index cc3c7a0..25b9bc3 100644 --- a/src/output.rs +++ b/src/output.rs @@ -6,7 +6,7 @@ use std::io::{self, BufRead, BufReader, Write}; use crate::cache::PageLookupResult; use crate::config::{Config, StyleConfig}; use crate::error::TealdeerError::WriteError; -use crate::formatter::{highlight_lines, HighlightingSnippet}; +use crate::formatter::{highlight_lines, PageSnippet}; use crate::line_iterator::LineIterator; /// Print page by path @@ -29,7 +29,7 @@ pub fn print_page( .map_err(|_| "Could not write to stdout".to_string())?; } } else { - let mut yield_snippet = |snip: HighlightingSnippet<'_>| { + let mut process_snippet = |snip: PageSnippet<'_>| { if snip.is_empty() { Ok(()) } else { @@ -39,7 +39,7 @@ pub fn print_page( }; highlight_lines( LineIterator::new(reader), - &mut yield_snippet, + &mut process_snippet, !config.display.compact, ) .map_err(|e| format!("Could not write to stdout: {}", e.message()))?; @@ -55,10 +55,10 @@ pub fn print_page( fn print_snippet( writer: &mut impl Write, - snip: HighlightingSnippet<'_>, + snip: PageSnippet<'_>, style: &StyleConfig, ) -> Result<(), io::Error> { - use HighlightingSnippet::*; + use PageSnippet::*; match snip { CommandName(s) => write!(writer, "{}", style.command_name.paint(s)),