herb 0.1.0-arm-linux-gnu

data/src/extract.c

@@ -0,0 +1,110 @@
+#include "include/array.h"
+#include "include/buffer.h"
+#include "include/herb.h"
+#include "include/io.h"
+#include "include/lexer.h"
+
+#include <stdlib.h>
+
+void herb_extract_ruby_to_buffer_with_semicolons(const char* source, buffer_T* output) {
+  const array_T* tokens = herb_lex(source);
+
+  for (size_t i = 0; i < array_size(tokens); i++) {
+    const token_T* token = array_get(tokens, i);
+
+    switch (token->type) {
+      case TOKEN_NEWLINE:
+      case TOKEN_ERB_CONTENT: buffer_append(output, token->value); break;
+      case TOKEN_ERB_END: {
+        buffer_append_char(output, ';');
+        buffer_append_whitespace(output, range_length(token->range) - 1);
+        break;
+      }
+
+      case TOKEN_ERB_START: {
+        if (strcmp(token->value, "<%#") == 0) {
+          buffer_append_char(output, ' ');
+          buffer_append_char(output, ' ');
+          buffer_append_char(output, '#');
+        } else {
+          buffer_append_whitespace(output, range_length(token->range));
+        }
+
+        break;
+      }
+
+      default: buffer_append_whitespace(output, range_length(token->range));
+    }
+  }
+}
+
+void herb_extract_ruby_to_buffer(const char* source, buffer_T* output) {
+  const array_T* tokens = herb_lex(source);
+
+  for (size_t i = 0; i < array_size(tokens); i++) {
+    const token_T* token = array_get(tokens, i);
+
+    switch (token->type) {
+      case TOKEN_NEWLINE:
+      case TOKEN_ERB_CONTENT: buffer_append(output, token->value); break;
+      case TOKEN_ERB_START: {
+        if (strcmp(token->value, "<%#") == 0) {
+          buffer_append_char(output, ' ');
+          buffer_append_char(output, ' ');
+          buffer_append_char(output, '#');
+        } else {
+          buffer_append_whitespace(output, range_length(token->range));
+        }
+
+        break;
+      }
+
+      default: buffer_append_whitespace(output, range_length(token->range));
+    }
+  }
+}
+
+void herb_extract_html_to_buffer(const char* source, buffer_T* output) {
+  const array_T* tokens = herb_lex(source);
+
+  for (size_t i = 0; i < array_size(tokens); i++) {
+    const token_T* token = array_get(tokens, i);
+
+    switch (token->type) {
+      case TOKEN_ERB_START:
+      case TOKEN_ERB_CONTENT:
+      case TOKEN_ERB_END: buffer_append_whitespace(output, range_length(token->range)); break;
+      default: buffer_append(output, token->value);
+    }
+  }
+}
+
+char* herb_extract_ruby_with_semicolons(const char* source) {
+  buffer_T output;
+  buffer_init(&output);
+
+  herb_extract_ruby_to_buffer_with_semicolons(source, &output);
+
+  return output.value;
+}
+
+char* herb_extract(const char* source, const herb_extract_language_T language) {
+  buffer_T output;
+  buffer_init(&output);
+
+  switch (language) {
+    case HERB_EXTRACT_LANGUAGE_RUBY: herb_extract_ruby_to_buffer(source, &output); break;
+    case HERB_EXTRACT_LANGUAGE_HTML: herb_extract_html_to_buffer(source, &output); break;
+  }
+
+  return output.value;
+}
+
+char* herb_extract_from_file(const char* path, const herb_extract_language_T language) {
+  char* source = herb_read_file(path);
+  char* output = herb_extract(source, language);
+
+  free(source);
+
+  return output;
+}

data/src/herb.c

