@herb-tools/node 0.1.1 → 0.2.0

package/extension/libherb/include/buffer.h

@@ -13,8 +13,11 @@ typedef struct BUFFER_STRUCT {
 bool buffer_init(buffer_T* buffer);
 buffer_T buffer_new(void);
 
-bool buffer_increase_capacity(buffer_T* buffer, size_t required_length);
-bool buffer_reserve(buffer_T* buffer, size_t min_capacity);
+bool buffer_increase_capacity(buffer_T* buffer, size_t additional_capacity);
+bool buffer_has_capacity(buffer_T* buffer, size_t required_length);
+bool buffer_expand_capacity(buffer_T* buffer);
+bool buffer_expand_if_needed(buffer_T* buffer, size_t required_length);
+bool buffer_resize(buffer_T* buffer, size_t new_capacity);
 
 void buffer_append(buffer_T* buffer, const char* text);
 void buffer_append_with_length(buffer_T* buffer, const char* text, size_t length);

package/extension/libherb/include/lexer_peek_helpers.h

@@ -1,5 +1,5 @@
-#ifndef HERB_LEXER_PEEK_H
-#define HERB_LEXER_PEEK_H
+#ifndef HERB_LEXER_PEEK_HELPERS_H
+#define HERB_LEXER_PEEK_HELPERS_H
 
 #include "lexer_struct.h"
 

package/extension/libherb/include/macros.h

@@ -1,9 +1,9 @@
 #ifndef HERB_MACROS_H
 #define HERB_MACROS_H
 
-#define MAX(a, b) (a) > (b) ? (a) : (b)
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
 
-#define MIN(a, b) (a) < (b) ? (a) : (b)
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
 
 #define unlikely(x) __builtin_expect(!!(x), 0)
 

package/extension/libherb/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.1.1"
+#define HERB_VERSION "0.2.0"
 
 #endif

package/extension/libherb/io.h

@@ -0,0 +1,9 @@
+#ifndef HERB_IO_H
+#define HERB_IO_H
+
+#include <stdio.h>
+#include <stdlib.h>
+
+char* herb_read_file(const char* filename);
+
+#endif

package/extension/libherb/json.h

@@ -0,0 +1,28 @@
+#ifndef HERB_JSON_H
+#define HERB_JSON_H
+
+#include "buffer.h"
+
+void json_start_root_object(buffer_T* json);
+void json_start_root_array(buffer_T* json);
+
+void json_escape_string(buffer_T* json, const char* string);
+
+void json_add_string(buffer_T* json, const char* key, const char* value);
+void json_add_int(buffer_T* json, const char* key, int value);
+void json_add_size_t(buffer_T* json, const char* key, size_t value);
+void json_add_double(buffer_T* json, const char* key, double value);
+void json_add_bool(buffer_T* json, const char* key, int value);
+
+void json_add_raw_string(buffer_T* json, const char* string);
+
+void json_start_object(buffer_T* json, const char* key);
+void json_end_object(buffer_T* json);
+
+void json_start_array(buffer_T* json, const char* key);
+void json_end_array(buffer_T* json);
+
+void json_double_to_string(double value, char* buffer);
+void json_int_to_string(int value, char* buffer);
+
+#endif

package/extension/libherb/lexer.c

@@ -72,7 +72,7 @@ token_T* lexer_error(lexer_T* lexer, const char* message) {
     lexer->current_column
   );
 
-  return token_init(herb_strdup(error_message), TOKEN_ERROR, lexer);
+  return token_init(error_message, TOKEN_ERROR, lexer);
 }
 
 static void lexer_advance(lexer_T* lexer) {

package/extension/libherb/lexer.h

@@ -0,0 +1,13 @@
+#ifndef HERB_LEXER_H
+#define HERB_LEXER_H
+
+#include "lexer_struct.h"
+#include "token_struct.h"
+
+lexer_T* lexer_init(const char* source);
+token_T* lexer_next_token(lexer_T* lexer);
+token_T* lexer_error(lexer_T* lexer, const char* message);
+
+void lexer_free(lexer_T* lexer);
+
+#endif

package/extension/libherb/lexer_peek_helpers.h

@@ -0,0 +1,23 @@
+#ifndef HERB_LEXER_PEEK_HELPERS_H
+#define HERB_LEXER_PEEK_HELPERS_H
+
+#include "lexer_struct.h"
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+char lexer_peek(const lexer_T* lexer, int offset);
+bool lexer_peek_for_doctype(const lexer_T* lexer, int offset);
+
+bool lexer_peek_for_html_comment_start(const lexer_T* lexer, int offset);
+bool lexer_peek_for_html_comment_end(const lexer_T* lexer, int offset);
+
+bool lexer_peek_erb_close_tag(const lexer_T* lexer, int offset);
+bool lexer_peek_erb_dash_close_tag(const lexer_T* lexer, int offset);
+bool lexer_peek_erb_percent_close_tag(const lexer_T* lexer, int offset);
+bool lexer_peek_erb_end(const lexer_T* lexer, int offset);
+
+char lexer_backtrack(const lexer_T* lexer, int offset);
+
+#endif

package/extension/libherb/lexer_struct.h

@@ -0,0 +1,32 @@
+#ifndef HERB_LEXER_STRUCT_H
+#define HERB_LEXER_STRUCT_H
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+typedef enum {
+  STATE_DATA,
+  STATE_ERB_CONTENT,
+  STATE_ERB_CLOSE,
+} lexer_state_T;
+
+typedef struct LEXER_STRUCT {
+  const char* source;
+  size_t source_length;
+
+  size_t current_line;
+  size_t current_column;
+  size_t current_position;
+
+  size_t previous_line;
+  size_t previous_column;
+  size_t previous_position;
+
+  char current_character;
+  lexer_state_T state;
+  size_t stall_counter;
+  size_t last_position;
+  bool stalled;
+} lexer_T;
+
+#endif

package/extension/libherb/location.h

@@ -0,0 +1,25 @@
+#ifndef HERB_LOCATION_H
+#define HERB_LOCATION_H
+
+#include <stdlib.h>
+
+#include "position.h"
+
+typedef struct LOCATION_STRUCT {
+  position_T* start;
+  position_T* end;
+} location_T;
+
+location_T* location_init(position_T* start, position_T* end);
+location_T* location_from(size_t start_line, size_t start_column, size_t end_line, size_t end_column);
+
+position_T* location_start(location_T* location);
+position_T* location_end_(location_T* location);
+
+size_t location_sizeof(void);
+
+location_T* location_copy(location_T* location);
+
+void location_free(location_T* location);
+
+#endif

package/extension/libherb/macros.h

@@ -0,0 +1,10 @@
+#ifndef HERB_MACROS_H
+#define HERB_MACROS_H
+
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+
+#define unlikely(x) __builtin_expect(!!(x), 0)
+
+#endif

package/extension/libherb/memory.h

@@ -0,0 +1,12 @@
+#ifndef HERB_MEMORY_H
+#define HERB_MEMORY_H
+
+#include <stddef.h>
+
+void* safe_malloc(size_t size);
+void* safe_realloc(void* pointer, size_t new_size);
+
+void* nullable_safe_malloc(size_t size);
+void* nullable_safe_realloc(void* pointer, size_t new_size);
+
+#endif

package/extension/libherb/parser.c

@@ -124,10 +124,9 @@ static AST_HTML_DOCTYPE_NODE_T* parser_parse_html_doctype(parser_T* parser) {
   return doctype;
 }
 
-static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser) {
+static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser, array_T* document_errors) {
   position_T* start = position_copy(parser->current_token->location->start);
 
-  array_T* errors = array_init(8);
   buffer_T content = buffer_new();
 
   while (token_is_none_of(
@@ -142,16 +141,18 @@ static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser) {
     if (token_is(parser, TOKEN_ERROR)) {
       buffer_free(&content);
 
-      token_T* token = parser_consume_expected(parser, TOKEN_ERROR, errors);
+      token_T* token = parser_consume_expected(parser, TOKEN_ERROR, document_errors);
       append_unexpected_error(
         "Token Error",
         "not TOKEN_ERROR",
         token->value,
         token->location->start,
         token->location->end,
-        errors
+        document_errors
       );
+
       token_free(token);
+      position_free(start);
 
       return NULL;
     }
@@ -161,6 +162,8 @@ static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser) {
     token_free(token);
   }
 
+  array_T* errors = array_init(8);
+
   if (buffer_length(&content) > 0) {
     AST_HTML_TEXT_NODE_T* text_node =
       ast_html_text_node_init(buffer_value(&content), start, parser->current_token->location->start, errors);
@@ -265,7 +268,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser
       false,
       erb_node->base.location->start,
       erb_node->base.location->end,
-      NULL
+      errors
     );
   }
 
@@ -284,7 +287,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser
       false,
       literal->base.location->start,
       literal->base.location->end,
-      NULL
+      errors
     );
   }
 
