@herb-tools/node 0.8.9 → 0.9.0

package/extension/libherb/util/hb_string.h

@@ -4,26 +4,73 @@
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
+#include <string.h>
+#include <strings.h>
 
-#include "hb_arena.h"
+#include "hb_allocator.h"
+#include "hb_foreach.h"
 
 typedef struct HB_STRING_STRUCT {
   char* data;
   uint32_t length;
 } hb_string_T;
 
-hb_string_T hb_string(const char* null_terminated_c_string);
-hb_string_T hb_string_slice(hb_string_T string, uint32_t offset);
-bool hb_string_equals(hb_string_T a, hb_string_T b);
-bool hb_string_equals_case_insensitive(hb_string_T a, hb_string_T b);
-bool hb_string_starts_with(hb_string_T string, hb_string_T expected_prefix);
-bool hb_string_is_empty(hb_string_T string);
-hb_string_T hb_string_truncate(hb_string_T string, uint32_t max_length);
+#define HB_STRING_EMPTY ((hb_string_T) { .data = "", .length = 0 })
+#define HB_STRING_NULL ((hb_string_T) { .data = NULL, .length = 0 })
+
+#define HB_STRING_LITERAL(string) { .data = (char*) (string), .length = (uint32_t) (sizeof(string) - 1) }
+
+#define HB_STRING_LIST(...) { HB_FOR_EACH(HB_STRING_LITERAL, __VA_ARGS__) }
+
+#define hb_string(string)                                                                                              \
+  (__builtin_constant_p(string)                                                                                        \
+     ? ((hb_string_T) { .data = (char*) (string), .length = (uint32_t) __builtin_strlen(string) })                     \
+     : hb_string_from_c_string(string))
+
+hb_string_T hb_string_from_c_string(const char* null_terminated_c_string);
+
+static inline bool hb_string_is_null(hb_string_T string) {
+  return string.data == NULL;
+}
+
+static inline bool hb_string_is_empty(hb_string_T string) {
+  return string.data == NULL || string.length == 0;
+}
+
+static inline hb_string_T hb_string_slice(hb_string_T string, uint32_t offset) {
+  if (string.length < offset) { return HB_STRING_NULL; }
+
+  return (hb_string_T) { .data = string.data + offset, .length = string.length - offset };
+}
 
+static inline bool hb_string_equals(hb_string_T a, hb_string_T b) {
+  if (a.length != b.length) { return false; }
+
+  return strncmp(a.data, b.data, a.length) == 0;
+}
+
+static inline bool hb_string_equals_case_insensitive(hb_string_T a, hb_string_T b) {
+  if (a.length != b.length) { return false; }
+
+  return strncasecmp(a.data, b.data, a.length) == 0;
+}
+
+static inline bool hb_string_starts_with(hb_string_T string, hb_string_T expected_prefix) {
+  if (hb_string_is_empty(string) || hb_string_is_empty(expected_prefix)) { return false; }
+  if (string.length < expected_prefix.length) { return false; }
+
+  return strncmp(string.data, expected_prefix.data, expected_prefix.length) == 0;
+}
+
+hb_string_T hb_string_truncate(hb_string_T string, uint32_t max_length);
 hb_string_T hb_string_range(hb_string_T string, uint32_t from, uint32_t to);
+hb_string_T hb_string_trim_start(hb_string_T string);
+hb_string_T hb_string_trim_end(hb_string_T string);
+hb_string_T hb_string_trim(hb_string_T string);
+bool hb_string_is_blank(hb_string_T string);
+hb_string_T hb_string_copy(hb_string_T string, hb_allocator_T* allocator);
 
 char* hb_string_to_c_string_using_malloc(hb_string_T string);
-
 char* hb_string_to_c_string(hb_arena_T* allocator, hb_string_T string);
 
 #endif

package/extension/libherb/util/string.h

@@ -0,0 +1,11 @@
+#ifndef HERB_UTILS_STRING_H
+#define HERB_UTILS_STRING_H
+
+#include <stdbool.h>
+#include <string.h>
+
+static inline bool string_equals(const char* a, const char* b) {
+  return strcmp(a, b) == 0;
+}
+
+#endif

package/extension/libherb/util.c

@@ -1,4 +1,5 @@
 #include "include/util.h"
+#include "include/util/hb_allocator.h"
 #include "include/util/hb_buffer.h"
 #include "include/util/hb_string.h"
 
@@ -10,10 +11,14 @@ int is_newline(int character) {
   return character == '\n' || character == '\r';
 }
 