@@ -0,0 +1,103 @@
+#include "include/herb.h"
+#include "include/array.h"
+#include "include/buffer.h"
+#include "include/io.h"
+#include "include/json.h"
+#include "include/lexer.h"
+#include "include/parser.h"
+#include "include/token.h"
+#include "include/version.h"
+
+#include <prism.h>
+#include <stdlib.h>
+
+array_T* herb_lex(const char* source) {
+  lexer_T* lexer = lexer_init(source);
+  token_T* token = NULL;
+  array_T* tokens = array_init(128);
+
+  while ((token = lexer_next_token(lexer))->type != TOKEN_EOF) {
+    array_append(tokens, token);
+  }
+
+  array_append(tokens, token);
+
+  lexer_free(lexer);
+
+  return tokens;
+}
+
+AST_DOCUMENT_NODE_T* herb_parse(const char* source) {
+  lexer_T* lexer = lexer_init(source);
+  parser_T* parser = parser_init(lexer);
+
+  AST_DOCUMENT_NODE_T* document = parser_parse(parser);
+
+  parser_free(parser);
+
+  return document;
+}
+
+array_T* herb_lex_file(const char* path) {
+  char* source = herb_read_file(path);
+  array_T* tokens = herb_lex(source);
+
+  free(source);
+
+  return tokens;
+}
+
+void herb_lex_to_buffer(const char* source, buffer_T* output) {
+  array_T* tokens = herb_lex(source);
+
+  for (size_t i = 0; i < array_size(tokens); i++) {
+    token_T* token = array_get(tokens, i);
+
+    char* type = token_to_string(token);
+    buffer_append(output, type);
+    free(type);
+
+    buffer_append(output, "\n");
+  }
+
+  herb_free_tokens(&tokens);
+}
+
+void herb_lex_json_to_buffer(const char* source, buffer_T* output) {
+  array_T* tokens = herb_lex(source);
+
+  buffer_T json = buffer_new();
+  json_start_root_array(&json);
+
+  for (size_t i = 0; i < array_size(tokens); i++) {
+    token_T* token = array_get(tokens, i);
+    char* token_json = token_to_json(token);
+    json_add_raw_string(&json, token_json);
+    free(token_json);
+  }
+
+  json_end_array(&json);
+  buffer_concat(output, &json);
+
+  buffer_free(&json);
+  herb_free_tokens(&tokens);
+}
+
+void herb_free_tokens(array_T** tokens) {
+  if (!tokens || !*tokens) { return; }
+
+  for (size_t i = 0; i < array_size(*tokens); i++) {
+    token_T* token = array_get(*tokens, i);
+    if (token) { token_free(token); }
+  }
+
+  array_free(tokens);
+}
+
+const char* herb_version(void) {
+  return HERB_VERSION;
+}
+
+const char* herb_prism_version(void) {
+  return PRISM_VERSION;
+}

data/src/html_util.c

@@ -0,0 +1,143 @@
+#include "include/html_util.h"
+#include "include/util.h"
+
+#include <ctype.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+
+// https://developer.mozilla.org/en-US/docs/Glossary/Void_element
+bool is_void_element(const char* tag_name) {
+  if (tag_name == NULL) { return false; }
+
+  const char* void_tags[] = {
+    "area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr",
+  };
+
+  for (size_t i = 0; i < sizeof(void_tags) / sizeof(char*); i++) {
+    if (strcasecmp(tag_name, void_tags[i]) == 0) { return true; }
+  }
+
+  return false;
+}
+
+bool is_html4_void_element(const char* tag_name) {
+  if (tag_name == NULL) { return false; }
+
+  const char* html4_void_tags[] = {
+    "basefont", "bgsound", "command", "frame", "image", "keygen",
+  };
+
+  for (size_t i = 0; i < sizeof(html4_void_tags) / sizeof(char*); i++) {
+    if (strcasecmp(tag_name, html4_void_tags[i]) == 0) { return true; }
+  }
+
+  return false;
+}
+
+/**
+ * @brief Creates an opening HTML tag string like "<tag_name>"
+ *
+ * @param tag_name The name of the HTML tag to be enclosed in a opening tag
+ * @return A newly allocated string containing the opening tag, or NULL if memory allocation fails
+ * @note The caller is responsible for freeing the returned string
+ *
+ * Example:
+ * @code
+ * char* tag = html_opening_tag_string("div");
+ * if (tag) {
+ *   printf("%s\n", tag); // Prints: <div>
+ *   free(tag);
+ * }
+ * @endcode
+ */
+char* html_opening_tag_string(const char* tag_name) {
+  if (tag_name == NULL) { return herb_strdup("<>"); }
+
+  size_t length = strlen(tag_name);
+  char* result = (char*) malloc(length + 3); // +3 for '<', '>', and '\0'
+
+  if (result == NULL) { return NULL; }
+
+  result[0] = '<';
+
+  memcpy(result + 1, tag_name, length);
+
+  result[length + 1] = '>';
+  result[length + 2] = '\0';
+
+  return result;
+}
+
+/**
+ * @brief Creates a closing HTML tag string like "</tag_name>"
+ *
+ * @param tag_name The name of the HTML tag to be enclosed in a closing tag
+ * @return A newly allocated string containing the closing tag, or NULL if memory allocation fails
+ * @note The caller is responsible for freeing the returned string
+ *
+ * Example:
+ * @code
+ * char* tag = html_closing_tag_string("div");
+ * if (tag) {
+ *   printf("%s\n", tag); // Prints: </div>
+ *   free(tag);
+ * }
+ * @endcode
+ */
+char* html_closing_tag_string(const char* tag_name) {
+  if (tag_name == NULL) { return herb_strdup("</>"); }
+
+  size_t length = strlen(tag_name);
+  char* result = (char*) malloc(length + 4); // +4 for '<', '/', '>', and '\0'
+
+  if (result == NULL) { return NULL; }
+
+  result[0] = '<';
+  result[1] = '/';
+
+  memcpy(result + 2, tag_name, length);
+
+  result[length + 2] = '>';
+  result[length + 3] = '\0';
+
+  return result;
+}
+
+/**
+ * @brief Creates a self-closing HTML tag string like "<tag_name />"
+ *
+ * @param tag_name The name of the HTML tag to be enclosed in a self-closing tag
+ * @return A newly allocated string containing the self-closing tag, or NULL if memory allocation fails
+ * @note The caller is responsible for freeing the returned string
+ *
+ * Example:
+ * @code
+ * char* tag = html_self_closing_tag_string("br");
+ * if (tag) {
+ *   printf("%s\n", tag); // Prints: <br />
+ *   free(tag);
+ * }
+ * @endcode
+ */
+char* html_self_closing_tag_string(const char* tag_name) {
+  if (tag_name == NULL) { return herb_strdup("< />"); }
+
+  size_t length = strlen(tag_name);
+  char* result = (char*) malloc(length + 5); // +5 for '<', ' ', '/', '>', and '\0'
+
+  if (result == NULL) { return NULL; }
+
+  result[0] = '<';
+
+  memcpy(result + 1, tag_name, length);
+
+  result[length + 1] = ' ';
+  result[length + 2] = '/';
+  result[length + 3] = '>';
+  result[length + 4] = '\0';
+
+  return result;
+}