@@ -400,6 +403,9 @@ static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
       token_free(tag_start);
       token_free(tag_name);
 
+      array_free(&children);
+      array_free(&errors);
+
       return NULL;
     }
 
@@ -617,7 +623,7 @@ static void parser_parse_in_data_state(parser_T* parser, array_T* children, arra
           TOKEN_UNDERSCORE,
           TOKEN_WHITESPACE
         )) {
-      array_append(children, parser_parse_text_content(parser));
+      array_append(children, parser_parse_text_content(parser, errors));
       continue;
     }
 
@@ -650,6 +656,10 @@ static void parser_parse_stray_closing_tags(parser_T* parser, array_T* children,
   while (token_is_not(parser, TOKEN_EOF)) {
     if (token_is_not(parser, TOKEN_HTML_TAG_START_CLOSE)) {
       parser_append_unexpected_token_error(parser, TOKEN_HTML_TAG_START_CLOSE, errors);
+
+      token_T* unexpected = parser_advance(parser);
+      token_free(unexpected);
+
       continue;
     }
 

package/extension/libherb/parser.h

@@ -0,0 +1,22 @@
+#ifndef HERB_PARSER_H
+#define HERB_PARSER_H
+
+#include "array.h"
+#include "ast_node.h"
+#include "lexer.h"
+
+typedef struct PARSER_STRUCT {
+  lexer_T* lexer;
+  token_T* current_token;
+  array_T* open_tags_stack;
+} parser_T;
+
+parser_T* parser_init(lexer_T* lexer);
+
+AST_DOCUMENT_NODE_T* parser_parse(parser_T* parser);
+
+size_t parser_sizeof(void);
+
+void parser_free(parser_T* parser);
+
+#endif

package/extension/libherb/parser_helpers.h

@@ -0,0 +1,33 @@
+#ifndef HERB_PARSER_HELPERS_H
+#define HERB_PARSER_HELPERS_H
+
+#include "array.h"
+#include "ast_nodes.h"
+#include "buffer.h"
+#include "errors.h"
+#include "parser.h"
+#include "token.h"
+
+void parser_push_open_tag(const parser_T* parser, token_T* tag_name);
+bool parser_check_matching_tag(const parser_T* parser, const char* tag_name);
+token_T* parser_pop_open_tag(const parser_T* parser);
+
+void parser_append_unexpected_error(parser_T* parser, const char* description, const char* expected, array_T* errors);
+void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, array_T* errors);
+
+void parser_append_literal_node_from_buffer(
+  const parser_T* parser, buffer_T* buffer, array_T* children, position_T* start
+);
+
+bool parser_in_svg_context(const parser_T* parser);
+
+token_T* parser_advance(parser_T* parser);
+token_T* parser_consume_if_present(parser_T* parser, token_type_T type);
+token_T* parser_consume_expected(parser_T* parser, token_type_T type, array_T* array);
+
+AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
+  AST_HTML_OPEN_TAG_NODE_T* open_tag, array_T* body, array_T* errors
+);
+void parser_handle_mismatched_tags(const parser_T* parser, const AST_HTML_CLOSE_TAG_NODE_T* close_tag, array_T* errors);
+
+#endif

