hokusai-zero 0.2.6 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c28ec9cbfb0ad097992724a26e9304ff581f2becdb0c3edae24b953fecf6f69c
-  data.tar.gz: 7d78d50e110f70dd8af7095df76bd5b039d13c205336c31f42d58c9d503cceb5
+  metadata.gz: 3430bbda86d7deae31c2e789646f7347e378bb8e0349bb7f37545010417b5d1f
+  data.tar.gz: 72457b126d79909ef0989cb67fd278993377b7aa18b9e759b6822e2c05380e8c
 SHA512:
-  metadata.gz: e4c92faf605ff7a6b4f9e0c3489327a01886ee18b2a2700a502b10b984fabf49e365986fb17c37c24d7f474fa7689e36761709bc1e59fcc0cd238ccf29ca8011
-  data.tar.gz: a2b09402e3f899644cb30e398130111e2afd40542763e6e9377f9777b6c5facf56f54465451b26ee2296d3834cc3be1aed640c7856bb2a7839801c260f7ad9ac
+  metadata.gz: 407646a8c7bb287f18b1cc864d72150f4f93f12e29dbcb833befb9968ee5bbea48e0447fda35ca9b40513e4a371db499bc3cd4457e66f8f1d70a6b1d6c0692bb
+  data.tar.gz: ea2e824fb8df8fb0c0a28fbf2ffeb6768f6c2a66d900bf0f2146e04da68dad0a9d93e30eb36d654a60deec1fa4d0625321d9d21a47156a3162bd428f10049b8d

data/Gemfile

@@ -3,7 +3,6 @@ source "https://www.rubygems.org"
 gem "ffi", github: "ffi/ffi", submodules: true
 
 group :development, :test do
-  gem "concurrent-ruby", require: "concurrent"
   gem "memory_profiler", require: false
   gem "mini_portile2", "~> 2.0.0" 
   gem "raylib-bindings"

data/Gemfile.lock

@@ -8,7 +8,6 @@ GIT
 GEM
   remote: https://www.rubygems.org/
   specs:
-    concurrent-ruby (1.3.5)
     daemons (1.4.1)
     diff-lcs (1.6.1)
     domain_name (0.6.20240107)
@@ -77,7 +76,6 @@ PLATFORMS
   x86_64-linux
 
 DEPENDENCIES
-  concurrent-ruby
   ffi!
   memory_profiler
   mini_portile2 (~> 2.0.0)

data/README.md

@@ -12,7 +12,7 @@ A Ruby library for authoring GUI applications
 In your Gemfile
 
 ```ruby
-gem "hokusai-zero",  "0.2.4"
+gem "hokusai-zero",  "0.2.6"
 ```
 
 ## In order to run an application, you will need to install a backend

data/ast/src/core/ast.c

@@ -194,26 +194,18 @@ int hoku_ast_event_compare(const void* a, const void* b, void* udata)
 
 int hoku_ast_add_prop(hoku_ast* component, hoku_ast_prop* prop)
 {
-	if (hashmap_set(component->props, prop) == NULL)
-	{
-		return -1;
-	}
-
+	hashmap_set(component->props, prop);
 	return 0;
 }
 
 hoku_ast_prop* hoku_ast_get_prop(hoku_ast* component, hoku_ast_prop* prop)
 {
-	return hashmap_get(component->props, prop);
+	return (hoku_ast_prop*)hashmap_get(component->props, prop);
 }
 
 int hoku_ast_add_event(hoku_ast* component, hoku_ast_event* event)
 {
-	if (hashmap_set(component->events, event) == NULL)
-	{
-		return -1;
-	}
-
+	hashmap_set(component->events, event);
 	return 0;
 }
 

data/ast/src/core/hml.c

@@ -88,6 +88,10 @@ void hoku_dump(hoku_ast* c, int level)
 		hoku_dump(sibling, level);
 	}
 
+	if (c->else_relations != NULL)
+	{
+		hoku_dump(c->else_relations->next_child, level);
+	}
 	return;
 }
 