data/src/include/analyze.h

@@ -0,0 +1,36 @@
+#ifndef HERB_ANALYZE_H
+#define HERB_ANALYZE_H
+
+#include "analyzed_ruby.h"
+#include "array.h"
+#include "ast_nodes.h"
+
+typedef struct ANALYZE_RUBY_CONTEXT_STRUCT {
+  AST_DOCUMENT_NODE_T* document;
+  AST_NODE_T* parent;
+  array_T* ruby_context_stack;
+} analyze_ruby_context_T;
+
+typedef enum {
+  CONTROL_TYPE_IF,
+  CONTROL_TYPE_ELSIF,
+  CONTROL_TYPE_ELSE,
+  CONTROL_TYPE_END,
+  CONTROL_TYPE_CASE,
+  CONTROL_TYPE_WHEN,
+  CONTROL_TYPE_BEGIN,
+  CONTROL_TYPE_RESCUE,
+  CONTROL_TYPE_ENSURE,
+  CONTROL_TYPE_UNLESS,
+  CONTROL_TYPE_WHILE,
+  CONTROL_TYPE_UNTIL,
+  CONTROL_TYPE_FOR,
+  CONTROL_TYPE_BLOCK,
+  CONTROL_TYPE_BLOCK_CLOSE,
+  CONTROL_TYPE_UNKNOWN
+} control_type_t;
+
+void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source);
+void herb_analyze_parse_tree(AST_DOCUMENT_NODE_T* document, const char* source);
+
+#endif

data/src/include/analyze_helpers.h

@@ -0,0 +1,43 @@
+#ifndef HERB_ANALYZE_HELPERS_H
+#define HERB_ANALYZE_HELPERS_H
+
+#include <prism.h>
+#include <stdbool.h>
+
+#include "analyzed_ruby.h"
+
+bool has_if_node(analyzed_ruby_T* analyzed);
+bool has_elsif_node(analyzed_ruby_T* analyzed);
+bool has_else_node(analyzed_ruby_T* analyzed);
+bool has_end(analyzed_ruby_T* analyzed);
+bool has_block_node(analyzed_ruby_T* analyzed);
+bool has_block_closing(analyzed_ruby_T* analyzed);
+bool has_case_node(analyzed_ruby_T* analyzed);
+bool has_when_node(analyzed_ruby_T* analyzed);
+bool has_for_node(analyzed_ruby_T* analyzed);
+bool has_while_node(analyzed_ruby_T* analyzed);
+bool has_until_node(analyzed_ruby_T* analyzed);
+bool has_begin_node(analyzed_ruby_T* analyzed);
+bool has_rescue_node(analyzed_ruby_T* analyzed);
+bool has_ensure_node(analyzed_ruby_T* analyzed);
+bool has_unless_node(analyzed_ruby_T* analyzed);
+
+bool has_error_message(analyzed_ruby_T* anlayzed, const char* message);
+
+bool search_if_nodes(const pm_node_t* node, void* data);
+bool search_block_nodes(const pm_node_t* node, void* data);
+bool search_case_nodes(const pm_node_t* node, void* data);
+bool search_while_nodes(const pm_node_t* node, void* data);
+bool search_for_nodes(const pm_node_t* node, void* data);
+bool search_until_nodes(const pm_node_t* node, void* data);
+bool search_begin_nodes(const pm_node_t* node, void* data);
+bool search_unless_nodes(const pm_node_t* node, void* data);
+bool search_elsif_nodes(analyzed_ruby_T* analyzed);
+bool search_else_nodes(analyzed_ruby_T* analyzed);
+bool search_end_nodes(analyzed_ruby_T* analyzed);
+bool search_block_closing_nodes(analyzed_ruby_T* analyzed);
+bool search_when_nodes(analyzed_ruby_T* analyzed);
+bool search_rescue_nodes(analyzed_ruby_T* analyzed);
+bool search_ensure_nodes(analyzed_ruby_T* analyzed);
+
+#endif

