hokusai-zero 0.1.1

data/ast/test/hokusai.c

@@ -0,0 +1,14 @@
+#include "greatest.h"
+#include "parser.c"
+#include "text.c"
+
+GREATEST_MAIN_DEFS();
+
+int main(int argc, char** argv) {
+  GREATEST_MAIN_BEGIN();
+
+  RUN_SUITE(hoku_parser_suite);
+  RUN_SUITE(hoku_text_suite);
+
+  GREATEST_MAIN_END();
+}

data/ast/test/parser.c

@@ -0,0 +1,234 @@
+#include "../src/core/ast.c"
+#include "../src/core/style.c"
+#include "../src/core/hml.c"
+
+void walk_tree(TSNode node, char* template, int level)
+{
+	TSNode child;
+	uint32_t child_count = ts_node_child_count(node);
+	for (uint32_t i = 0; i < child_count; i++)
+	{
+		child = ts_node_child(node, i);
+		walk_tree(child, template, level + 1);
+	}
+}
+
+hoku_ast* parse_string(char* template)
+{
+	hoku_ast* comp;
+	hoku_ast_from_template(&comp, "root", template);
+	return comp;
+}
+
+hoku_style* parse_style(char* template)
+{
+	hoku_style* style;
+	int ret = hoku_style_from_template(&style, template);
+	if (ret != 0)
+	{
+		printf("FAILED STYLE PARSE");
+		return NULL;
+	}
+}
+
+TEST test_hoku_parse_macros()
+{
+	char* template =
+	"[template]\n"
+	"	[for=\"post in posts\"]\n"
+	"		two\n"
+	"			[if=\"truth\"]\n"
+	"				three\n"
+ 	"			[else]\n"
+	"				four\n";
+
+	hoku_ast* root = parse_string(template);
+	ASSERT_STR_EQ("root", root->type);
+	hoku_ast* child1 = root->relations->next_child;
+	ASSERT_NEQ(NULL, child1->loop);
+	hoku_ast* child2 = child1->relations->next_child;
+	ASSERT_NEQ(NULL, child2->cond);
+	ASSERT_NEQ(NULL, child2->else_relations);
+
+	PASS();
+}
+
+TEST test_hoku_simple_if()
+{
+	char* template =
+	"[template]\n"
+	"	vblock\n"
+	"		[if=\"state\"]\n"
+	"			conda\n"
+	"		[else]\n"
+	"			condb\n"
+	"		control\n";
+
+	hoku_ast* root = parse_string(template);
+
+	PASS();
+}
+
+TEST test_hoku_parse_style()
+{
+	char* template =
+	"[style]\n"
+	"additionStyles {\n"
+	"  background: color(67,99,168)\n"
+	"  rounding: 0.0;\n"
+	"}\n";
+
+	hoku_style* root = parse_style(template);
+
+	PASS();
+}
+
+
+TEST test_hoku_parse_loop()
+{
+	char* template =
+	"[template]\n"
+	"  panel\n"
+	"    [for=\"content in messages\"]\n"
+	"      ptext\n"
+	"  textfield";
+
+	hoku_ast* root = parse_string(template);
+	ASSERT_STR_EQ("root", root->type);
+	hoku_ast* child1 = root->relations->next_child;
+	ASSERT_STR_EQ("panel", child1->type);
+
+	hoku_ast* textfield = child1->relations->next_sibling;
+	ASSERT_NEQ(NULL, textfield);
+	ASSERT_STR_EQ("textfield", textfield->type);
+
+	hoku_ast* child2 = child1->relations->next_child;
+	ASSERT_NEQ(NULL, child2);
+	ASSERT_STR_EQ("ptext", child2->type);
+
+	PASS();
+}
+
+TEST test_hoku_parse_loop_if()
+{
+	char* template =
+	"[template]\n"
+	"	panel\n"
+	"		[for=\"content in messages\"]\n"
+	"		[if=\"is(item)\"]\n"
+	"			ptext\n"
+	"		[else]\n"
+	"			textfield";
+
+	hoku_ast* root = parse_string(template);
+		hoku_dump(root, 0);
+
+	ASSERT_STR_EQ("root", root->type);
+	hoku_ast* child1 = root->relations->next_child;
+	ASSERT_STR_EQ("panel", child1->type);
+
+	hoku_ast* for_if = child1->relations->next_child;
+	ASSERT_NEQ(NULL, for_if);
+	ASSERT_STR_EQ("ptext", for_if->type);
+	ASSERT_NEQ(NULL, for_if->loop);
+	ASSERT_NEQ(NULL, for_if->cond);
+
+	PASS();
+}
+
+TEST test_hoku_parse_sibling_macros()
+{
+	char* template =
+	"[template]\n"
+	"	[for=\"post in posts\"]\n"
+	"		two\n"
+	"		[if=\"truth\"]\n"
+	"			three\n"
+ 	"		[else]\n"
+	"			four\n";
+	
+	hoku_ast* root = parse_string(template);
+	ASSERT_STR_EQ("root", root->type);
+	hoku_ast* child1 = root->relations->next_child;
+	ASSERT_STR_EQ("two", child1->type);
+	ASSERT_NEQ(NULL, child1->loop);
+	hoku_ast* child2 = child1->relations->next_child;
+	ASSERT_NEQ(NULL, child2->cond);
+	ASSERT_NEQ(NULL, child2->else_relations);
+	PASS();
+}
+
+TEST test_hoku_parse_basic()
+{
+	char* template = 
+	"[template]\n"
+	"child1#it.foo.bar { @click=\"handleClick(arg1, arg2)\", @hover=\"handleHover(one)\"}\n"
+	"  grandchild1\n"
+	"  grandchild2\n"
+	"    great-grandchild1 {:prop=\"value\"}";
+
+	hoku_ast* root = parse_string(template);
+
+	ASSERT_STR_EQ("root", root->type);
+	hoku_ast* child1 = root->relations->next_child;
+	ASSERT_STR_EQ("child1", child1->type);
+	ASSERT_NEQ(NULL, child1->id);
+	ASSERT_EQ(NULL, child1->error);
+	ASSERT_STR_EQ("it", child1->id);
+	ASSERT_EQ(true, hoku_ast_class_list_includes(child1, "foo"));
+	ASSERT_EQ(true, hoku_ast_class_list_includes(child1, "bar"));
+	ASSERT_EQ(false, hoku_ast_class_list_includes(child1, "baz"));
+	ASSERT_EQ_FMT(2, child1->child_len, "%d");
+	ASSERT_EQ_FMT(2, hoku_ast_events_count(child1), "%d");
+	ASSERT_EQ_FMT(0, hoku_ast_props_count(child1), "%d");
+	ASSERT_EQ(NULL, child1->relations->next_sibling);
+
+	hoku_ast_event* click = hoku_ast_get_event(child1, &(hoku_ast_event){.name="click"});
+	ASSERT_NEQ(NULL, click);
+	ASSERT_EQ_FMT(2, click->call->args_len, "%d");
+	ASSERT_STR_EQ("handleClick", click->call->function);
+	ASSERT_STR_EQ("arg1", click->call->strargs[0]);
+	ASSERT_STR_EQ("arg2", click->call->strargs[1]);
+	
+	hoku_ast_event* hover = hoku_ast_get_event(child1, &(hoku_ast_event){.name="hover"});
+	ASSERT_NEQ(NULL, hover);
+	ASSERT_STR_EQ("handleHover", hover->call->function);
+	ASSERT_EQ_FMT(1, hover->call->args_len, "%d");
+	ASSERT_STR_EQ("one" , hover->call->strargs[0]);
+
+	hoku_ast* gchild1 = child1->relations->next_child;
+	ASSERT_STR_EQ("grandchild1", gchild1->type);
+	ASSERT_EQ_FMT(0, hoku_ast_events_count(gchild1), "%d");
+	ASSERT_EQ_FMT(0, hoku_ast_props_count(gchild1), "%d");
+	ASSERT_EQ_FMT(0, gchild1->child_len, "%d");
+
+	hoku_ast* gchild2 = gchild1->relations->next_sibling;
+	ASSERT_NEQ(NULL, gchild2);
+	ASSERT_STR_EQ("grandchild2", gchild2->type);
+	ASSERT_EQ_FMT(1, gchild2->child_len, "%d");
+	ASSERT_EQ(NULL, gchild2->relations->next_sibling);
+
+	hoku_ast* ggchild1 = gchild2->relations->next_child;
+	ASSERT_STR_EQ("great-grandchild1", ggchild1->type);
+	ASSERT_EQ(NULL, ggchild1->relations->next_child);
+	ASSERT_EQ(NULL, ggchild1->relations->next_sibling);
+	ASSERT_EQ_FMT(1, hoku_ast_props_count(ggchild1), "%d");
+	hoku_ast_prop* prop = hoku_ast_get_prop(ggchild1, &(hoku_ast_prop){.name="prop"});
+	ASSERT_NEQ(NULL, prop);
+	ASSERT_EQ_FMT(true, prop->computed, "%d");
+	ASSERT_STR_EQ("prop", prop->name);
+	ASSERT_EQ_FMT(0, prop->call->args_len, "%d");
+	ASSERT_STR_EQ("value", prop->call->function);
+
+	PASS();
+}
+
+SUITE(hoku_parser_suite)
+{
+	RUN_TEST(test_hoku_parse_basic);
+	RUN_TEST(test_hoku_parse_macros);
+	RUN_TEST(test_hoku_parse_loop);
+	RUN_TEST(test_hoku_parse_loop_if);
+	RUN_TEST(test_hoku_parse_style);
+	// RUN_TEST(test_hoku_simple_if);
+}