-hb_string_T escape_newlines(hb_string_T input) {
+int is_whitespace(int character) {
+  return character == ' ' || character == '\t' || character == '\n' || character == '\r';
+}
+
+hb_string_T escape_newlines(hb_allocator_T* allocator, hb_string_T input) {
   hb_buffer_T buffer;
 
-  hb_buffer_init(&buffer, input.length);
+  hb_buffer_init(&buffer, input.length, allocator);
 
   for (size_t i = 0; i < input.length; ++i) {
     switch (input.data[i]) {
@@ -34,10 +39,10 @@ hb_string_T escape_newlines(hb_string_T input) {
   return hb_string(buffer.value);
 }
 
-static hb_string_T wrap_string(hb_string_T input, char character) {
+static hb_string_T wrap_string(hb_allocator_T* allocator, hb_string_T input, char character) {
   hb_buffer_T buffer;
 
-  hb_buffer_init(&buffer, input.length + 2);
+  hb_buffer_init(&buffer, input.length + 2, allocator);
 
   hb_buffer_append_char(&buffer, character);
   hb_buffer_append_string(&buffer, input);
@@ -46,15 +51,20 @@ static hb_string_T wrap_string(hb_string_T input, char character) {
   return hb_string(buffer.value);
 }
 
-hb_string_T quoted_string(hb_string_T input) {
-  return wrap_string(input, '"');
+hb_string_T quoted_string(hb_allocator_T* allocator, hb_string_T input) {
+  return wrap_string(allocator, input, '"');
 }
 
-char* herb_strdup(const char* s) {
-  size_t len = strlen(s) + 1;
-  char* copy = malloc(len);
+char* convert_underscores_to_dashes(const char* input) {
+  if (!input) { return NULL; }
 
-  if (copy) { memcpy(copy, s, len); }
+  size_t len = strlen(input);
+  char* output = calloc(len + 1, sizeof(char));
+  if (!output) { return NULL; }
+
+  for (size_t i = 0; i < len; i++) {
+    output[i] = (input[i] == '_') ? '-' : input[i];
+  }
 
-  return copy;
+  return output;
 }

package/extension/libherb/util.h

@@ -5,10 +5,13 @@
 #include <stdbool.h>
 #include <stdlib.h>
 
+struct hb_allocator;
+
 int is_newline(int character);
+int is_whitespace(int character);
+hb_string_T escape_newlines(struct hb_allocator* allocator, hb_string_T input);
+hb_string_T quoted_string(struct hb_allocator* allocator, hb_string_T input);
 
-hb_string_T escape_newlines(hb_string_T input);
-hb_string_T quoted_string(hb_string_T input);
-char* herb_strdup(const char* s);
+char* convert_underscores_to_dashes(const char* input);
 
 #endif

package/extension/libherb/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.8.9"
+#define HERB_VERSION "0.9.0"
 
 #endif

package/extension/libherb/visitor.c

@@ -1,5 +1,5 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.9/templates/src/visitor.c.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.9.0/templates/src/visitor.c.erb
 
 #include <stdio.h>
 
@@ -42,6 +42,15 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
 
     } break;
 
+    case AST_HTML_CONDITIONAL_OPEN_TAG_NODE: {
+      const AST_HTML_CONDITIONAL_OPEN_TAG_NODE_T* html_conditional_open_tag_node = ((const AST_HTML_CONDITIONAL_OPEN_TAG_NODE_T *) node);
+
+      if (html_conditional_open_tag_node->conditional != NULL) {
+        herb_visit_node((AST_NODE_T *) html_conditional_open_tag_node->conditional, visitor, data);
+      }
+
+    } break;
+
     case AST_HTML_CLOSE_TAG_NODE: {
       const AST_HTML_CLOSE_TAG_NODE_T* html_close_tag_node = ((const AST_HTML_CLOSE_TAG_NODE_T *) node);
 
@@ -72,6 +81,33 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
 
     } break;
 
+    case AST_HTML_CONDITIONAL_ELEMENT_NODE: {
+      const AST_HTML_CONDITIONAL_ELEMENT_NODE_T* html_conditional_element_node = ((const AST_HTML_CONDITIONAL_ELEMENT_NODE_T *) node);
+
+      if (html_conditional_element_node->open_conditional != NULL) {
+        herb_visit_node((AST_NODE_T *) html_conditional_element_node->open_conditional, visitor, data);
+      }
+
+      if (html_conditional_element_node->open_tag != NULL) {
+        herb_visit_node((AST_NODE_T *) html_conditional_element_node->open_tag, visitor, data);
+      }
+
+      if (html_conditional_element_node->body != NULL) {
+        for (size_t index = 0; index < hb_array_size(html_conditional_element_node->body); index++) {
+          herb_visit_node(hb_array_get(html_conditional_element_node->body, index), visitor, data);
+        }
+      }
+
+      if (html_conditional_element_node->close_tag != NULL) {
+        herb_visit_node((AST_NODE_T *) html_conditional_element_node->close_tag, visitor, data);
+      }
+
+      if (html_conditional_element_node->close_conditional != NULL) {
+        herb_visit_node((AST_NODE_T *) html_conditional_element_node->close_conditional, visitor, data);
+      }
+
+    } break;
+
     case AST_HTML_ATTRIBUTE_VALUE_NODE: {
       const AST_HTML_ATTRIBUTE_VALUE_NODE_T* html_attribute_value_node = ((const AST_HTML_ATTRIBUTE_VALUE_NODE_T *) node);
 
@@ -107,6 +143,17 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
 
     } break;
 
+    case AST_ERB_OPEN_TAG_NODE: {
+      const AST_ERB_OPEN_TAG_NODE_T* erb_open_tag_node = ((const AST_ERB_OPEN_TAG_NODE_T *) node);
+
+      if (erb_open_tag_node->children != NULL) {
+        for (size_t index = 0; index < hb_array_size(erb_open_tag_node->children); index++) {
+          herb_visit_node(hb_array_get(erb_open_tag_node->children, index), visitor, data);
+        }
+      }
+
+    } break;
+
     case AST_HTML_COMMENT_NODE: {
       const AST_HTML_COMMENT_NODE_T* html_comment_node = ((const AST_HTML_COMMENT_NODE_T *) node);