@@ -180,15 +184,31 @@ element 1
 hoku_ast* hoku_ast_walk_tree(TSNode node, char* template, int level)
 {
 	char* ntype = ts_node_type(node);
+	if (ntype == NULL)
+	{
+		f_log(F_LOG_ERROR, "Node type is null!\n %s", template);
+		return NULL;
+	}
 
 	if (strcmp(ntype, "name") == 0)
 	{
 		char* name = hoku_get_tag(node, template);
+		if (name == NULL)
+		{
+			f_log(F_LOG_ERROR, "Node name is null!\n%s", template);
+			return NULL;
+		}
 		hoku_ast* init;
-		hoku_ast_init(&init, name);
+		if (hoku_ast_init(&init, name) == -1)
+		{
+			f_log(F_LOG_ERROR, "Could not init ast for %s", name);
+			return NULL;
+		}
+
 		free(name);
 		int i = 0;
-		TSNode sibling = ts_node_next_sibling(node);
+
+		TSNode sibling = ts_node_next_named_sibling(node);
 
 		// a lateral walk across siblings
 		// can be "attributes OR children"
@@ -196,46 +216,94 @@ hoku_ast* hoku_ast_walk_tree(TSNode node, char* template, int level)
 		{
 			i++;
 			char* stype = ts_node_type(sibling);
+			if (stype == NULL)
+			{
+				f_log(F_LOG_ERROR, "Sibling node type is null");
+				return NULL;
+			}
+
 			if (strcmp(stype, "attributes") == 0)
 			{
+				f_log(F_LOG_FINE, "Processing attributes for %s", init->type);
 				// process attributes
-				TSNode attribute = ts_node_child(sibling, 0);
+				TSNode attribute = ts_node_named_child(sibling, 0);
 				while (!ts_node_is_null(attribute))
 				{
 					char* atype = ts_node_type(attribute);
+					if (atype == NULL)
+					{
+						f_log(F_LOG_ERROR, "attribute type is null");
+						return NULL;
+					}
 					if (strcmp(atype, "prop") == 0)
 					{
+						f_log(F_LOG_FINE, "Walking props");
 						hoku_ast_prop* prop = hoku_ast_walk_prop(attribute, template, level + 1);
-						hoku_ast_add_prop(init, prop);
+						if (prop == NULL)
+						{
+							f_log(F_LOG_ERROR, "Prop is null for attribute %s", attribute);
+							return NULL;
+						}
+						if (hoku_ast_add_prop(init, prop) == -1)
+						{
+							f_log(F_LOG_ERROR, "Couldn't add prop %s to %s", prop->name, init->type);
+							return NULL;
+						}
 					}
 					else if (strcmp(atype, "event") == 0)
 					{
+						f_log(F_LOG_FINE, "Walking events");
 						hoku_ast_event* event = hoku_ast_walk_event(attribute, template, level + 1);
-						hoku_ast_add_event(init, event);
+						if (event == NULL)
+						{
+							f_log(F_LOG_ERROR, "Event is null for attribute %s", attribute);
+							return NULL;
+						}
+
+						f_log(F_LOG_FINE, "Adding event %s to ast", event->name);
+						if (hoku_ast_add_event(init, event) == -1)
+						{
+							f_log(F_LOG_ERROR, "Couldn't add event to %s", init->type);
+							return NULL;
+						}
 					}
 					else if (strcmp(atype, "style") == 0)
 					{
-						
 						char* style_name = hoku_get_tag(attribute, template);
+						if (style_name == NULL)
+						{
+							f_log(F_LOG_ERROR, "Style tag name is NULL");
+							return NULL;
+						}
+						f_log(F_LOG_FINE, "prepending style name %s to ast", style_name);
 						if (hoku_ast_style_list_prepend(init, style_name) != 0) return NULL;
+						free(style_name);
 					}
 					else
 					{
 						hoku_ast_set_error(init, "Expecting `event` or `prop`", attribute, hoku_get_tag(attribute, template));
 					}
-					attribute = ts_node_next_sibling(attribute);
+					attribute = ts_node_next_named_sibling(attribute);
 				}
 			}
 			else if (strcmp(stype, "selectors") == 0)
 			{
-				TSNode sel = ts_node_child(sibling, 0);
+				f_log(F_LOG_FINE, "Walking selectors");
+				TSNode sel = ts_node_named_child(sibling, 0);
 				while (!ts_node_is_null(sel))
 				{	
 					char* seltype = ts_node_type(sel);
 					char* seltag = hoku_get_tag(sel, template);
+					if (seltag == NULL)
+					{
+						f_log(F_LOG_ERROR, "selector tag is null!");
+						return NULL;
+					}
+
 					if (strcmp(seltype, "id") == 0)
 					{
-						init->id = seltag;
+						init->id = strdup(seltag);
+						free(seltag);
 					}
 					else if (strcmp(seltype, "class") == 0)
 					{
@@ -243,45 +311,66 @@ hoku_ast* hoku_ast_walk_tree(TSNode node, char* template, int level)
 						free(seltag);
 					}
 
-					sel = ts_node_next_sibling(sel);
+					f_log(F_LOG_FINE, "Getting next selector sibling");
+					sel = ts_node_next_named_sibling(sel);
 				}
 			}
 			else if (strcmp(stype, "children") == 0)
 			{
 				TSNode child;
-				uint32_t child_count = ts_node_child_count(sibling);
+				uint32_t child_count = ts_node_named_child_count(sibling);
+				f_log(F_LOG_DEBUG, "Walking %u children", child_count);
+
 				init->child_len = (int) child_count;
 				hoku_ast* sinit = NULL;
 				for (uint32_t i=0; i<child_count; i++)
 				{
-					child = ts_node_child(sibling, i);
-					char* ctypee = ts_node_type(child);
-					hoku_ast* cchild = hoku_ast_walk_tree(child, template, level + 1);
-					if (sinit == NULL)
-					{
-						sinit = cchild;
-					}
-					else
+					child = ts_node_named_child(sibling, i);
+					char* ctype = ts_node_type(child);
+					f_log(F_LOG_FINE, "Child: %s %d", ctype, i);
+					f_log(F_LOG_DEBUG, "Walking ast tree for %s (%d)", ctype, level);
+
+					if(strcmp(ctype, "else_macro") != 0)
 					{
-						hoku_ast_append_sibling(&sinit, cchild);
+
+						hoku_ast* cchild = hoku_ast_walk_tree(child, template, level + 1);
+						if (cchild == NULL)
+						{
+							f_log(F_LOG_ERROR, "Ast child is NULL");
+							return NULL;
+						}
+
+						if (sinit == NULL)
+						{
+							sinit = cchild;
+						}
+						else
+						{
+							f_log(F_LOG_FINE, "Appending sibling %s to %s", cchild->type, sinit->type);
+							hoku_ast_append_sibling(&sinit, cchild);
+						}
 					}
 				}
 
+				f_log(F_LOG_DEBUG, "Appending child %s to %s", sinit->type, init->type);
 				hoku_ast_append_child(&init, sinit);
 			}
 
 			sibling = ts_node_next_sibling(sibling);
 		}
 
+		f_log(F_LOG_DEBUG, "Returning ast %s", init->type);
 		return init;
 	}
 	else if (strcmp(ntype, "element") == 0)
 	{
+		f_log(F_LOG_FINE, "Walking element tree");
 		TSNode child = ts_node_child(node, 0);
 		return hoku_ast_walk_tree(child, template, level + 1);
 	}
 	else if (strcmp(ntype, "children") == 0)
 	{
+		f_log(F_LOG_FINE, "Walking children tree");
 		TSNode child = ts_node_child(node, 0);
 		return hoku_ast_walk_tree(child, template, level + 1);
 	}
@@ -289,19 +378,38 @@ hoku_ast* hoku_ast_walk_tree(TSNode node, char* template, int level)
 	{
 		TSNode child = ts_node_named_child(node, 0);
 		char* name = hoku_get_tag(child, template);
+		if (name == NULL)
+		{
+			f_log(F_LOG_ERROR, "for macro name is null!");
+			return NULL;
+		}
 
 		TSNode sibling = ts_node_next_named_sibling(child);
 		char* list_name = hoku_get_tag(sibling, template);
+		if (list_name == NULL)
+		{
+			f_log(F_LOG_ERROR, "for macro list name is null!");
+			return NULL;
+		}
+
 		hoku_ast_loop* loop;
 		if (hoku_ast_loop_init(&loop, name, list_name) == -1)
 		{
+			f_log(F_LOG_ERROR, "Failed to initialize loop %s %s", name, list_name);
 			return NULL;
 		}
 
 		free(name);
 		free(list_name);
+
 		TSNode children = ts_node_next_named_sibling(sibling);
+		f_log(F_LOG_DEBUG, "Walking loop children");
 		hoku_ast* ast = hoku_ast_walk_tree(children, template, level + 1);
+		if (ast == NULL)
+		{
+			f_log(F_LOG_ERROR, "Loop ast is null");
+			return NULL;
+		}
 
 		ast->loop = loop;
 
@@ -309,17 +417,32 @@ hoku_ast* hoku_ast_walk_tree(TSNode node, char* template, int level)
 	}
 	else if (strcmp(ntype, "if_macro") == 0)
 	{
+		f_log(F_LOG_DEBUG, "Handling if macro");
 		TSNode child = ts_node_named_child(node, 0);
 		hoku_ast_func_call* call = hoku_ast_walk_func(child, template, level);
+		if (call == NULL)
+		{
+			f_log(F_LOG_ERROR, "Func call for if macro is null");
+			return NULL;
+		}
 
 		hoku_ast_condition* cond;
 		if (hoku_ast_cond_init(&cond, call) == -1)
 		{
+			f_log(F_LOG_ERROR, "Condition for if macro is null");
 			return NULL;
 		}
 
 		TSNode ichildren = ts_node_next_named_sibling(child);
+
 		hoku_ast* iast = hoku_ast_walk_tree(ichildren, template, level + 1);
+		if (iast == NULL)
+		{
+			f_log(F_LOG_ERROR, "If macro children ast is null");
+			return NULL;
+		}
+
+		f_log(F_LOG_FINE, "Walked if macro children");
 		iast->cond = cond;
 
 		TSNode echild = ts_node_next_named_sibling(node);
@@ -329,21 +452,35 @@ hoku_ast* hoku_ast_walk_tree(TSNode node, char* template, int level)
 
 			if (strcmp(etype, "else_macro") == 0)
 			{
+				f_log(F_LOG_FINE, "Walking next else child");
+
 				TSNode eechildren = ts_node_named_child(echild, 0);
-				hoku_ast* oast = hoku_ast_walk_tree(eechildren, template, level + 1);
+				if (!ts_node_is_null(eechildren))
+				{
+					hoku_ast* oast = hoku_ast_walk_tree(eechildren, template, level + 1);
+					if (oast == NULL)
+					{
+						f_log(F_LOG_ERROR, "Else cond children ast is null");
+						return NULL;
+					}
 
-				iast->else_relations = malloc(sizeof(hoku_ast*));
-				if (iast->else_relations == NULL) return NULL;
+					iast->else_relations = malloc(sizeof(hoku_ast*));
+					if (iast->else_relations == NULL) return NULL;
 
-				iast->else_relations->next_child = oast;
-				iast->else_relations->next_sibling = NULL;
-			}
+					iast->else_relations->next_child = oast;
+					iast->else_relations->next_sibling = NULL;
+				}
+			}	
+		}
+		else
+		{
+			f_log(F_LOG_WARN, "If macro has no else children");
 		}