package/extension/libherb/position.h

@@ -0,0 +1,22 @@
+#ifndef HERB_POSITION_H
+#define HERB_POSITION_H
+
+#include <stdlib.h>
+
+typedef struct POSITION_STRUCT {
+  size_t line;
+  size_t column;
+} position_T;
+
+position_T* position_init(size_t line, size_t column);
+
+size_t position_line(const position_T* position);
+size_t position_column(const position_T* position);
+
+size_t position_sizeof(void);
+
+position_T* position_copy(position_T* position);
+
+void position_free(position_T* position);
+
+#endif

package/extension/libherb/pretty_print.h

@@ -0,0 +1,53 @@
+#ifndef HERB_PRETTY_PRINT_H
+#define HERB_PRETTY_PRINT_H
+
+#include "analyzed_ruby.h"
+#include "ast_nodes.h"
+#include "buffer.h"
+#include "location.h"
+
+#include <stdbool.h>
+
+void pretty_print_indent(buffer_T* buffer, size_t indent);
+void pretty_print_newline(size_t indent, size_t relative_indent, buffer_T* buffer);
+void pretty_print_label(const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer);
+
+void pretty_print_position_property(
+  position_T* position, const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_location(location_T* location, buffer_T* buffer);
+
+void pretty_print_property(
+  const char* name, const char* value, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_size_t_property(
+  size_t value, const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_string_property(
+  const char* string, const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_quoted_property(
+  const char* name, const char* value, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_boolean_property(
+  const char* name, bool value, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_token_property(
+  token_T* token, const char* name, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_array(
+  const char* name, array_T* array, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer
+);
+
+void pretty_print_errors(AST_NODE_T* node, size_t indent, size_t relative_indent, bool last_property, buffer_T* buffer);
+
+void pretty_print_analyed_ruby(analyzed_ruby_T* analyzed, const char* source);
+
+#endif

package/extension/libherb/prism_helpers.h

@@ -0,0 +1,18 @@
+#ifndef HERB_PRISM_HELPERS_H
+#define HERB_PRISM_HELPERS_H
+
+#include "ast_nodes.h"
+#include "errors.h"
+#include "position.h"
+
+#include <prism.h>
+
+const char* pm_error_level_to_string(pm_error_level_t level);
+
+RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error(
+  const pm_diagnostic_t* error, const AST_NODE_T* node, const char* source, pm_parser_t* parser
+);
+
+position_T* position_from_source_with_offset(const char* source, size_t offset);
+
+#endif

package/extension/libherb/range.h

@@ -0,0 +1,23 @@
+#ifndef HERB_RANGE_H
+#define HERB_RANGE_H
+
+#include <stdlib.h>
+
+typedef struct RANGE_STRUCT {
+  size_t from;
+  size_t to;
+} range_T;
+
+range_T* range_init(size_t from, size_t to);
+
+size_t range_from(const range_T* range);
+size_t range_to(const range_T* range);
+size_t range_length(range_T* range);
+
+range_T* range_copy(range_T* range);
+
+size_t range_sizeof(void);
+
+void range_free(range_T* range);
+
+#endif

package/extension/libherb/ruby_parser.h

@@ -0,0 +1,6 @@
+#ifndef HERB_RUBY_PARSER_H
+#define HERB_RUBY_PARSER_H
+
+void herb_parse_ruby_to_stdout(char* source);
+
+#endif

package/extension/libherb/token.c

@@ -72,7 +72,7 @@ const char* token_type_to_string(const token_type_T type) {
     case TOKEN_EOF: return "TOKEN_EOF";
   }
 
-  return "Unkown token_type_T";
+  return "Unknown token_type_T";
 }
 
 char* token_to_string(const token_T* token) {

package/extension/libherb/token.h

@@ -0,0 +1,25 @@
+#ifndef HERB_TOKEN_H
+#define HERB_TOKEN_H
+
+#include "lexer_struct.h"
+#include "position.h"
+#include "token_struct.h"
+
+token_T* token_init(const char* value, token_type_T type, lexer_T* lexer);
+char* token_to_string(const token_T* token);
+char* token_to_json(const token_T* token);
+const char* token_type_to_string(token_type_T type);
+
+char* token_value(const token_T* token);
+int token_type(const token_T* token);
+
+position_T* token_start_position(token_T* token);
+position_T* token_end_position(token_T* token);
+
+size_t token_sizeof(void);
+
+token_T* token_copy(token_T* token);
+
+void token_free(token_T* token);
+
+#endif

package/extension/libherb/token_matchers.h

@@ -0,0 +1,21 @@
+#ifndef HERB_TOKEN_MATCHERS_H
+#define HERB_TOKEN_MATCHERS_H
+
+#include "parser.h"
+#include "token.h"
+
+#include <stdarg.h>
+#include <stdbool.h>
+
+// This "TOKEN" is used to terminate the va_list arguments in the token_matches_any function
+#define TOKEN_SENTINEL 99999999
+
+bool token_is(parser_T* parser, token_type_T expected_type);
+bool token_is_not(parser_T* parser, token_type_T type);
+
+bool token_matches_any(token_type_T current_token, token_type_T first_token, ...);
+
+#define token_is_any_of(parser, ...) (token_matches_any((parser)->current_token->type, __VA_ARGS__, TOKEN_SENTINEL))
+#define token_is_none_of(parser, ...) (!token_matches_any((parser)->current_token->type, __VA_ARGS__, TOKEN_SENTINEL))
+
+#endif

package/extension/libherb/token_struct.h

@@ -0,0 +1,51 @@
+#ifndef HERB_TOKEN_STRUCT_H
+#define HERB_TOKEN_STRUCT_H
+
+#include "location.h"
+#include "range.h"
+
+typedef enum {
+  TOKEN_WHITESPACE, // ' '
+  TOKEN_NBSP,       // \xC2\xA0
+  TOKEN_NEWLINE,    // \n
+  TOKEN_IDENTIFIER,
+
+  TOKEN_HTML_DOCTYPE, // <!DOCTYPE, <!doctype, <!DoCtYpE, <!dOcTyPe
+
+  TOKEN_HTML_TAG_START,       // <
+  TOKEN_HTML_TAG_START_CLOSE, // </
+  TOKEN_HTML_TAG_END,         // >
+  TOKEN_HTML_TAG_SELF_CLOSE,  // />
+
+  TOKEN_HTML_COMMENT_START, // <!--
+  TOKEN_HTML_COMMENT_END,   // -->
+
+  TOKEN_ERB_START,   // <%, <%=, <%#, <%-, <%==, <%%
+  TOKEN_ERB_CONTENT, // Ruby Code
+  TOKEN_ERB_END,     // %>, -%>, %%>
+
+  TOKEN_LT,          // <
+  TOKEN_SLASH,       // /
+  TOKEN_EQUALS,      // =
+  TOKEN_QUOTE,       // ", '
+  TOKEN_DASH,        // -
+  TOKEN_UNDERSCORE,  // _
+  TOKEN_EXCLAMATION, // !
+  TOKEN_SEMICOLON,   // ;
+  TOKEN_COLON,       // :
+  TOKEN_PERCENT,     // %
+  TOKEN_AMPERSAND,   // &
+
+  TOKEN_CHARACTER,
+  TOKEN_ERROR,
+  TOKEN_EOF,
+} token_type_T;
+
+typedef struct TOKEN_STRUCT {
+  char* value;
+  range_T* range;
+  location_T* location;
+  token_type_T type;
+} token_T;
+
+#endif

package/extension/libherb/util.c

@@ -43,13 +43,15 @@ int count_newlines(const char* string) {
 }
 
 char* replace_char(char* string, const char find, const char replace) {
+  char* original_string = string;
+
   while (*string != '\0') {
     if (*string == find) { *string = replace; }
 
     string++;
   }
 
-  return string;
+  return original_string;
 }
 
 char* escape_newlines(const char* input) {

package/extension/libherb/util.h

@@ -0,0 +1,25 @@
+#ifndef HERB_UTIL_H
+#define HERB_UTIL_H
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+int is_whitespace(int character);
+int is_newline(int character);
+
+int count_in_string(const char* string, char character);
+int count_newlines(const char* string);
+
+char* replace_char(char* string, char find, char replace);
+char* escape_newlines(const char* input);
+char* quoted_string(const char* input);
+char* wrap_string(const char* input, char character);
+
+bool string_blank(const char* input);
+bool string_present(const char* input);
+
+char* herb_strdup(const char* s);
+
+char* size_t_to_string(size_t value);
+
+#endif

package/extension/libherb/version.h

@@ -0,0 +1,6 @@
+#ifndef HERB_VERSION_H
+#define HERB_VERSION_H
+
+#define HERB_VERSION "0.2.0"
+
+#endif