feat(markdown): improve markdown parser and diagnostics

crates/biome_cli/src/commands/lint.rs

@@ -7,6 +7,7 @@ use biome_configuration::css::CssLinterConfiguration;
 use biome_configuration::graphql::GraphqlLinterConfiguration;
 use biome_configuration::javascript::JsLinterConfiguration;
 use biome_configuration::json::JsonLinterConfiguration;
+use biome_configuration::markdown::MarkdownLinterConfiguration;
 use biome_configuration::vcs::VcsConfiguration;
 use biome_configuration::{Configuration, FilesConfiguration, LinterConfiguration};
 use biome_console::Console;
@@ -37,6 +38,7 @@ pub(crate) struct LintCommandPayload {
     pub(crate) json_linter: Option<JsonLinterConfiguration>,
     pub(crate) css_linter: Option<CssLinterConfiguration>,
     pub(crate) graphql_linter: Option<GraphqlLinterConfiguration>,
+    pub(crate) markdown_linter: Option<MarkdownLinterConfiguration>,
 }
 
 impl CommandRunner for LintCommandPayload {
@@ -83,12 +85,21 @@ impl CommandRunner for LintCommandPayload {
                 .get_or_insert_with(Default::default);
             graphql.linter.merge_with(self.graphql_linter.clone());
         }
+
+        if self.markdown_linter.is_some() {
+            let markdown = fs_configuration
+                .markdown
+                .get_or_insert_with(Default::default);
+            markdown.linter.merge_with(self.markdown_linter.clone());
+        }
+
         if self.javascript_linter.is_some() {
             let javascript = fs_configuration
                 .javascript
                 .get_or_insert_with(Default::default);
             javascript.linter.merge_with(self.javascript_linter.clone());
         }
+
         if self.json_linter.is_some() {
             let json = fs_configuration.json.get_or_insert_with(Default::default);
             json.linter.merge_with(self.json_linter.clone());

crates/biome_cli/src/commands/mod.rs

@@ -12,6 +12,7 @@ use biome_configuration::formatter::FormatterEnabled;
 use biome_configuration::graphql::{GraphqlFormatterConfiguration, GraphqlLinterConfiguration};
 use biome_configuration::javascript::{JsFormatterConfiguration, JsLinterConfiguration};
 use biome_configuration::json::{JsonFormatterConfiguration, JsonLinterConfiguration};
+use biome_configuration::markdown::MarkdownLinterConfiguration;
 use biome_configuration::vcs::VcsConfiguration;
 use biome_configuration::{BiomeDiagnostic, Configuration};
 use biome_configuration::{
@@ -20,7 +21,8 @@ use biome_configuration::{
     formatter_configuration, graphql::graphql_formatter_configuration,
     graphql::graphql_linter_configuration, javascript::js_formatter_configuration,
     javascript::js_linter_configuration, json::json_formatter_configuration,
-    json::json_linter_configuration, linter_configuration, vcs::vcs_configuration,
+    json::json_linter_configuration, linter_configuration, markdown::markdown_linter_configuration,
+    vcs::vcs_configuration,
 };
 use biome_console::{Console, ConsoleExt, markup};
 use biome_diagnostics::{Diagnostic, PrintDiagnostic, Severity};
@@ -208,6 +210,9 @@ pub enum BiomeCommand {
         #[bpaf(external(graphql_linter_configuration), optional, hide_usage, hide)]
         graphql_linter: Option<GraphqlLinterConfiguration>,
 
+        #[bpaf(external(markdown_linter_configuration), optional, hide_usage, hide)]
+        markdown_linter: Option<MarkdownLinterConfiguration>,
+
         #[bpaf(external, hide_usage)]
         cli_options: CliOptions,
 

crates/biome_cli/src/lib.rs

@@ -123,6 +123,7 @@ impl<'app> CliSession<'app> {
                 javascript_linter,
                 json_linter,
                 graphql_linter,
+                markdown_linter,
             } => run_command(
                 self,
                 &cli_options,
@@ -146,6 +147,7 @@ impl<'app> CliSession<'app> {
                     javascript_linter,
                     json_linter,
                     graphql_linter,
+                    markdown_linter,
                 },
             ),
             BiomeCommand::Ci {

crates/biome_configuration/src/lib.rs

@@ -14,6 +14,7 @@ pub mod grit;
 pub mod html;
 pub mod javascript;
 pub mod json;
+pub mod markdown;
 pub mod max_size;
 mod overrides;
 pub mod plugins;
@@ -30,6 +31,7 @@ use crate::graphql::{GraphqlFormatterConfiguration, GraphqlLinterConfiguration};
 pub use crate::grit::{GritConfiguration, grit_configuration};
 use crate::javascript::{JsFormatterConfiguration, JsLinterConfiguration};
 use crate::json::{JsonFormatterConfiguration, JsonLinterConfiguration};
+use crate::markdown::{MarkdownConfiguration, markdown_configuration};
 use crate::max_size::MaxSize;
 use crate::vcs::{VcsConfiguration, vcs_configuration};
 pub use analyzer::{
@@ -151,6 +153,11 @@ pub struct Configuration {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub html: Option<HtmlConfiguration>,
 
+    /// Specific configuration for the Markdown language
+    #[bpaf(external(markdown_configuration), optional)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub markdown: Option<MarkdownConfiguration>,
+
     /// A list of granular patterns that should be applied only to a sub set of files
     #[bpaf(hide, pure(Default::default()))]
     #[serde(skip_serializing_if = "Option::is_none")]

crates/biome_configuration/src/markdown.rs

@@ -0,0 +1,108 @@
+use crate::bool::Bool;
+use biome_deserialize_macros::{Deserializable, Merge};
+use biome_formatter::{
+    BracketSpacing, IndentStyle, IndentWidth, LineEnding, LineWidth, QuoteStyle,
+};
+use bpaf::Bpaf;
+use serde::{Deserialize, Serialize};
+
+/// Configuration for the Markdown language
+#[derive(
+    Bpaf, Clone, Deserializable, Debug, Default, Deserialize, Eq, PartialEq, Merge, Serialize,
+)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[serde(rename_all = "camelCase", default, deny_unknown_fields)]
+pub struct MarkdownConfiguration {
+    /// Configuration for the Markdown formatter
+    #[bpaf(external(markdown_formatter_configuration), optional)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub formatter: Option<MarkdownFormatterConfiguration>,
+
+    /// Configuration for the Markdown linter
+    #[bpaf(external(markdown_linter_configuration), optional)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub linter: Option<MarkdownLinterConfiguration>,
+
+    /// Configuration for the Markdown parser
+    #[bpaf(external(markdown_parser_configuration), optional)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub parser: Option<MarkdownParserConfiguration>,
+}
+
+pub type MarkdownFormatterEnabled = Bool<true>;
+
+/// Configuration for the Markdown formatter
+#[derive(
+    Bpaf, Clone, Deserializable, Debug, Default, Deserialize, Eq, PartialEq, Merge, Serialize,
+)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[serde(rename_all = "camelCase", default, deny_unknown_fields)]
+pub struct MarkdownFormatterConfiguration {
+    /// Markdown formatter options
+    #[bpaf(long("markdown-formatter-enabled"), argument("true|false"))]
+    pub enabled: Option<MarkdownFormatterEnabled>,
+
+    /// The indent style applied to Markdown files.
+    #[bpaf(long("markdown-formatter-indent-style"), argument("tab|space"))]
+    pub indent_style: Option<IndentStyle>,
+
+    /// The size of the indentation applied to Markdown files. Default to 2.
+    #[bpaf(long("markdown-formatter-indent-width"), argument("NUMBER"))]
+    pub indent_width: Option<IndentWidth>,
+
+    /// The type of line ending applied to Markdown files.
+    #[bpaf(long("markdown-formatter-line-ending"), argument("lf|crlf|cr"))]
+    pub line_ending: Option<LineEnding>,
+
+    /// What's the max width of a line applied to Markdown files. Defaults to 80.
+    #[bpaf(long("markdown-formatter-line-width"), argument("NUMBER"))]
+    pub line_width: Option<LineWidth>,
+
+    /// The type of quotes used in Markdown code. Defaults to double.
+    #[bpaf(long("markdown-formatter-quote-style"), argument("double|single"))]
+    pub quote_style: Option<QuoteStyle>,
+
+    /// Whether to insert spaces around brackets in object literals. Defaults to true.
+    #[bpaf(long("bracket-spacing"), argument("true|false"))]
+    pub bracket_spacing: Option<BracketSpacing>,
+}
+
+impl MarkdownFormatterConfiguration {
+    pub fn is_enabled(&self) -> bool {
+        self.enabled.unwrap_or_default().into()
+    }
+}
+
+pub type MarkdownLinterEnabled = Bool<true>;
+
+/// Configuration for the Markdown linter
+#[derive(
+    Bpaf, Clone, Deserializable, Debug, Default, Deserialize, Eq, PartialEq, Merge, Serialize,
+)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[serde(rename_all = "camelCase", default, deny_unknown_fields)]
+pub struct MarkdownLinterConfiguration {
+    /// Control the linter for Markdown files.
+    #[bpaf(long("markdown-linter-enabled"), argument("true|false"))]
+    pub enabled: Option<MarkdownLinterEnabled>,
+}
+
+/// Configuration for the Markdown parser
+#[derive(
+    Bpaf, Clone, Deserializable, Debug, Default, Deserialize, Eq, PartialEq, Merge, Serialize,
+)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[serde(rename_all = "camelCase", default, deny_unknown_fields)]
+pub struct MarkdownParserConfiguration {
+    /// Whether to parse GitHub Flavored Markdown extensions
+    #[bpaf(hide)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub gfm: Option<Bool<true>>,
+}
+
+#[test]
+fn default_markdown_formatter() {
+    let markdown_configuration = MarkdownFormatterConfiguration::default();
+
+    assert!(markdown_configuration.is_enabled());
+}

crates/biome_markdown_factory/src/lib.rs

@@ -8,6 +8,6 @@ pub use crate::generated::MarkdownSyntaxFactory;
 #[doc(hidden)]
 pub use biome_markdown_syntax as syntax;
 
-pub type DemoSyntaxTreeBuilder = TreeBuilder<'static, MarkdownLanguage, MarkdownSyntaxFactory>;
+pub type MarkdownSyntaxTreeBuilder = TreeBuilder<'static, MarkdownLanguage, MarkdownSyntaxFactory>;
 
 pub mod make;

crates/biome_markdown_factory/src/make.rs

@@ -1 +1,123 @@
+use biome_markdown_syntax::{MarkdownSyntaxKind, MarkdownSyntaxToken};
+
 pub use crate::generated::node_factory::*;
+
+/// Create a textual token
+pub fn textual(text: &str) -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::MD_TEXTUAL_LITERAL, text, [], [])
+}
+
+/// Create a string token
+pub fn string(text: &str) -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::MD_STRING_LITERAL, text, [], [])
+}
+
+/// Create a hash token for headers
+pub fn hash() -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::HASH, "#", [], [])
+}
+
+/// Create a backtick token
+pub fn backtick() -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::BACKTICK, "`", [], [])
+}
+
+/// Create a star token for emphasis
+pub fn star() -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::STAR, "*", [], [])
+}
+
+/// Create an underscore token for emphasis
+pub fn underscore() -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::UNDERSCORE, "_", [], [])
+}
+
+/// Create a left bracket token
+pub fn l_brack() -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::L_BRACK, "[", [], [])
+}
+
+/// Create a right bracket token
+pub fn r_brack() -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::R_BRACK, "]", [], [])
+}
+
+/// Create a left parenthesis token
+pub fn l_paren() -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::L_PAREN, "(", [], [])
+}
+
+/// Create a right parenthesis token
+pub fn r_paren() -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::R_PAREN, ")", [], [])
+}
+
+/// Create a bang token for images
+pub fn bang() -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::BANG, "!", [], [])
+}
+
+/// Create a minus token for thematic breaks
+pub fn minus() -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::MINUS, "-", [], [])
+}
+
+/// Create a thematic break token
+pub fn thematic_break() -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::MD_THEMATIC_BREAK_LITERAL, "---", [], [])
+}
+
+/// Create a newline token
+pub fn newline() -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::NEWLINE, "\n", [], [])
+}
+
+/// Create a whitespace token
+pub fn whitespace(text: &str) -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::WHITESPACE, text, [], [])
+}
+
+/// Create a tab token
+pub fn tab() -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::TAB, "\t", [], [])
+}
+
+/// Create an indent chunk token for indented code blocks
+pub fn indent_chunk() -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::MD_INDENT_CHUNK_LITERAL, "    ", [], [])
+}
+
+/// Create a hard line break token
+pub fn hard_line_break() -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::MD_HARD_LINE_LITERAL, "  \n", [], [])
+}
+
+/// Create a greater than token for blockquotes
+pub fn greater_than() -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::R_ANGLE, ">", [], [])
+}
+
+/// Create a plus token for unordered lists
+pub fn plus() -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::PLUS, "+", [], [])
+}
+
+/// Create a digit token for ordered lists
+pub fn digit(text: &str) -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::DIGIT, text, [], [])
+}
+
+/// Create a period token for ordered lists
+pub fn period() -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::PERIOD, ".", [], [])
+}
+
+/// Create a pipe token for tables
+pub fn pipe() -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::PIPE, "|", [], [])
+}
+
+/// Create a colon token for table alignment
+pub fn colon() -> MarkdownSyntaxToken {
+    MarkdownSyntaxToken::new_detached(MarkdownSyntaxKind::COLON, ":", [], [])
+}