hokusai-zero 0.2.6.pre.pinephone6 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fadc5b1cf6e75bc57d76dcca297a97521e64a744858ef0cafbf53e2e7d259373
-  data.tar.gz: 010f5c1f195932e39b8f5061cbab13bc55ce88485bec86dadb6a5ec0754feb2b
+  metadata.gz: 608b618b6ed01eea7db698a5e8d18d7916d8e06ef9227b6ce0b24a9e9e744d24
+  data.tar.gz: f0ae7f8a0e94aa8056989af6090a8e734dc1674880a3b138338d6f15a55500d0
 SHA512:
-  metadata.gz: 4e0bdc4ecaa1609324e3ca7a2ba3dadd7ca9ef145ee67c49d66a9fc8c76b5971f1d61f14f806124c7e0c5564a0420af50619dd44da64828a8e041ed47cf35a6d
-  data.tar.gz: 63f2644bd086280547eea3497df85f274e9dd6304314de84c77839eb4bbd49b903506afb87aae47a230e2861cb80201e1c296c864869b8fbf4a5dca0999c3abc
+  metadata.gz: 42dad85dbcaf2e3a5bf5af87cfb608b18be65b978cdeac5fe13aa6f27c944ae0661aa3c92045d296e65065049482f66d4a02d27a187950a18fa5060857b0712b
+  data.tar.gz: ae90ae51b1025fe9f991b05ef632b7ff4f354c541f34ad507c8c8e90ac8cd80ee35e759ae82cb45f2d8060530572c9dba468a6433b76ec76b64df4705fb45991

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;
@@ -571,26 +714,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 +751,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 +779,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/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

data/ast/src/core/log.h

@@ -0,0 +1,41 @@
+#ifndef FLASHLIGHT_LOG_H
+#define FLASHLIGHT_LOG_H
+#include <time.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+#define ANSI_COLOR_YELLOW  "\x1b[33m"
+#define ANSI_COLOR_BLUE    "\x1b[34m"
+#define ANSI_COLOR_MAGENTA "\x1b[35m"
+#define ANSI_COLOR_CYAN    "\x1b[36m"
+#define ANSI_COLOR_RESET   "\x1b[0m"
+
+enum F_LOG_LEVEL
+{
+  F_LOG_ERROR = 1 << 0,
+  F_LOG_WARN = 1 << 1,
+  F_LOG_INFO = 1 << 2,
+  F_LOG_DEBUG = 1 << 3,
+  F_LOG_FINE = 1 << 4
+};
+
+typedef struct FLogMessage
+{
+  char* datetime;
+  enum F_LOG_LEVEL level;
+  char* message;
+} f_log_message;
+
+typedef void (*f_logger_cb)(f_log_message message, volatile void* payload);
+static volatile f_logger_cb f_log_cb = NULL;
+static volatile enum F_LOG_LEVEL f_log_level = F_LOG_ERROR;
+static volatile void* f_log_payload = NULL;
+
+void f_logger_set_level(enum F_LOG_LEVEL level);
+void f_logger_set_cb(f_logger_cb cb, volatile void* payload);
+f_logger_cb f_logger_get_cb();
+enum F_LOG_LEVEL f_logger_get_level();
+volatile void* f_logger_get_payload();
+void f_log(enum F_LOG_LEVEL level, char* fmt, ...);
+
+#endif

data/ast/test/parser.c

@@ -1,3 +1,4 @@
+#include "../src/core/log.c"
 #include "../src/core/ast.c"
 #include "../src/core/style.c"
 #include "../src/core/hml.c"

data/ext/extconf.rb

@@ -54,10 +54,10 @@ md4c.activate
 pre = "#{__dir__}/.."
 cwd = "#{__dir__}"
 
-files = %w[ast/src/core/hml.c ast/src/core/ast.c ast/rc/core/style.c ast/src/core/input.c ast/src/core/component.c ast/src/core/util.c ast/src/core/text.c grammar/src/parser.c grammar/src/scanner.c ast/include/hashmap.c]
-objects = %w[hml.o ast.o style.o input.o component.o util.o text.o parser.o scanner.o hashmap.o]
+files = %w[ast/src/core/log.c ast/src/core/hml.c ast/src/core/ast.c ast/rc/core/style.c ast/src/core/input.c ast/src/core/component.c ast/src/core/util.c ast/src/core/text.c grammar/src/parser.c grammar/src/scanner.c ast/include/hashmap.c]
+objects = %w[log.o hml.o ast.o style.o input.o component.o util.o text.o parser.o scanner.o hashmap.o]
 libraries = [File.expand_path("#{tree_sitter.path}/lib/libtree-sitter.a"), File.expand_path("#{md4c.path}/lib/libmd4c.#{md4cext}")]