data/ast/test/text.c

@@ -0,0 +1,116 @@
+#include "../src/core/text.c"
+
+int test_char_width_cb(char letter, void* payload)
+{
+  return 2;
+}
+
+TEST test_hoku_clamp_basic()
+{
+  hoku_clamping* clamp;
+  int ret = hoku_text_clamp(&clamp, "aabbcc", 4, 0.0, NULL, test_char_width_cb);
+  ASSERT_EQ_FMT(0, ret, "%d");
+
+  hoku_text_clamp_debug(clamp);
+
+  hoku_segment* seg = clamp->segments;
+  hoku_char* chr;
+
+  int i;
+  for (i = 0; i < 2; i++)
+  {
+    ASSERT_NEQ(NULL, seg);
+    ASSERT_EQ_FMT(i * 2, seg->offset, "%d");
+    ASSERT_EQ_FMT(2, seg->size, "%d");
+
+    chr = seg->chars;
+
+    // validate chars
+    int d;
+    for (d = 0; d < 2; d++)
+    {
+
+      printf("[seg: %d] %d\n", i, d);
+      ASSERT_NEQ(NULL, chr);
+      ASSERT_EQ_FMT(i * 2 + d, chr->offset, "%d");
+      ASSERT_EQ_FMT(2, seg->size, "%d");
+
+      chr = chr->next_char;
+    }
+
+    seg = seg->next_segment;
+  }
+
+  PASS();
+}
+
+TEST test_hoku_clamp_newline()
+{
+  hoku_clamping* clamp;
+  int ret = hoku_text_clamp(&clamp, "aab\nbcc", 4, 0.0, NULL, test_char_width_cb);
+  ASSERT_EQ_FMT(0, ret, "%d");
+
+  hoku_text_clamp_debug(clamp);
+  PASS();
+}
+
+TEST test_hoku_clamp_wrap()
+{
+  hoku_clamping* clamp;
+  int ret = hoku_text_clamp(&clamp, "the quick brown fox jumped over the yellow dog", 4, 0.0, NULL, test_char_width_cb);
+  ASSERT_EQ_FMT(0, ret, "%d");
+
+  hoku_text_clamp_debug(clamp);
+  PASS();
+}
+
+TEST test_hoku_clamp_file()
+{
+  char *buffer;
+  FILE *fh = fopen("ui/examples/foobar.rb", "rb");
+  if ( fh != NULL )
+  {
+    fseek(fh, 0L, SEEK_END);
+    long s = ftell(fh);
+    rewind(fh);
+    buffer = malloc(s);
+    if ( buffer != NULL )
+    {
+      fread(buffer, s, 1, fh);
+      // we can now close the file
+      fclose(fh); fh = NULL;
+
+      printf("%s\n", buffer);
+
+        hoku_clamping* clamp;
+        int ret = hoku_text_clamp(&clamp, buffer, 400, 0.0, NULL, test_char_width_cb);
+        ASSERT_EQ_FMT(0, ret, "%d");
+
+//        hoku_text_clamp_debug(clamp);
+    }
+    else
+    {
+      perror("Bad");
+    }
+  }
+
+  PASS();
+}
+
+TEST test_hoku_clamp_markdown()
+{
+  hoku_clamping* clamp;
+  int ret = hoku_text_md_clamp(&clamp, "hello _world_\nMy my **my**", 20, 0.0, NULL, test_char_width_cb);
+  ASSERT_EQ_FMT(0, ret, "%d");
+  printf("clamp text: %s\n", clamp->text);
+  PASS();
+
+}
+
+SUITE(hoku_text_suite)
+{
+	RUN_TEST(test_hoku_clamp_basic);
+  RUN_TEST(test_hoku_clamp_markdown);
+	// RUN_TEST(test_hoku_clamp_newline);
+	// RUN_TEST(test_hoku_clamp_file);
+}