-
 		return iast;
 	}
 	else if (strcmp(ntype, "for_if_macro") == 0)
 	{
+		f_log(F_LOG_DEBUG, "Handling for/if macro");
 		TSNode child = ts_node_named_child(node, 0);
 		char* name = hoku_get_tag(child, template);
 
@@ -394,6 +531,7 @@ hoku_ast* hoku_ast_walk_tree(TSNode node, char* template, int level)
 	}
 	else
 	{
+		f_log(F_LOG_WARN, "Unsupported type %s", ntype);
 		return NULL;
 	}
 }
@@ -412,6 +550,11 @@ hoku_style_attribute* hoku_walk_style_attributes(TSNode node, char* template)
 		TSNode value_node = ts_node_next_named_sibling(attribute_name_node);
 		char* value_node_type = ts_node_type(value_node);
 
+		if (value_node_type == NULL || attribute_name == NULL)
+		{
+			return NULL;
+		}
+
 		enum HOKU_STYLE_TYPE type;
 		char* value = NULL;
 		char* function_name = NULL;
@@ -564,6 +707,8 @@ int hoku_style_from_template(hoku_style** out, char* template)
 		return -1;
 	}
 
+	ts_tree_delete(tree);
+	ts_parser_delete(parser);
 	*out = style;
 	return 0;
 }