data/src/include/analyzed_ruby.h

@@ -0,0 +1,33 @@
+#ifndef HERB_ANALYZED_RUBY_H
+#define HERB_ANALYZED_RUBY_H
+
+#include "array.h"
+
+#include <prism.h>
+
+typedef struct ANALYZED_RUBY_STRUCT {
+  pm_parser_t parser;
+  pm_node_t* root;
+  bool valid;
+  bool parsed;
+  bool has_if_node;
+  bool has_elsif_node;
+  bool has_else_node;
+  bool has_end;
+  bool has_block_closing;
+  bool has_block_node;
+  bool has_case_node;
+  bool has_when_node;
+  bool has_for_node;
+  bool has_while_node;
+  bool has_until_node;
+  bool has_begin_node;
+  bool has_rescue_node;
+  bool has_ensure_node;
+  bool has_unless_node;
+} analyzed_ruby_T;
+
+analyzed_ruby_T* init_analyzed_ruby(char* source);
+void free_analyzed_ruby(analyzed_ruby_T* analyzed);
+
+#endif

data/src/include/array.h

@@ -0,0 +1,33 @@
+#ifndef HERB_ARRAY_H
+#define HERB_ARRAY_H
+
+#include <stdlib.h>
+
+typedef struct ARRAY_STRUCT {
+  void** items;
+  size_t size;
+  size_t capacity;
+} array_T;
+
+array_T* array_init(size_t capacity);
+
+void* array_get(const array_T* array, size_t index);
+void* array_first(array_T* array);
+void* array_last(array_T* array);
+
+void array_append(array_T* array, void* item);
+void array_set(const array_T* array, size_t index, void* item);
+void array_free(array_T** array);
+void array_remove(array_T* array, size_t index);
+
+size_t array_index_of(array_T* array, void* item);
+void array_remove_item(array_T* array, void* item);
+
+void array_push(array_T* array, void* item);
+void* array_pop(array_T* array);
+
+size_t array_capacity(const array_T* array);
+size_t array_size(const array_T* array);
+size_t array_sizeof(void);
+
+#endif

data/src/include/ast_node.h

@@ -0,0 +1,35 @@
+#ifndef HERB_AST_H
+#define HERB_AST_H
+
+#include "ast_nodes.h"
+#include "errors.h"
+#include "position.h"
+#include "token_struct.h"
+
+void ast_node_init(AST_NODE_T* node, ast_node_type_T type, position_T* start, position_T* end, array_T* errors);
+void ast_node_free(AST_NODE_T* node);
+
+AST_LITERAL_NODE_T* ast_literal_node_init_from_token(const token_T* token);
+
+size_t ast_node_sizeof(void);
+size_t ast_node_child_count(AST_NODE_T* node);
+
+ast_node_type_T ast_node_type(const AST_NODE_T* node);
+
+char* ast_node_name(AST_NODE_T* node);
+
+void ast_node_set_start(AST_NODE_T* node, position_T* position);
+void ast_node_set_end(AST_NODE_T* node, position_T* position);
+
+size_t ast_node_errors_count(const AST_NODE_T* node);
+array_T* ast_node_errors(const AST_NODE_T* node);
+void ast_node_append_error(const AST_NODE_T* node, ERROR_T* error);
+
+void ast_node_set_start_from_token(AST_NODE_T* node, const token_T* token);
+void ast_node_set_end_from_token(AST_NODE_T* node, const token_T* token);
+
+void ast_node_set_positions_from_token(AST_NODE_T* node, const token_T* token);
+
+bool ast_node_is(const AST_NODE_T* node, ast_node_type_T type);
+
+#endif