tree-sitter-sed 0.7.0 → 0.8.0

package/Cargo.toml

@@ -0,0 +1,43 @@
+[package]
+authors = ["konomanoasa"]
+autoexamples = false
+categories = ["parser-implementations", "parsing", "text-editors"]
+description = "Tree-sitter grammars for POSIX sed."
+edition = "2024"
+keywords = ["incremental", "parsing", "tree-sitter", "sed"]
+license = "MIT"
+name = "tree-sitter-sed"
+publish = false
+readme = "README.md"
+repository = "https://github.com/konomanoasa/tree-sitter-sed"
+version = "0.8.0"
+
+build = "bindings/rust/build.rs"
+include = [
+  "/LICENSE",
+  "/README.md",
+  "/bindings/rust/*.rs",
+  "/common/scanner.h",
+  "/queries/*.scm",
+  "/sed_ere/queries/*.scm",
+  "/sed_ere/src/node-types.json",
+  "/sed_ere/src/parser.c",
+  "/sed_ere/src/scanner.c",
+  "/sed_ere/src/tree_sitter/*.h",
+  "/src/node-types.json",
+  "/src/parser.c",
+  "/src/scanner.c",
+  "/src/tree_sitter/*.h",
+]
+
+[lib]
+path = "bindings/rust/lib.rs"
+
+[dependencies]
+tree-sitter-language = "0.1"
+
+[build-dependencies]
+cc = "1.2"
+
+[dev-dependencies]
+tree-sitter = "0.27.0"

package/README.md

@@ -8,6 +8,8 @@ POSIX.1-2024 `sed`.
 
 ## Installation
 
+### npm
+
 ```sh
 npm install tree-sitter-sed
 ```
@@ -16,10 +18,10 @@ npm install tree-sitter-sed
 
 This repository contains the following two grammars.
 
-| Grammar   | Regexp | C function              |
-| --------- | ------ | ----------------------- |
-| `sed`     | BRE    | `tree_sitter_sed()`     |
-| `sed_ere` | ERE    | `tree_sitter_sed_ere()` |
+| Grammar   | Regexp | Rust constant  |
+| --------- | ------ | -------------- |
+| `sed`     | BRE    | `LANGUAGE`     |
+| `sed_ere` | ERE    | `LANGUAGE_ERE` |
 
 ## Development
 

package/bindings/rust/build.rs

@@ -0,0 +1,40 @@
+use std::path::Path;
+
+fn compile_parser(source_dir: &Path, library_name: &str, wasm_headers: Option<&Path>) {
+    let parser_path = source_dir.join("parser.c");
+    let scanner_path = source_dir.join("scanner.c");
+    let mut c_config = cc::Build::new();
+    c_config.std("c11").include(source_dir);
+
+    #[cfg(target_env = "msvc")]
+    c_config.flag("-utf-8");
+
+    if let Some(headers) = wasm_headers {
+        c_config.include(headers);
+    }
+
+    c_config.file(&parser_path).file(&scanner_path);
+    c_config.compile(library_name);
+
+    println!("cargo:rerun-if-changed={}", parser_path.display());
+    println!("cargo:rerun-if-changed={}", scanner_path.display());
+}
+
+fn main() {
+    let target = std::env::var("TARGET").expect("Cargo must provide TARGET");
+    let wasm_headers = (target == "wasm32-unknown-unknown").then(|| {
+        std::env::var_os("DEP_TREE_SITTER_LANGUAGE_WASM_HEADERS")
+            .map(std::path::PathBuf::from)
+            .expect(
+                "tree-sitter-language must provide its headers when compiling for wasm32-unknown-unknown",
+            )
+    });
+
+    compile_parser(Path::new("src"), "tree-sitter-sed", wasm_headers.as_deref());
+    compile_parser(
+        Path::new("sed_ere/src"),
+        "tree-sitter-sed-ere",
+        wasm_headers.as_deref(),
+    );
+    println!("cargo:rerun-if-changed=common/scanner.h");
+}

package/bindings/rust/lib.rs

@@ -0,0 +1,70 @@
+//! POSIX sed grammars for the Tree-sitter parsing library.
+//!
+//! [`LANGUAGE`] parses basic regular expressions, while [`LANGUAGE_ERE`] parses
+//! extended regular expressions.
+//!
+//! ```
+//! let mut parser = tree_sitter::Parser::new();
+//! parser
+//!     .set_language(&tree_sitter_sed::LANGUAGE.into())
+//!     .expect("POSIX sed grammar must load");
+//! let tree = parser.parse("p\n", None).expect("parser must return a tree");
+//! assert!(!tree.root_node().has_error());
+//! ```
+
+use tree_sitter_language::LanguageFn;
+
+unsafe extern "C" {
+    fn tree_sitter_sed() -> *const ();
+    fn tree_sitter_sed_ere() -> *const ();
+}
+
+/// The Tree-sitter [`LanguageFn`] for POSIX sed with basic regular expressions.
+pub const LANGUAGE: LanguageFn = unsafe { LanguageFn::from_raw(tree_sitter_sed) };
+
+/// The Tree-sitter [`LanguageFn`] for POSIX sed with extended regular expressions.
+pub const LANGUAGE_ERE: LanguageFn = unsafe { LanguageFn::from_raw(tree_sitter_sed_ere) };
+
+/// The node type definitions for [`LANGUAGE`].
+pub const NODE_TYPES: &str = include_str!("../../src/node-types.json");
+
+/// The node type definitions for [`LANGUAGE_ERE`].
+pub const NODE_TYPES_ERE: &str = include_str!("../../sed_ere/src/node-types.json");
+
+/// The syntax highlighting query for [`LANGUAGE`].
+pub const HIGHLIGHTS_QUERY: &str = include_str!("../../queries/highlights.scm");
+
+/// The syntax highlighting query for [`LANGUAGE_ERE`].
+pub const HIGHLIGHTS_QUERY_ERE: &str = include_str!("../../sed_ere/queries/highlights.scm");
+
+#[cfg(test)]
+mod tests {
+    fn assert_parses(language: tree_sitter_language::LanguageFn) {
+        let mut parser = tree_sitter::Parser::new();
+        parser
+            .set_language(&language.into())
+            .expect("generated grammar must be compatible with the Tree-sitter runtime");
+        let tree = parser
+            .parse("p\n", None)
+            .expect("parser must return a tree");
+        assert_eq!(tree.root_node().kind(), "script");
+        assert!(!tree.root_node().has_error());
+    }
+
+    #[test]
+    fn sed_grammar_loads_and_parses() {
+        assert_parses(super::LANGUAGE);
+    }
+
+    #[test]
+    fn sed_ere_grammar_loads_and_parses() {
+        assert_parses(super::LANGUAGE_ERE);
+    }
+
+    #[test]
+    fn sed_and_sed_ere_are_distinct_grammars() {
+        let sed = tree_sitter::Language::new(super::LANGUAGE);
+        let sed_ere = tree_sitter::Language::new(super::LANGUAGE_ERE);
+        assert_ne!(sed, sed_ere);
+    }
+}