@@ -571,26 +716,35 @@ int hoku_style_from_template(hoku_style** out, char* template)
 int hoku_ast_from_template(hoku_ast** out, char* type, char* template)
 {
 	hoku_ast* init;
-	if (hoku_ast_init(&init, type) == -1) return -1;
+	if (hoku_ast_init(&init, type) == -1)
+	{
+		f_log(F_LOG_ERROR, "AST initialization failed.");
+		return -1;
+	}
 
 	hoku_style* style = NULL;
 
+	f_log(F_LOG_FINE, "Initializing parser.");
 	TSParser* parser = ts_parser_new();
 	if (parser == NULL)
 	{
+		f_log(F_LOG_ERROR, "Parser initialization failed.");
 		free(init);
 		return -1;
 	}
 
+	f_log(F_LOG_FINE, "Parsing document.");
 	ts_parser_set_language(parser, tree_sitter_hml());
 	TSTree* tree = ts_parser_parse_string(parser, NULL, template, strlen(template));
 	if (tree == NULL)
 	{
+		f_log(F_LOG_ERROR, "TS Parser tree is NULL.");
 		ts_parser_delete(parser);
 		free(init);
 		return -1;
 	}
 
+	f_log(F_LOG_FINE, "Getting tree root node.");
 	TSNode document = ts_tree_root_node(tree);
 	if (strcmp(ts_node_type(document), "document") != 0)
 	{
@@ -599,16 +753,20 @@ int hoku_ast_from_template(hoku_ast** out, char* type, char* template)
 		return 0;
 	}
 
+	f_log(F_LOG_FINE, "Getting document template (first child)");
 	TSNode templ = ts_node_named_child(document, 0);
 	if (strcmp(ts_node_type(templ), "template") != 0 && strcmp(ts_node_type(templ), "style_template") != 0)
 	{
+		f_log(F_LOG_DEBUG, "Document not expected.");
 		hoku_ast_set_error(init, "Expecting template", templ, hoku_get_tag(templ, template));
 		*out = init;
 		return 0;
 	}
 
+	f_log(F_LOG_FINE, "Checking style template");
 	if (strcmp(ts_node_type(templ), "style_template") == 0)
 	{
+		f_log(F_LOG_DEBUG, "Walking style template.");
 		style = hoku_walk_style_template(templ, template);
 		templ = ts_node_next_named_sibling(templ);
 
@@ -623,39 +781,55 @@ int hoku_ast_from_template(hoku_ast** out, char* type, char* template)
 	TSNode child = ts_node_named_child(templ, 0);
 	hoku_ast* roots = NULL;
 	char* ntype = ts_node_type(child);
+	f_log(F_LOG_FINE, "init vars, %p, %p", child, ntype);
 
+	f_log(F_LOG_DEBUG, "Walking template tree for");
 	while (!ts_node_is_null(child))
 	{
-		hoku_ast* children;
-		children = hoku_ast_walk_tree(child, template, 0);
+		ntype = ts_node_type(child);
 
-		if (children == NULL) 
+		if (strcmp(ntype, "else_macro") != 0)
 		{
-			char* ntype = ts_node_type(child);
-		}
+			hoku_ast* children;
+			children = hoku_ast_walk_tree(child, template, 0);
 
-		if (roots == NULL)
-		{
-			roots = children;
-		}
-		else
-		{
-			hoku_ast_append_sibling(&roots, children);
+			f_log(F_LOG_DEBUG, "Walked template children, %p", children);
+
+			if (children == NULL) 
+			{
+				f_log(F_LOG_WARN, "Children are NULL");
+				char* ntype = ts_node_type(child);
+			}
+
+			if (roots == NULL)
+			{
+				f_log(F_LOG_DEBUG, "Setting roots to children");
+				roots = children;
+			}
+			else
+			{
+				f_log(F_LOG_FINE, "Appending children as siblings to root ast.");
+				hoku_ast_append_sibling(&roots, children);
+			}
 		}
 
+		f_log(F_LOG_DEBUG, "Assigning next sibling.");
 		child = ts_node_next_named_sibling(child);
 	}
 
+	f_log(F_LOG_DEBUG, "Appending root ast to init ast");
 	hoku_ast_append_child(&init, roots);
 
 	templ = ts_node_next_named_sibling(templ);
 	if (!ts_node_is_null(templ) && strcmp(ts_node_type(templ), "style_template") == 0)
 	{
+		f_log(F_LOG_FINE, "walking style template\n");
 		style = hoku_walk_style_template(templ, template);
 	}
 
 	init->styles = style;
 
+	f_log(F_LOG_FINE, "delete tree and parser");
 	ts_tree_delete(tree);
 	ts_parser_delete(parser);
 	

data/ast/src/core/hml.h

@@ -3,6 +3,7 @@
 
 #include "style.h"
 #include "ast.h"
+#include "log.h"
 
 int hoku_style_from_template(hoku_style** out, char* template);
 int hoku_ast_from_template(hoku_ast** out, char* type, char* template);

data/ast/src/core/input.h

@@ -93,7 +93,6 @@ typedef struct HmlInput
   hoku_input_mouse* mouse;
 } hoku_input;
 
-
 int hoku_input_keyboard_init(hoku_input_keyboard** keyboard);
 int hoku_input_mouse_init(hoku_input_mouse** mouse);
 int hoku_input_init(hoku_input** input);

data/ast/src/core/log.c

@@ -0,0 +1,87 @@
+#ifndef FLASHLIGHT_LOG
+#define FLASHLIGHT_LOG
+#include "log.h"
+
+void f_default_on_log_message(f_log_message msg)
+{
+  if (msg.level & f_logger_get_level())
+  {
+    switch(msg.level)
+    {
+      case F_LOG_FINE: {
+        fprintf(stderr, ANSI_COLOR_YELLOW " [%s] " ANSI_COLOR_RESET "%s\n", msg.datetime, msg.message);
+        break;
+      }
+      case F_LOG_DEBUG: {
+        fprintf(stderr, ANSI_COLOR_CYAN " [%s] " ANSI_COLOR_RESET "%s\n", msg.datetime, msg.message);
+        break;
+      }
+      case F_LOG_INFO: {
+        fprintf(stderr, ANSI_COLOR_BLUE " [%s] " ANSI_COLOR_RESET "%s\n", msg.datetime, msg.message);
+        break;
+      }
+      case F_LOG_WARN: {
+        fprintf(stderr, ANSI_COLOR_YELLOW " [%s] " ANSI_COLOR_RESET "%s\n", msg.datetime, msg.message);
+        break;
+      }
+      case F_LOG_ERROR: {
+        fprintf(stderr, ANSI_COLOR_MAGENTA " [%s] " ANSI_COLOR_RESET "%s\n", msg.datetime, msg.message);
+        break;
+      }
+    }
+  }
+}
+
+void f_logger_set_level(enum F_LOG_LEVEL level)
+{
+  f_log_level = level;
+}
+
+void f_logger_set_cb(f_logger_cb cb, volatile void* payload)
+{
+  f_log_cb = cb;
+  f_log_payload = payload;
+}
+
+f_logger_cb f_logger_get_cb()
+{
+  return f_log_cb;
+}
+
+volatile void* f_logger_get_payload()
+{
+  return f_log_payload;
+}
+
+enum F_LOG_LEVEL f_logger_get_level()
+{
+  return f_log_level;
+}
+
+void f_log(enum F_LOG_LEVEL level, char* fmt, ...)
+{
+  time_t t = time(NULL);
+  struct tm* tm = localtime(&t);
+  char datetime[64];
+  strftime(datetime, sizeof(datetime), "%c", tm);
+  char message[500];
+  volatile void* payload = f_logger_get_payload();
+
+  va_list args;
+  va_start(args, fmt);
+  vsprintf(message, fmt, args);
+  va_end(args);
+
+  f_log_message msg = {datetime, level, message};
+
+  if (f_log_cb == NULL)
+  {
+    f_default_on_log_message(msg);
+  }
+  else
+  {
+    f_log_cb(msg, payload);
+  }
+}
+
+#endif