data/ext/extconf.rb

@@ -0,0 +1,27 @@
+require "mkmf"
+
+File.open("Makefile", "w") do |io|
+  io << <<~EOF
+  all: clean hokusai
+
+  install:
+  #{"\t"}echo "done"
+
+  vendor/lib/libtree-sitter.a:
+  #{"\t"}xmake q -y tree-sitter
+
+  vendor/lib/libmd4c.a:
+  #{"\t"}xmake q -y md4c
+
+  hokusai: vendor/lib/libmd4c.a vendor/lib/libtree-sitter.a
+  #{"\t"}xmake b -y hokusai
+
+  clean:
+  #{"\t"}xmake clean
+  #{"\t"}xmake q -y --uninstall tree-sitter
+  #{"\t"}xmake q -y --uninstall md4c
+  #{"\t"}rm -f vendor/lib/libhokusai.*
+  #{"\t"}rm -f vendor/lib/libmd4c.*
+  #{"\t"}rm -f vendor/lib/libtree-sitter.*
+  EOF
+end

data/grammar/Cargo.lock

@@ -0,0 +1,80 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "cc"
+version = "1.0.83"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.153"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
+
+[[package]]
+name = "memchr"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149"
+
+[[package]]
+name = "regex"
+version = "1.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b62dbe01f0b06f9d8dc7d49e05a0785f153b00b2c227856282f671e0318c9b15"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5bb987efffd3c6d0d8f5f89510bb458559eab11e4f869acb20bf845e016259cd"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
+
+[[package]]
+name = "tree-sitter"
+version = "0.20.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e747b1f9b7b931ed39a548c1fae149101497de3c1fc8d9e18c62c1a66c683d3d"
+dependencies = [
+ "cc",
+ "regex",
+]
+
+[[package]]
+name = "tree-sitter-HML"
+version = "0.0.1"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]

