@herb-tools/node 0.1.0

package/extension/extension_helpers.cpp

@@ -0,0 +1,206 @@
+#include <node_api.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+extern "C" {
+#include "../extension/libherb/include/array.h"
+#include "../extension/libherb/include/ast_nodes.h"
+#include "../extension/libherb/include/buffer.h"
+#include "../extension/libherb/include/herb.h"
+#include "../extension/libherb/include/io.h"
+#include "../extension/libherb/include/location.h"
+#include "../extension/libherb/include/position.h"
+#include "../extension/libherb/include/range.h"
+#include "../extension/libherb/include/token.h"
+}
+
+#include "error_helpers.h"
+#include "nodes.h"
+
+char* CheckString(napi_env env, napi_value value) {
+  size_t length;
+  size_t copied;
+  napi_valuetype type;
+
+  napi_typeof(env, value, &type);
+  if (type != napi_string) {
+    napi_throw_type_error(env, nullptr, "String expected");
+    return nullptr;
+  }
+
+  napi_get_value_string_utf8(env, value, nullptr, 0, &length);
+  char* result = (char*) malloc(length + 1);
+  if (!result) {
+    napi_throw_error(env, nullptr, "Memory allocation failed");
+    return nullptr;
+  }
+
+  napi_get_value_string_utf8(env, value, result, length + 1, &copied);
+  return result;
+}
+
+napi_value CreateString(napi_env env, const char* str) {
+  napi_value result;
+  napi_create_string_utf8(env, str, NAPI_AUTO_LENGTH, &result);
+  return result;
+}
+
+napi_value CreatePosition(napi_env env, position_T* position) {
+  if (!position) {
+    napi_value null_value;
+    napi_get_null(env, &null_value);
+    return null_value;
+  }
+
+  napi_value result;
+  napi_create_object(env, &result);
+
+  napi_value line, column;
+  napi_create_uint32(env, (uint32_t)position->line, &line);
+  napi_create_uint32(env, (uint32_t)position->column, &column);
+
+  napi_set_named_property(env, result, "line", line);
+  napi_set_named_property(env, result, "column", column);
+
+  return result;
+}
+
+napi_value CreateLocation(napi_env env, location_T* location) {
+  if (!location) {
+    napi_value null_value;
+    napi_get_null(env, &null_value);
+    return null_value;
+  }
+
+  napi_value result;
+  napi_create_object(env, &result);
+
+  napi_value start = CreatePosition(env, location->start);
+  napi_value end = CreatePosition(env, location->end);
+
+  napi_set_named_property(env, result, "start", start);
+  napi_set_named_property(env, result, "end", end);
+
+  return result;
+}
+
+napi_value CreateRange(napi_env env, range_T* range) {
+  if (!range) {
+    napi_value null_value;
+    napi_get_null(env, &null_value);
+    return null_value;
+  }
+
+  napi_value result;
+  napi_create_array(env, &result);
+
+  napi_value from, to;
+  napi_create_uint32(env, (uint32_t)range->from, &from);
+  napi_create_uint32(env, (uint32_t)range->to, &to);
+
+  napi_set_element(env, result, 0, from);
+  napi_set_element(env, result, 1, to);
+
+  return result;
+}
+
+napi_value CreateToken(napi_env env, token_T* token) {
+  if (!token) {
+    napi_value null_value;
+    napi_get_null(env, &null_value);
+    return null_value;
+  }
+
+  napi_value result;
+  napi_create_object(env, &result);
+
+  // Value
+  napi_value value = token->value ? CreateString(env, token->value) : nullptr;
+  if (value) {
+    napi_set_named_property(env, result, "value", value);
+  } else {
+    napi_value null_value;
+    napi_get_null(env, &null_value);
+    napi_set_named_property(env, result, "value", null_value);
+  }
+
+  // Range
+  napi_value range = CreateRange(env, token->range);
+  napi_set_named_property(env, result, "range", range);
+
+  // Location
+  napi_value location = CreateLocation(env, token->location);
+  napi_set_named_property(env, result, "location", location);
+
+  // Type
+  napi_value type = CreateString(env, token_type_to_string(token->type));
+  napi_set_named_property(env, result, "type", type);
+
+  return result;
+}
+
+napi_value ReadFileToString(napi_env env, const char* file_path) {
+  char* content = herb_read_file(file_path);
+  if (!content) {
+    napi_throw_error(env, nullptr, "Failed to read file");
+    return nullptr;
+  }
+
+  napi_value result = CreateString(env, content);
+  free(content);
+  return result;
+}
+
+napi_value CreateLexResult(napi_env env, array_T* tokens, napi_value source) {
+  napi_value result, tokens_array, errors_array, warnings_array;
+
+  napi_create_object(env, &result);
+  napi_create_array(env, &tokens_array);
+  napi_create_array(env, &errors_array);
+  napi_create_array(env, &warnings_array);
+
+  // Add tokens to array
+  if (tokens) {
+    for (size_t i = 0; i < array_size(tokens); i++) {
+      token_T* token = (token_T*)array_get(tokens, i);
+      if (token) {
+        napi_value token_obj = CreateToken(env, token);
+        napi_set_element(env, tokens_array, i, token_obj);
+      }
+    }
+  }
+
+  napi_set_named_property(env, result, "tokens", tokens_array);
+  napi_set_named_property(env, result, "source", source);
+  napi_set_named_property(env, result, "warnings", warnings_array);
+  napi_set_named_property(env, result, "errors", errors_array);
+
+  // Free tokens after creating JS objects
+  herb_free_tokens(&tokens);
+
+  return result;
+}
+
+napi_value CreateParseResult(napi_env env, AST_DOCUMENT_NODE_T* root, napi_value source) {
+  napi_value result, errors_array, warnings_array;
+
+  napi_create_object(env, &result);
+  napi_create_array(env, &errors_array);
+  napi_create_array(env, &warnings_array);
+
+  // Convert the AST to a JavaScript object
+  napi_value ast_value;
+  if (root) {
+    ast_value = NodeFromCStruct(env, (AST_NODE_T*)root);
+  } else {
+    napi_get_null(env, &ast_value);
+  }
+
+  napi_set_named_property(env, result, "value", ast_value);
+  napi_set_named_property(env, result, "source", source);
+  napi_set_named_property(env, result, "warnings", warnings_array);
+  napi_set_named_property(env, result, "errors", errors_array);
+
+  return result;
+}

