Lints to ensure link text for EIPs should match the EIP's number

eipw-lint/src/lib.rs

@@ -419,12 +419,24 @@ pub fn default_lints_enum() -> impl Iterator<Item = (&'static str, DefaultLint<&
                 message: "proposals must be referenced with the form `EIP-N` (not `EIPN` or `EIP N`)",
             }),
         ),
+        (
+            "markdown-link-eip",
+            MarkdownLinkEip {
+                pattern: markdown::LinkEip(r"eip-([^.]*)\.md(#.+)?$")
+            }
+        ),
         (
             "markdown-link-first",
             MarkdownLinkFirst {
                 pattern: markdown::LinkFirst(r"(?i)(?:eip|erc)-[0-9]+"),
             }
         ),
+        (
+            "markdown-link-other",
+            MarkdownLinkOther {
+                pattern: markdown::LinkOther(r"^(EIP|ERC)-(\d+)\s*\S*$")
+            }
+        ),
         ("markdown-rel-links", MarkdownRelativeLinks(markdown::RelativeLinks {
             exceptions: vec![
                 "^https://(www\\.)?github\\.com/ethereum/consensus-specs/blob/[a-f0-9]{40}/.+$",

eipw-lint/src/lints/known_lints.rs

@@ -53,9 +53,15 @@ pub enum DefaultLint<S> {
 
     MarkdownHtmlComments(markdown::HtmlComments<S>),
     MarkdownJsonSchema(markdown::JsonSchema<S>),
+    MarkdownLinkEip {
+        pattern: markdown::LinkEip<S>
+    },
     MarkdownLinkFirst {
         pattern: markdown::LinkFirst<S>,
     },
+    MarkdownLinkOther {
+        pattern: markdown::LinkOther<S>
+    },
     MarkdownLinkStatus(markdown::LinkStatus<S>),
     MarkdownProposalRef(markdown::ProposalRef<S>),
     MarkdownRegex(markdown::Regex<S>),
@@ -102,6 +108,8 @@ where
 
             Self::MarkdownHtmlComments(l) => Box::new(l),
             Self::MarkdownJsonSchema(l) => Box::new(l),
+            Self::MarkdownLinkEip { pattern } => Box::new(pattern),
+            Self::MarkdownLinkOther { pattern } => Box::new(pattern),
             Self::MarkdownLinkFirst { pattern } => Box::new(pattern),
             Self::MarkdownLinkStatus(l) => Box::new(l),
             Self::MarkdownProposalRef(l) => Box::new(l),
@@ -141,7 +149,9 @@ where
 
             Self::MarkdownHtmlComments(l) => l,
             Self::MarkdownJsonSchema(l) => l,
+            Self::MarkdownLinkEip { pattern } => pattern,
             Self::MarkdownLinkFirst { pattern } => pattern,
+            Self::MarkdownLinkOther { pattern } => pattern,
             Self::MarkdownLinkStatus(l) => l,
             Self::MarkdownProposalRef(l) => l,
             Self::MarkdownRegex(l) => l,
@@ -257,6 +267,12 @@ where
                     .map(|(a, b)| (a.as_ref(), b.as_ref()))
                     .collect(),
             }),
+            Self::MarkdownLinkEip { pattern } => DefaultLint::MarkdownLinkEip {
+                pattern: markdown::LinkEip(pattern.0.as_ref()),
+            },
+            Self::MarkdownLinkOther { pattern } => DefaultLint::MarkdownLinkOther {
+                pattern: markdown::LinkOther(pattern.0.as_ref()),
+            },
             Self::MarkdownLinkFirst { pattern } => DefaultLint::MarkdownLinkFirst {
                 pattern: markdown::LinkFirst(pattern.0.as_ref()),
             },
@@ -275,7 +291,7 @@ where
                     prefix: l.prefix.as_ref(),
                     suffix: l.suffix.as_ref(),
                 })
-            }
+            },
             Self::MarkdownRegex(l) => DefaultLint::MarkdownRegex(markdown::Regex {
                 message: l.message.as_ref(),
                 mode: l.mode,

eipw-lint/src/lints/markdown.rs

@@ -7,7 +7,9 @@
 pub mod headings_space;
 pub mod html_comments;
 pub mod json_schema;
+pub mod link_eip;
 pub mod link_first;
+pub mod link_other;
 pub mod link_status;
 pub mod proposal_ref;
 pub mod regex;
@@ -18,7 +20,9 @@ pub mod section_required;
 pub use self::headings_space::HeadingsSpace;
 pub use self::html_comments::HtmlComments;
 pub use self::json_schema::JsonSchema;
+pub use self::link_eip::LinkEip;
 pub use self::link_first::LinkFirst;
+pub use self::link_other::LinkOther;
 pub use self::link_status::LinkStatus;
 pub use self::proposal_ref::ProposalRef;
 pub use self::regex::Regex;

eipw-lint/src/lints/markdown/link_eip.rs

@@ -0,0 +1,141 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+use annotate_snippets::snippet::{Annotation, AnnotationType, Slice, Snippet};
+
+use comrak::nodes::{Ast, NodeLink};
+
+use crate::lints::{Context, Error, Lint};
+use crate::tree::{self, Next, TraverseExt};
+
+use regex::Regex;
+
+use serde::{Deserialize, Serialize};
+
+use std::fmt::{Debug, Display};
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct LinkEip<S>(pub S);
+
+impl<S> Lint for LinkEip<S>
+where
+    S: Display + Debug + AsRef<str>,
+{
+    fn lint<'a>(&self, slug: &'a str, ctx: &Context<'a, '_>) -> Result<(), Error> {
+        let pattern = self.0.as_ref();
+        let re = Regex::new(pattern).map_err(Error::custom)?;
+
+        let mut visitor = Visitor {
+            ctx,
+            re,
+            slug,
+            link_depth: 0,
+            current_link: Link { url: String::new(), text: String::new() },
+        };
+        ctx.body().traverse().visit(&mut visitor)?;
+
+        Ok(())
+    }
+}
+#[derive(Debug)]
+struct Link {
+    url: String,
+    text: String,
+}
+
+#[derive(Debug)]
+struct Visitor<'a, 'b, 'c> {
+    ctx: &'c Context<'a, 'b>,
+    re: Regex,
+    slug: &'c str,
+    link_depth: usize,
+    current_link: Link,
+}
+
+impl<'a, 'b, 'c> Visitor<'a, 'b, 'c> {
+    fn check(&self, ast: &Ast) -> Result<Next, Error> {  
+        let pattern = r"(?i)\b(?:eip|erc)-(\d+)\b";
+        let url_re = Regex::new(pattern).map_err(Error::custom)?;
+
+        let url_eip_number = if let Some(captures) = url_re.captures(&self.current_link.url) {
+            captures.get(1).map(|m| m.as_str())
+        } else { None };
+
+        if let Some(url_eip_number) = url_eip_number {
+            let section_pattern = r"eip-([^.]*)\.md#.+$";
+            let url_re = Regex::new(section_pattern).map_err(Error::custom)?;
+            let dynamic_pattern = if url_re.is_match(&self.current_link.url) {
+                format!(r"^(EIP|ERC)-{}\s*\S+", regex::escape(&url_eip_number))
+            } else {
+                format!(r"^(EIP|ERC)-{}$", regex::escape(&url_eip_number))
+            };
+            let text_re = Regex::new(&dynamic_pattern).map_err(Error::custom)?;
+
+            if text_re.is_match(&self.current_link.text) {
+                return Ok(Next::TraverseChildren);
+            };
+
+            let expected = if url_re.is_match(&self.current_link.url) {
+                format!("[EIP|ERC-{}<section-description>]", url_eip_number)
+            } else {
+                format!("[EIP|ERC-{}]", url_eip_number)
+            };
+
+            let footer_label = format!("link text should match `{}`", expected);
+
+            let source = self.ctx.source_for_text(ast.sourcepos.start.line, &self.current_link.text);
+            self.ctx.report(Snippet {
+                title: Some(Annotation {
+                    annotation_type: self.ctx.annotation_type(),
+                    id: Some(self.slug),
+                    label: Some("link text does not match link destination"),
+                }),
+                slices: vec![Slice {
+                    fold: false,
+                    line_start: ast.sourcepos.start.line,
+                    origin: self.ctx.origin(),
+                    source: &source,
+                    annotations: vec![],
+                }],
+                footer: vec![Annotation {
+                    id: None,
+                    annotation_type: AnnotationType::Info,
+                    label: Some(&footer_label),
+                }],
+                opt: Default::default(),
+            })?;
+        }
+
+        Ok(Next::TraverseChildren)
+    }
+}
+
+impl<'a, 'b, 'c> tree::Visitor for Visitor<'a, 'b, 'c> {
+    type Error = Error;
+
+    fn enter_link(&mut self, _: &Ast, link: &NodeLink,) -> Result<Next, Self::Error> {
+        if self.re.is_match(&link.url) {        
+            self.current_link = Link { url: link.url.to_owned(), text: String::new() }; 
+            self.link_depth += 1;  
+        }                          
+        Ok(Next::TraverseChildren)
+    }
+
+    fn depart_link(&mut self, _: &Ast, _: &NodeLink) -> Result<(), Self::Error> {
+        if self.link_depth > 0 {
+            self.link_depth = self.link_depth.checked_sub(1).unwrap();
+        }
+        Ok(())
+    }
+
+    fn enter_text(&mut self, ast: &Ast, txt: &str) -> Result<Next, Self::Error> {
+        if self.link_depth > 0 {
+            self.current_link.text = txt.to_owned();
+            self.check(ast)?;         
+        }
+        Ok(Next::TraverseChildren)    
+    }
+}