-src_files = ["#{tree_sitter.path}/lib/libtree-sitter.a", "#{md4c.path}/lib/libmd4c.#{md4cext}", "#{pre}/ast/src/core/hml.c", "#{pre}/ast/src/core/ast.c", "#{pre}/ast/src/core/style.c", "#{pre}/ast/src/core/input.c", "#{pre}/ast/src/core/component.c", "#{pre}/ast/src/core/util.c", "#{pre}/ast/src/core/text.c", "#{pre}/grammar/src/parser.c", "#{pre}/grammar/src/scanner.c", "#{pre}/ast/include/hashmap.c"]
+src_files = ["#{tree_sitter.path}/lib/libtree-sitter.a", "#{md4c.path}/lib/libmd4c.#{md4cext}", "#{pre}/ast/src/core/log.c", "#{pre}/ast/src/core/hml.c", "#{pre}/ast/src/core/ast.c", "#{pre}/ast/src/core/style.c", "#{pre}/ast/src/core/input.c", "#{pre}/ast/src/core/component.c", "#{pre}/ast/src/core/util.c", "#{pre}/ast/src/core/text.c", "#{pre}/grammar/src/parser.c", "#{pre}/grammar/src/scanner.c", "#{pre}/ast/include/hashmap.c"]
 if MiniPortile.windows?
   cflags = "-shared -Wall -Wl,--export-all-symbols -Wl,--enable-auto-import"
   mkdir = "mkdir #{pre}\\vendor\\lib"

data/hokusai.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'hokusai-zero'
-  s.version     = '0.2.6-pinephone6'
+  s.version     = '0.2.7'
   s.licenses    = ['MIT']
   s.summary     = "A Ruby library for writing GUI applications"
   s.authors     = ["skinnyjames"]

data/ui/examples/counter.rb

@@ -122,12 +122,11 @@ Hokusai::Backends::RaylibBackend.run(Demos::Counter) do |config|
   # end
 
   config.after_load do
-    font = Hokusai::Backends::RaylibBackend::Font.sdf("#{__dir__}/assets/OpenSans-Regular.ttf", 260)
+    font = Hokusai::Backends::RaylibBackend::Font.from_ext("#{__dir__}/assets/OpenSans-Regular.ttf", 160)
     Hokusai.fonts.register "opensans", font
     Hokusai.fonts.activate "opensans"
   end
 
-  config.fps = 40
   config.width = 500
   config.height = 500
   config.title = "Counter application"

data/ui/examples/spreadsheet.rb

@@ -119,15 +119,15 @@ module Demos
   end
 end
 
-Hokusai::Backends::RaylibBackend.run(Demos::Spreadsheet::App) do |config|
-  config.after_load do
-    font = Hokusai::Backends::RaylibBackend::Font.from("#{__dir__}/assets/Inter-Regular.ttf")
-    Hokusai.fonts.register "inter", font
-    Hokusai.fonts.activate "inter"
+Hokusai::Backends::SDLBackend.run(Demos::Spreadsheet::App) do |config|
+  # config.after_load do
+  #   font = Hokusai::Backends::RaylibBackend::Font.from("#{__dir__}/assets/Inter-Regular.ttf")
+  #   Hokusai.fonts.register "inter", font
+  #   Hokusai.fonts.activate "inter"
 
-    font = Hokusai::Backends::RaylibBackend::Font.from_ext("#{__dir__}/assets/Delius-Regular.ttf", 160)
-    Hokusai.fonts.register "dohyeon", font
-  end 
+  #   font = Hokusai::Backends::RaylibBackend::Font.from_ext("#{__dir__}/assets/Delius-Regular.ttf", 160)
+  #   Hokusai.fonts.register "dohyeon", font
+  # end 
 
   config.fps = 60
   config.width = 800
@@ -135,7 +135,7 @@ Hokusai::Backends::RaylibBackend.run(Demos::Spreadsheet::App) do |config|
   config.title = "Spreadsheet application"
 
 
-  config.config_flags = Raylib::FLAG_WINDOW_RESIZABLE | Raylib::FLAG_VSYNC_HINT | Raylib::FLAG_WINDOW_TRANSPARENT
-  config.window_state_flags = Raylib::FLAG_WINDOW_RESIZABLE | Raylib::FLAG_WINDOW_UNDECORATED | Raylib::FLAG_WINDOW_TRANSPARENT
-  config.background = Raylib::BLANK
+  # config.config_flags = Raylib::FLAG_WINDOW_RESIZABLE | Raylib::FLAG_VSYNC_HINT | Raylib::FLAG_WINDOW_TRANSPARENT
+  # config.window_state_flags = Raylib::FLAG_WINDOW_RESIZABLE | Raylib::FLAG_WINDOW_UNDECORATED | Raylib::FLAG_WINDOW_TRANSPARENT
+  # config.background = Raylib::BLANK
 end

data/ui/examples/tic_tac_toe.rb

@@ -240,9 +240,9 @@ module Demos
     end
   end
 end
-
-Hokusai::Backends::RaylibBackend.run(Demos::TicTacToe::App) do |config|
-  config.width = 500
-  config.height = 500
-  config.title = "Tic Tac Trollio"
-end
+#
+# Hokusai::Backends::SDLBackend.run(TicTacToe::App) do |config|
+#   config.width = 500
+#   config.height = 500
+#   config.title = "Tic Tac Trollio"
+# end