data/grammar/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "tree-sitter-HML"
+description = "HML grammar for the tree-sitter parsing library"
+version = "0.0.1"
+keywords = ["incremental", "parsing", "HML"]
+categories = ["parsing", "text-editors"]
+repository = "https://github.com/tree-sitter/tree-sitter-HML"
+edition = "2018"
+license = "MIT"
+
+build = "bindings/rust/build.rs"
+include = [
+  "bindings/rust/*",
+  "grammar.js",
+  "queries/*",
+  "src/*",
+]
+
+[lib]
+path = "bindings/rust/lib.rs"
+
+[dependencies]
+tree-sitter = "~0.20.10"
+
+[build-dependencies]
+cc = "1.0"

data/grammar/binding.gyp

@@ -0,0 +1,20 @@
+{
+  "targets": [
+    {
+      "target_name": "tree_sitter_HML_binding",
+      "include_dirs": [
+        "<!(node -e \"require('nan')\")",
+        "src"
+      ],
+      "sources": [
+        "bindings/node/binding.cc",
+        "src/parser.c",
+				"src/scanner.c"
+        # If your language uses an external scanner, add it here.
+      ],
+      "cflags_c": [
+        "-std=c99",
+      ]
+    }
+  ]
+}

data/grammar/bindings/node/binding.cc

@@ -0,0 +1,28 @@
+#include "tree_sitter/parser.h"
+#include <node.h>
+#include "nan.h"
+
+using namespace v8;
+
+extern "C" TSLanguage * tree_sitter_HML();
+
+namespace {
+
+NAN_METHOD(New) {}
+
+void Init(Local<Object> exports, Local<Object> module) {
+  Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
+  tpl->SetClassName(Nan::New("Language").ToLocalChecked());
+  tpl->InstanceTemplate()->SetInternalFieldCount(1);
+
+  Local<Function> constructor = Nan::GetFunction(tpl).ToLocalChecked();
+  Local<Object> instance = constructor->NewInstance(Nan::GetCurrentContext()).ToLocalChecked();
+  Nan::SetInternalFieldPointer(instance, 0, tree_sitter_HML());
+
+  Nan::Set(instance, Nan::New("name").ToLocalChecked(), Nan::New("HML").ToLocalChecked());
+  Nan::Set(module, Nan::New("exports").ToLocalChecked(), instance);
+}
+
+NODE_MODULE(tree_sitter_HML_binding, Init)
+
+}  // namespace

