ae-tree-sitter-bundle 0.1.0

//! # tree-sitter-bundle
//!
//! A collection of [tree-sitter](https://tree-sitter.github.io) parsers compiled
//! into a single crate, with their highlight queries, ready for editor integration.
//!
//! Each grammar is gated behind a Cargo feature, so you only pay for the languages
//! you enable. Enable everything with the `full` feature, or pick a subset:
//!
//! ```toml
//! tree-sitter-bundle = { version = "0.1", features = ["rust", "python", "json"] }
//! ```
//!
//! ## Parsing
//!
//! ```no_run
//! let lang = tree_sitter_bundle::get("rust").unwrap();
//! let mut parser = tree_sitter::Parser::new();
//! parser.set_language(&lang.language()).unwrap();
//! let tree = parser.parse("fn main() {}", None).unwrap();
//! assert_eq!(tree.root_node().kind(), "source_file");
//! ```
//!
//! ## Highlighting (requires the `highlight` feature, on by default)
//!
//! ```no_run
//! # #[cfg(feature = "highlight")] {
//! use tree_sitter_highlight::{Highlighter, HighlightEvent};
//!
//! let names = ["keyword", "function", "string", "type", "variable"]
//!     .map(String::from);
//! let lang = tree_sitter_bundle::get("rust").unwrap();
//! let config = lang.highlight_config(&names).unwrap();
//!
//! let mut hl = Highlighter::new();
//! let src = b"fn main() {}";
//! for event in hl.highlight(&config, src, None, |_| None).unwrap() {
//!     match event.unwrap() {
//!         HighlightEvent::Source { start, end } => { /* emit text src[start..end] */ }
//!         HighlightEvent::HighlightStart(h) => { /* open span names[h.0] */ }
//!         HighlightEvent::HighlightEnd => { /* close span */ }
//!     }
//! }
//! # }
//! ```

mod generated {
    include!(concat!(env!("OUT_DIR"), "/generated.rs"));
}

use generated::{RawLanguage, RAW_LANGUAGES};

pub use tree_sitter;
#[cfg(feature = "highlight")]
pub use tree_sitter_highlight;

use tree_sitter::Language;

/// A single bundled language: its grammar plus its bundled queries.
#[derive(Clone, Copy)]
pub struct LanguageEntry {
    raw: &'static RawLanguage,
}

impl LanguageEntry {
    /// The language identifier, e.g. `"rust"`, `"tsx"`, `"markdown_inline"`.
    pub fn name(&self) -> &'static str {
        self.raw.name
    }

    /// File extensions associated with this language (without the leading dot).
    pub fn extensions(&self) -> &'static [&'static str] {
        self.raw.extensions
    }

    /// The tree-sitter [`Language`] for this grammar.
    pub fn language(&self) -> Language {
        self.raw.language.into()
    }

    /// The bundled `highlights.scm` query source (may be empty).
    pub fn highlights_query(&self) -> &'static str {
        self.raw.highlights
    }

    /// The bundled `injections.scm` query source (may be empty).
    pub fn injections_query(&self) -> &'static str {
        self.raw.injections
    }

    /// The bundled `locals.scm` query source (may be empty).
    pub fn locals_query(&self) -> &'static str {
        self.raw.locals
    }

    /// Build a ready-to-use [`HighlightConfiguration`] from the bundled queries.
    ///
    /// `recognized_names` is the list of capture names your renderer understands
    /// (e.g. `["keyword", "function", "string"]`); the configuration is wired so
    /// that [`Highlight`] indices map into this slice.
    ///
    /// [`HighlightConfiguration`]: tree_sitter_highlight::HighlightConfiguration
    /// [`Highlight`]: tree_sitter_highlight::Highlight
    #[cfg(feature = "highlight")]
    pub fn highlight_config(
        &self,
        recognized_names: &[String],
    ) -> Result<tree_sitter_highlight::HighlightConfiguration, tree_sitter::QueryError> {
        let mut config = tree_sitter_highlight::HighlightConfiguration::new(
            self.language(),
            self.name(),
            self.highlights_query(),
            self.injections_query(),
            self.locals_query(),
        )?;
        config.configure(recognized_names);
        Ok(config)
    }
}

/// Iterate over every compiled language in the bundle.
pub fn languages() -> impl Iterator<Item = LanguageEntry> {
    RAW_LANGUAGES.iter().map(|raw| LanguageEntry { raw })
}

/// Number of compiled languages.
pub fn count() -> usize {
    RAW_LANGUAGES.len()
}

/// Look up a language by its identifier (case-sensitive), e.g. `get("rust")`.
pub fn get(name: &str) -> Option<LanguageEntry> {
    RAW_LANGUAGES
        .iter()
        .find(|raw| raw.name == name)
        .map(|raw| LanguageEntry { raw })
}

/// Look up a language by file extension (with or without a leading dot).
///
/// Returns the first language that claims the extension. For ambiguous
/// extensions you'll usually want your own filetype table on top of this.
pub fn from_extension(ext: &str) -> Option<LanguageEntry> {
    let ext = ext.trim_start_matches('.');
    RAW_LANGUAGES
        .iter()
        .find(|raw| raw.extensions.iter().any(|e| e.eq_ignore_ascii_case(ext)))
        .map(|raw| LanguageEntry { raw })
}

/// Look up a language by file path, using its extension.
pub fn from_path(path: impl AsRef<std::path::Path>) -> Option<LanguageEntry> {
    path.as_ref()
        .extension()
        .and_then(|e| e.to_str())
        .and_then(from_extension)
}