data/ui/lib/lib_hokusai.rb

@@ -146,8 +146,26 @@ module LibHokusai
     :max
   ]
 
+  def self.set_log_level(symbol)
+    case symbol
+    when :fine
+      LibHokusai.f_logger_set_level(1 | 2 | 4 | 8 | 16)
+    when :debug
+      LibHokusai.f_logger_set_level(1 | 2 | 4 | 8)
+    when :info
+      LibHokusai.f_logger_set_level(1 | 2 | 4)
+    when :warn
+      LibHokusai.f_logger_set_level(1 | 2)
+    when :error
+      LibHokusai.f_logger_set_level(1)
+    end
+  end
+
+  enum :log_level, [:error, 1, :warn, 2, :info, 4, :debug, 8, :fine, 16]
+
   # fun hashmap_iter(map : Hashmap, i : LibC::SizeT*, item : Void**) : Bool
   # ast methods
+  attach_function :f_logger_set_level, [:log_level], :void
   attach_function :hoku_ast_prop_init, [:pointer, :string], :int
   attach_function :hoku_ast_class_list_includes, [:pointer, :string], :int
   attach_function :hoku_ast_get_prop, [HmlAst.by_ref, HmlAstProp.by_ref], HmlAstProp.by_ref

data/ui/src/hokusai/backends/raylib.rb

@@ -20,7 +20,7 @@ module Hokusai::Backends
     uniform vec4 colDiffuse;
 
     // NOTE: Add your custom variables here
-    const float smoothing = 1.0/16.0;
+    const float smoothing = 1.0/32.0;
 
     void main()
     {

data/ui/src/hokusai/meta.rb

@@ -118,10 +118,15 @@ module Hokusai
         child.update
       end
     end
-
-    def has_ast?(ast, index)
-      if portal = children![index]&.node&.portal&.portal
-        return portal.ast.object_id == ast.object_id
+    def has_ast?(ast, index, elsy = false)
+      if elsy
+        if portal = children![index]&.node&.portal
+          return portal.ast.object_id == ast.object_id
+        end
+      else
+        if portal = children![index]&.node&.portal&.portal
+          return portal.ast.object_id == ast.object_id
+        end
       end
 
       false

data/ui/src/hokusai/mounting/update_entry.rb

@@ -19,8 +19,8 @@ module Hokusai
             portal.ast.children.each_with_index do |child, index|
               next unless child.has_if_condition?
 
-              child_present = ->(child) do
-                meta.has_ast?(child, index)
+              child_present = ->(child, elsy) do
+                meta.has_ast?(child, index, elsy)
               end 
 
               if child.if.args.size > 0
@@ -33,11 +33,11 @@ module Hokusai
 
               if !!visible
                 if child.else_condition_active?
-                  meta.child_delete(index) if child_present.call(child)
+                  meta.child_delete(index) if child_present.call(child, false)
                   child.else_active = 0
                 end
 
-                unless child_present.call(child)
+                unless child_present.call(child, true)
                   portal = Node.new(child, Node.new(child))
                   node = child_block_klass.compile("root", portal)
                   node.add_styles(target.class)
@@ -52,8 +52,9 @@ module Hokusai
                   child_block = NodeMounter.new(node, child_block_klass, [stack], previous_providers: providers).mount(context: context, providers: providers)
 
                   UpdateEntry.new(child_block, block, target).register(context: context, providers: providers)
-                  
+                  pp [meta.has_ast?(child, index, false), "shouldn't be here?"]
                   meta.children!.insert(index, child_block)
+                  pp ["children", meta.children!.size, meta.children!.map(&:class)]
 
                   child_block.public_send(:before_updated) if child_block.respond_to?(:before_updated)
                   child_block.update
@@ -61,7 +62,7 @@ module Hokusai
                 end
               elsif !visible
                 if !child.has_else_condition? || (child.has_else_condition? && !child.else_condition_active?)
-                  if (child_present.call(child))
+                  if (child_present.call(child, true))
                     meta.child_delete(index)
                   end
                 end

data/xmake.lua

@@ -119,6 +119,7 @@ target("hokusai")
   add_links("$(projectdir)/vendor/lib/libtree-sitter.a")
   add_links("$(projectdir)/vendor/lib/libmd4c.a")
   add_files(
+    "ast/src/core/log.c",
     "ast/src/core/hml.c",
     "ast/src/core/ast.c",
     "ast/src/core/style.c",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hokusai-zero
 version: !ruby/object:Gem::Version
-  version: 0.2.6.pre.pinephone6
+  version: 0.2.7
 platform: ruby
 authors:
 - skinnyjames
@@ -103,6 +103,8 @@ files:
 - ast/src/core/hml.h
 - ast/src/core/input.c
 - ast/src/core/input.h
+- ast/src/core/log.c
+- ast/src/core/log.h
 - ast/src/core/style.c
 - ast/src/core/style.h
 - ast/src/core/text.c