package/extension/extension_helpers.h

@@ -0,0 +1,22 @@
+#ifndef HERB_NODE_EXTENSION_HELPERS_H
+#define HERB_NODE_EXTENSION_HELPERS_H
+
+#include <node_api.h>
+
+extern "C" {
+#include "../extension/libherb/include/array.h"
+#include "../extension/libherb/include/ast_nodes.h"
+}
+
+char* CheckString(napi_env env, napi_value value);
+napi_value CreateString(napi_env env, const char* str);
+napi_value ReadFileToString(napi_env env, const char* file_path);
+napi_value CreateLexResult(napi_env env, array_T* tokens, napi_value source);
+napi_value CreateParseResult(napi_env env, AST_DOCUMENT_NODE_T* root, napi_value source);
+
+napi_value CreateLocation(napi_env env, location_T* location);
+napi_value CreateToken(napi_env env, token_T* token);
+napi_value CreatePosition(napi_env env, position_T* position);
+napi_value CreateRange(napi_env env, range_T* range);
+
+#endif

package/extension/herb.cpp

@@ -0,0 +1,232 @@
+extern "C" {
+#include "../extension/libherb/include/analyze.h"
+#include "../extension/libherb/include/array.h"
+#include "../extension/libherb/include/ast_nodes.h"
+#include "../extension/libherb/include/buffer.h"
+#include "../extension/libherb/include/herb.h"
+#include "../extension/libherb/include/location.h"
+#include "../extension/libherb/include/range.h"
+#include "../extension/libherb/include/token.h"
+}
+
+#include "error_helpers.h"
+#include "extension_helpers.h"
+#include "nodes.h"
+
+#include <node_api.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+napi_value Herb_lex(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+
+  if (argc < 1) {
+    napi_throw_error(env, nullptr, "Wrong number of arguments");
+    return nullptr;
+  }
+
+  char* string = CheckString(env, args[0]);
+  if (!string) { return nullptr; }
+
+  array_T* tokens = herb_lex(string);
+  napi_value result = CreateLexResult(env, tokens, args[0]);
+
+  free(string);
+  return result;
+}
+
+napi_value Herb_lex_file(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+
+  if (argc < 1) {
+    napi_throw_error(env, nullptr, "Wrong number of arguments");
+    return nullptr;
+  }
+
+  char* file_path = CheckString(env, args[0]);
+  if (!file_path) { return nullptr; }
+
+  array_T* tokens = herb_lex_file(file_path);
+  napi_value source_value = ReadFileToString(env, file_path);
+  napi_value result = CreateLexResult(env, tokens, source_value);
+
+  free(file_path);
+  return result;
+}
+
+napi_value Herb_parse(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+
+  if (argc < 1) {
+    napi_throw_error(env, nullptr, "Wrong number of arguments");
+    return nullptr;
+  }
+
+  char* string = CheckString(env, args[0]);
+  if (!string) { return nullptr; }
+
+  AST_DOCUMENT_NODE_T* root = herb_parse(string);
+  herb_analyze_parse_tree(root, string);
+  napi_value result = CreateParseResult(env, root, args[0]);
+
+  free(string);
+  return result;
+}
+
+napi_value Herb_parse_file(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+
+  if (argc < 1) {
+    napi_throw_error(env, nullptr, "Wrong number of arguments");
+    return nullptr;
+  }
+
+  char* file_path = CheckString(env, args[0]);
+  if (!file_path) { return nullptr; }
+
+  napi_value source_value = ReadFileToString(env, file_path);
+
+  char* string = CheckString(env, source_value);
+  if (!string) {
+    free(file_path);
+    return nullptr;
+  }
+
+  AST_DOCUMENT_NODE_T* root = herb_parse(string);
+  napi_value result = CreateParseResult(env, root, source_value);
+
+  free(file_path);
+  free(string);
+  return result;
+}
+
+napi_value Herb_lex_to_json(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+
+  if (argc < 1) {
+    napi_throw_error(env, nullptr, "Wrong number of arguments");
+    return nullptr;
+  }
+
+  char* string = CheckString(env, args[0]);
+  if (!string) { return nullptr; }
+
+  buffer_T output;
+  if (!buffer_init(&output)) {
+    free(string);
+    napi_throw_error(env, nullptr, "Failed to initialize buffer");
+    return nullptr;
+  }
+
+  herb_lex_json_to_buffer(string, &output);
+
+  napi_value result;
+  napi_create_string_utf8(env, output.value, output.length, &result);
+
+  buffer_free(&output);
+  free(string);
+  return result;
+}
+
+napi_value Herb_extract_ruby(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+
+  if (argc < 1) {
+    napi_throw_error(env, nullptr, "Wrong number of arguments");
+    return nullptr;
+  }
+
+  char* string = CheckString(env, args[0]);
+  if (!string) { return nullptr; }
+
+  buffer_T output;
+  if (!buffer_init(&output)) {
+    free(string);
+    napi_throw_error(env, nullptr, "Failed to initialize buffer");
+    return nullptr;
+  }
+
+  herb_extract_ruby_to_buffer(string, &output);
+
+  napi_value result;
+  napi_create_string_utf8(env, output.value, NAPI_AUTO_LENGTH, &result);
+
+  buffer_free(&output);
+  free(string);
+  return result;
+}
+
+napi_value Herb_extract_html(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+
+  if (argc < 1) {
+    napi_throw_error(env, nullptr, "Wrong number of arguments");
+    return nullptr;
+  }
+
+  char* string = CheckString(env, args[0]);
+  if (!string) { return nullptr; }
+
+  buffer_T output;
+  if (!buffer_init(&output)) {
+    free(string);
+    napi_throw_error(env, nullptr, "Failed to initialize buffer");
+    return nullptr;
+  }
+
+  herb_extract_html_to_buffer(string, &output);
+
+  napi_value result;
+  napi_create_string_utf8(env, output.value, NAPI_AUTO_LENGTH, &result);
+
+  buffer_free(&output);
+  free(string);
+  return result;
+}
+
+napi_value Herb_version(napi_env env, napi_callback_info info) {
+  const char* libherb_version = herb_version();
+  const char* libprism_version = herb_prism_version();
+
+  char version_buf[256];
+  snprintf(version_buf, sizeof(version_buf), "libprism@%s, libherb@%s (Node.js C++ native extension)", libprism_version, libherb_version);
+
+  napi_value result;
+  napi_create_string_utf8(env, version_buf, NAPI_AUTO_LENGTH, &result);
+
+  return result;
+}
+
+napi_value Init(napi_env env, napi_value exports) {
+  napi_property_descriptor descriptors[] = {
+    { "parse", nullptr, Herb_parse, nullptr, nullptr, nullptr, napi_default, nullptr },
+    { "lex", nullptr, Herb_lex, nullptr, nullptr, nullptr, napi_default, nullptr },
+    { "parseFile", nullptr, Herb_parse_file, nullptr, nullptr, nullptr, napi_default, nullptr },
+    { "lexFile", nullptr, Herb_lex_file, nullptr, nullptr, nullptr, napi_default, nullptr },
+    { "lexToJson", nullptr, Herb_lex_to_json, nullptr, nullptr, nullptr, napi_default, nullptr },
+    { "extractRuby", nullptr, Herb_extract_ruby, nullptr, nullptr, nullptr, napi_default, nullptr },
+    { "extractHTML", nullptr, Herb_extract_html, nullptr, nullptr, nullptr, napi_default, nullptr },
+    { "version", nullptr, Herb_version, nullptr, nullptr, nullptr, napi_default, nullptr },
+  };
+
+  napi_define_properties(env, exports, sizeof(descriptors) / sizeof(descriptors[0]), descriptors);
+
+  return exports;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)