eipw-lint/src/lints/markdown/link_other.rs

@@ -0,0 +1,124 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+use annotate_snippets::snippet::{Annotation, AnnotationType, Slice, Snippet};
+
+use comrak::nodes::{Ast, NodeLink};
+
+use crate::lints::{Context, Error, Lint};
+use crate::tree::{self, Next, TraverseExt};
+
+use regex::Regex;
+
+use serde::{Deserialize, Serialize};
+
+use std::fmt::{Debug, Display};
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct LinkOther<S>(pub S);
+
+impl<S> Lint for LinkOther<S>
+where
+    S: Display + Debug + AsRef<str>,
+{
+    fn lint<'a>(&self, slug: &'a str, ctx: &Context<'a, '_>) -> Result<(), Error> {
+        let pattern = self.0.as_ref();
+        let re = Regex::new(pattern).map_err(Error::custom)?;
+
+        let mut visitor = Visitor {
+            ctx,
+            re,
+            slug,
+            link_depth: 0,
+            current_link: Link { url: String::new(), text: String::new() },
+        };
+        ctx.body().traverse().visit(&mut visitor)?;
+
+        Ok(())
+    }
+}
+#[derive(Debug)]
+struct Link {
+    url: String,
+    text: String,
+}
+
+#[derive(Debug)]
+struct Visitor<'a, 'b, 'c> {
+    ctx: &'c Context<'a, 'b>,
+    re: Regex,
+    slug: &'c str,
+    link_depth: usize,
+    current_link: Link,
+}
+
+impl<'a, 'b, 'c> Visitor<'a, 'b, 'c> {
+    fn check(&self, ast: &Ast) -> Result<Next, Error> {  
+        let text_eip_number = if let Some(captures) = self.re.captures(&self.current_link.text) {
+            captures.get(2).map(|m| m.as_str())
+        } else { None };
+
+        if let Some(text_eip_number) = text_eip_number {
+            let pattern = format!(r"(?i)\beip-{}\b", regex::escape(&text_eip_number));
+            let re = Regex::new(&pattern).map_err(Error::custom)?;
+
+            if re.is_match(&self.current_link.url) {
+                return Ok(Next::TraverseChildren);
+            }
+
+            let footer_label = format!("link destinstion must match text EIP");
+
+            let source = self.ctx.source_for_text(ast.sourcepos.start.line, &self.current_link.text);
+            self.ctx.report(Snippet {
+                title: Some(Annotation {
+                    annotation_type: self.ctx.annotation_type(),
+                    id: Some(self.slug),
+                    label: Some("link text does not match link destination"),
+                }),
+                slices: vec![Slice {
+                    fold: false,
+                    line_start: ast.sourcepos.start.line,
+                    origin: self.ctx.origin(),
+                    source: &source,
+                    annotations: vec![],
+                }],
+                footer: vec![Annotation {
+                    id: None,
+                    annotation_type: AnnotationType::Info,
+                    label: Some(&footer_label),
+                }],
+                opt: Default::default(),
+            })?;
+        }
+
+        Ok(Next::TraverseChildren)
+    }
+}
+
+impl<'a, 'b, 'c> tree::Visitor for Visitor<'a, 'b, 'c> {
+    type Error = Error;
+
+    fn enter_link(&mut self, _: &Ast, link: &NodeLink,) -> Result<Next, Self::Error> {
+        self.current_link = Link { url: link.url.to_owned(), text: String::new() };  
+        self.link_depth += 1;                         
+        Ok(Next::TraverseChildren)
+    }
+
+    fn depart_link(&mut self, _: &Ast, _: &NodeLink) -> Result<(), Self::Error> {
+        if self.link_depth > 0 {
+            self.link_depth = self.link_depth.checked_sub(1).unwrap();
+        }
+        Ok(())
+    }
+
+    fn enter_text(&mut self, ast: &Ast, txt: &str) -> Result<Next, Self::Error> {
+        if self.link_depth > 0 && self.re.is_match(&txt) {
+            self.current_link.text = txt.to_owned();
+            self.check(ast)?;         
+        }
+        Ok(Next::TraverseChildren)    
+    }
+}