Struct DeclarativeProfile 

pub struct DeclarativeProfile {
    pub name: String,
    pub extensions: Vec<String>,
    pub line_comments: Vec<LineDelimiter>,
    pub block_comments: Vec<BlockDelimiter>,
    pub strings: Vec<StringDelimiter>,
    pub protected_patterns: Vec<ProtectedPattern>,
}

A deliberately limited scanner profile for unambiguous comment syntaxes.

A profile describes a syntax whose comments and strings are literal delimiters and nothing more, so that one byte-oriented pass can find them with no grammar and no backtracking. That is the whole of what it can express, and the limits are enforced rather than assumed:

• Every delimiter is a literal token. It must not be empty and must not contain a line terminator.
• No comment delimiter may be a prefix of another comment delimiter, no string delimiter of another string delimiter, and no comment delimiter of a string delimiter or the reverse. One position therefore never has two readings, which is what makes the single pass correct.
• A nested block needs a start and an end that are distinct and neither contained in the other, so the depth count cannot be fooled.
• A comment’s CommentKind is whatever the delimiter declares. There is no classification by content the way a built-in scanner does it: a profile finds no shebang, no encoding line, and no license notice unless a ProtectedPattern says so.

A syntax that needs more than this — a regex literal, a heredoc, an indentation rule — needs a scanner plugin instead.

Examples

use ocomment_core::{
    CommentKind, DeclarativeProfile, LineDelimiter, StringDelimiter, TransformOptions,
    transform_profile,
};

let profile = DeclarativeProfile {
    name: "lisp".into(),
    extensions: vec!["lisp".into()],
    line_comments: vec![LineDelimiter {
        start: ";;".into(),
        requires_boundary: false,
        kind: CommentKind::Line,
    }],
    strings: vec![StringDelimiter {
        start: "\"".into(),
        end: "\"".into(),
        escape: Some("\\".into()),
        multiline: false,
    }],
    ..Default::default()
};

let source = b"(print \";; not a comment\") ;; a comment\n";
let result = transform_profile(source, &profile, TransformOptions::default()).unwrap();
assert_eq!(result.output, b"(print \";; not a comment\") \n");

Fields

name: String

What to call the profile in a diagnostic. It must not be blank.

extensions: Vec<String>

The file extensions this profile claims, with or without the leading dot and matched case-insensitively. The scanner never reads this; it is for whoever picks a profile for a path.

line_comments: Vec<LineDelimiter>

Tokens that open a comment running to the end of the line.

block_comments: Vec<BlockDelimiter>

Tokens that open a comment running to a closing token.

strings: Vec<StringDelimiter>

String forms to skip, so a comment token inside one is only text.

protected_patterns: Vec<ProtectedPattern>

Substrings that turn a comment into a kept directive.

Trait Implementations

impl Clone for DeclarativeProfile

fn clone(&self) -> DeclarativeProfile

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DeclarativeProfile

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for DeclarativeProfile

fn default() -> DeclarativeProfile

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for DeclarativeProfile

where DeclarativeProfile: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for DeclarativeProfile

impl PartialEq for DeclarativeProfile

fn eq(&self, other: &DeclarativeProfile) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for DeclarativeProfile

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for DeclarativeProfile