data/grammar/bindings/node/index.js

@@ -0,0 +1,19 @@
+try {
+  module.exports = require("../../build/Release/tree_sitter_HML_binding");
+} catch (error1) {
+  if (error1.code !== 'MODULE_NOT_FOUND') {
+    throw error1;
+  }
+  try {
+    module.exports = require("../../build/Debug/tree_sitter_HML_binding");
+  } catch (error2) {
+    if (error2.code !== 'MODULE_NOT_FOUND') {
+      throw error2;
+    }
+    throw error1
+  }
+}
+
+try {
+  module.exports.nodeTypeInfo = require("../../src/node-types.json");
+} catch (_) {}

data/grammar/bindings/rust/build.rs

@@ -0,0 +1,40 @@
+fn main() {
+    let src_dir = std::path::Path::new("src");
+
+    let mut c_config = cc::Build::new();
+    c_config.include(&src_dir);
+    c_config
+        .flag_if_supported("-Wno-unused-parameter")
+        .flag_if_supported("-Wno-unused-but-set-variable")
+        .flag_if_supported("-Wno-trigraphs");
+    let parser_path = src_dir.join("parser.c");
+    c_config.file(&parser_path);
+
+    // If your language uses an external scanner written in C,
+    // then include this block of code:
+
+    /*
+    let scanner_path = src_dir.join("scanner.c");
+    c_config.file(&scanner_path);
+    println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap());
+    */
+
+    c_config.compile("parser");
+    println!("cargo:rerun-if-changed={}", parser_path.to_str().unwrap());
+
+    // If your language uses an external scanner written in C++,
+    // then include this block of code:
+
+    /*
+    let mut cpp_config = cc::Build::new();
+    cpp_config.cpp(true);
+    cpp_config.include(&src_dir);
+    cpp_config
+        .flag_if_supported("-Wno-unused-parameter")
+        .flag_if_supported("-Wno-unused-but-set-variable");
+    let scanner_path = src_dir.join("scanner.cc");
+    cpp_config.file(&scanner_path);
+    cpp_config.compile("scanner");
+    println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap());
+    */
+}

data/grammar/bindings/rust/lib.rs

@@ -0,0 +1,52 @@
+//! This crate provides HML language support for the [tree-sitter][] parsing library.
+//!
+//! Typically, you will use the [language][language func] function to add this language to a
+//! tree-sitter [Parser][], and then use the parser to parse some code:
+//!
+//! ```
+//! let code = "";
+//! let mut parser = tree_sitter::Parser::new();
+//! parser.set_language(tree_sitter_HML::language()).expect("Error loading HML grammar");
+//! let tree = parser.parse(code, None).unwrap();
+//! ```
+//!
+//! [Language]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Language.html
+//! [language func]: fn.language.html
+//! [Parser]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Parser.html
+//! [tree-sitter]: https://tree-sitter.github.io/
+
+use tree_sitter::Language;
+
+extern "C" {
+    fn tree_sitter_HML() -> Language;
+}
+
+/// Get the tree-sitter [Language][] for this grammar.
+///
+/// [Language]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Language.html
+pub fn language() -> Language {
+    unsafe { tree_sitter_HML() }
+}
+
+/// The content of the [`node-types.json`][] file for this grammar.
+///
+/// [`node-types.json`]: https://tree-sitter.github.io/tree-sitter/using-parsers#static-node-types
+pub const NODE_TYPES: &'static str = include_str!("../../src/node-types.json");
+
+// Uncomment these to include any queries that this grammar contains
+
+// pub const HIGHLIGHTS_QUERY: &'static str = include_str!("../../queries/highlights.scm");
+// pub const INJECTIONS_QUERY: &'static str = include_str!("../../queries/injections.scm");
+// pub const LOCALS_QUERY: &'static str = include_str!("../../queries/locals.scm");
+// pub const TAGS_QUERY: &'static str = include_str!("../../queries/tags.scm");
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_can_load_grammar() {
+        let mut parser = tree_sitter::Parser::new();
+        parser
+            .set_language(super::language())
+            .expect("Error loading HML language");
+    }
+}