tree_sitter_language_pack 1.0.0.rc.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e0e70fba75e85bf3ca744874c8b278fe3fa821bfe35998495f5826b50f94c4c0
+  data.tar.gz: e77f82f0394870ae8a02718e0d52a0193379eff0696bb874571c1c61159e133f
+SHA512:
+  metadata.gz: 97b9ef50b06634a695a6dbf2f14abe459a13dac86453e7543fb4f8aeaff580a0833f5940d4d0431d4afd152d5f2c45b18714da3b738f1bc87b621c79a71da2c6
+  data.tar.gz: e3b8796578f971068923eea849d7323f9df5d444d786fd6e3cf798af3317dbac282b2c84c4ce812352b846a129680ecbdb524faef68a67d3c4b536a53ce33b22

data/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "ts-pack-ruby"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+description = "Ruby Magnus bindings for tree-sitter language pack"
+publish = false
+
+[lib]
+name = "ts_pack_ruby"
+crate-type = ["cdylib"]
+
+[dependencies]
+tree-sitter-language-pack = { workspace = true, features = ["serde"] }
+serde_json = { workspace = true }
+tree-sitter = { workspace = true }
+magnus = "0.8"
+rb-sys = "0.9"
+
+[package.metadata.cargo-machete]
+ignored = ["rb-sys"]

data/extconf.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+require 'rb_sys/mkmf'
+
+# Use a separate target dir to avoid lockfile collision with the workspace
+ENV['CARGO_TARGET_DIR'] ||= File.expand_path('target', __dir__)
+
+create_rust_makefile('ts_pack_ruby/ts_pack_ruby') do |r|
+  r.profile = ENV.fetch('CARGO_PROFILE', 'release').to_sym
+  r.ext_dir = File.expand_path('.', __dir__)
+end

data/lib/tree_sitter_language_pack.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'tree_sitter_language_pack/ts_pack_ruby'
+
+# Ruby bindings for the tree-sitter language pack.
+module TreeSitterLanguagePack
+end

data/src/lib.rs

@@ -0,0 +1,96 @@
+use magnus::{Error, Ruby, function, method, prelude::*};
+use std::sync::Mutex;
+
+/// Wraps a tree-sitter Tree for safe sharing across the Ruby boundary.
+#[magnus::wrap(class = "TreeSitterLanguagePack::Tree")]
+struct TreeWrapper(Mutex<tree_sitter::Tree>);
+
+/// Helper to create a runtime error from instance methods where `&Ruby` is not available.
+fn lock_error() -> Error {
+    // SAFETY: This is called from Ruby-invoked methods, so the Ruby VM is active.
+    let ruby = unsafe { Ruby::get_unchecked() };
+    Error::new(ruby.exception_runtime_error(), "lock poisoned")
+}
+
+impl TreeWrapper {
+    fn root_node_type(&self) -> Result<String, Error> {
+        let guard = self.0.lock().map_err(|_| lock_error())?;
+        Ok(guard.root_node().kind().to_string())
+    }
+
+    fn root_child_count(&self) -> Result<usize, Error> {
+        let guard = self.0.lock().map_err(|_| lock_error())?;
+        Ok(guard.root_node().named_child_count())
+    }
+
+    fn contains_node_type(&self, node_type: String) -> Result<bool, Error> {
+        let guard = self.0.lock().map_err(|_| lock_error())?;
+        Ok(tree_sitter_language_pack::tree_contains_node_type(&guard, &node_type))
+    }
+
+    fn has_error_nodes(&self) -> Result<bool, Error> {
+        let guard = self.0.lock().map_err(|_| lock_error())?;
+        Ok(tree_sitter_language_pack::tree_has_error_nodes(&guard))
+    }
+}
+
+fn available_languages() -> Vec<String> {
+    tree_sitter_language_pack::available_languages()
+}
+
+fn has_language(name: String) -> bool {
+    tree_sitter_language_pack::has_language(&name)
+}
+
+fn language_count() -> usize {
+    tree_sitter_language_pack::language_count()
+}
+
+fn get_language_ptr(ruby: &Ruby, name: String) -> Result<u64, Error> {
+    let language = tree_sitter_language_pack::get_language(&name)
+        .map_err(|_| Error::new(ruby.exception_runtime_error(), format!("language not found: {name}")))?;
+    let raw_ptr = language.into_raw();
+    Ok(raw_ptr as u64)
+}
+
+fn parse_string(ruby: &Ruby, language: String, source: String) -> Result<TreeWrapper, Error> {
+    let tree = tree_sitter_language_pack::parse_string(&language, source.as_bytes())
+        .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("{e}")))?;
+    Ok(TreeWrapper(Mutex::new(tree)))
+}
+
+/// Unified process method that accepts a JSON config string and returns a JSON result string.
+///
+/// The config JSON must contain at least `"language"`. Optional fields:
+/// - `structure`, `imports`, `exports`, `comments`, `docstrings`, `symbols`, `diagnostics` (booleans, default true)
+/// - `chunk_max_size` (integer or null, default null meaning no chunking)
+fn process(ruby: &Ruby, source: String, config_json: String) -> Result<String, Error> {
+    let core_config: tree_sitter_language_pack::ProcessConfig = serde_json::from_str(&config_json)
+        .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("invalid config JSON: {e}")))?;
+
+    let result = tree_sitter_language_pack::process(&source, &core_config)
+        .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("{e}")))?;
+
+    serde_json::to_string(&result)
+        .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("serialization failed: {e}")))
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module = ruby.define_module("TreeSitterLanguagePack")?;
+
+    module.define_module_function("available_languages", function!(available_languages, 0))?;
+    module.define_module_function("has_language", function!(has_language, 1))?;
+    module.define_module_function("language_count", function!(language_count, 0))?;
+    module.define_module_function("get_language_ptr", function!(get_language_ptr, 1))?;
+    module.define_module_function("parse_string", function!(parse_string, 2))?;
+    module.define_module_function("process", function!(process, 2))?;
+
+    let tree_class = module.define_class("Tree", ruby.class_object())?;
+    tree_class.define_method("root_node_type", method!(TreeWrapper::root_node_type, 0))?;
+    tree_class.define_method("root_child_count", method!(TreeWrapper::root_child_count, 0))?;
+    tree_class.define_method("contains_node_type", method!(TreeWrapper::contains_node_type, 1))?;
+    tree_class.define_method("has_error_nodes", method!(TreeWrapper::has_error_nodes, 0))?;
+
+    Ok(())
+}

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: tree_sitter_language_pack
+version: !ruby/object:Gem::Version
+  version: 1.0.0.rc.7
+platform: ruby
+authors:
+- kreuzberg.dev
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-03-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: 170+ pre-compiled tree-sitter language parsers with Ruby bindings via
+  Magnus native extensions.
+email:
+- dev@kreuzberg.dev
+executables: []
+extensions:
+- extconf.rb
+extra_rdoc_files: []
+files:
+- Cargo.toml
+- extconf.rb
+- lib/tree_sitter_language_pack.rb
+- src/lib.rs
+homepage: https://github.com/kreuzberg-dev/tree-sitter-language-pack
+licenses:
+- MIT
+metadata:
+  cargo_crate_name: ts-pack-ruby
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Ruby bindings for tree-sitter-language-pack
+test_files: []