@herb-tools/node 0.8.10 → 0.9.1

package/extension/error_helpers.h

@@ -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.10/templates/javascript/packages/node/extension/error_helpers.h.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.9.1/templates/javascript/packages/node/extension/error_helpers.h.erb
 
 #ifndef HERB_EXTENSION_ERRORS_H
 #define HERB_EXTENSION_ERRORS_H
@@ -18,13 +18,30 @@ napi_value UnexpectedTokenErrorFromCStruct(napi_env env, UNEXPECTED_TOKEN_ERROR_
 napi_value MissingOpeningTagErrorFromCStruct(napi_env env, MISSING_OPENING_TAG_ERROR_T* missing_opening_tag_error);
 napi_value MissingClosingTagErrorFromCStruct(napi_env env, MISSING_CLOSING_TAG_ERROR_T* missing_closing_tag_error);
 napi_value TagNamesMismatchErrorFromCStruct(napi_env env, TAG_NAMES_MISMATCH_ERROR_T* tag_names_mismatch_error);
-napi_value QuotesMismatchErrorFromCStruct(napi_env env, QUOTES_MISMATCH_ERROR_T* quotes_mismatch_error);
 napi_value VoidElementClosingTagErrorFromCStruct(napi_env env, VOID_ELEMENT_CLOSING_TAG_ERROR_T* void_element_closing_tag_error);
 napi_value UnclosedElementErrorFromCStruct(napi_env env, UNCLOSED_ELEMENT_ERROR_T* unclosed_element_error);
 napi_value RubyParseErrorFromCStruct(napi_env env, RUBY_PARSE_ERROR_T* ruby_parse_error);
 napi_value ERBControlFlowScopeErrorFromCStruct(napi_env env, ERB_CONTROL_FLOW_SCOPE_ERROR_T* erb_control_flow_scope_error);
-napi_value MissingERBEndTagErrorFromCStruct(napi_env env, MISSINGERB_END_TAG_ERROR_T* missingerb_end_tag_error);
+napi_value MissingERBEndTagErrorFromCStruct(napi_env env, MISSING_ERB_END_TAG_ERROR_T* missing_erb_end_tag_error);
 napi_value ERBMultipleBlocksInTagErrorFromCStruct(napi_env env, ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error);
 napi_value ERBCaseWithConditionsErrorFromCStruct(napi_env env, ERB_CASE_WITH_CONDITIONS_ERROR_T* erb_case_with_conditions_error);
+napi_value ConditionalElementMultipleTagsErrorFromCStruct(napi_env env, CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR_T* conditional_element_multiple_tags_error);
+napi_value ConditionalElementConditionMismatchErrorFromCStruct(napi_env env, CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR_T* conditional_element_condition_mismatch_error);
+napi_value InvalidCommentClosingTagErrorFromCStruct(napi_env env, INVALID_COMMENT_CLOSING_TAG_ERROR_T* invalid_comment_closing_tag_error);
+napi_value OmittedClosingTagErrorFromCStruct(napi_env env, OMITTED_CLOSING_TAG_ERROR_T* omitted_closing_tag_error);
+napi_value UnclosedOpenTagErrorFromCStruct(napi_env env, UNCLOSED_OPEN_TAG_ERROR_T* unclosed_open_tag_error);
+napi_value UnclosedCloseTagErrorFromCStruct(napi_env env, UNCLOSED_CLOSE_TAG_ERROR_T* unclosed_close_tag_error);
+napi_value UnclosedQuoteErrorFromCStruct(napi_env env, UNCLOSED_QUOTE_ERROR_T* unclosed_quote_error);
+napi_value MissingAttributeValueErrorFromCStruct(napi_env env, MISSING_ATTRIBUTE_VALUE_ERROR_T* missing_attribute_value_error);
+napi_value UnclosedERBTagErrorFromCStruct(napi_env env, UNCLOSED_ERB_TAG_ERROR_T* unclosed_erb_tag_error);
+napi_value StrayERBClosingTagErrorFromCStruct(napi_env env, STRAY_ERB_CLOSING_TAG_ERROR_T* stray_erb_closing_tag_error);
+napi_value NestedERBTagErrorFromCStruct(napi_env env, NESTED_ERB_TAG_ERROR_T* nested_erb_tag_error);
+napi_value RenderAmbiguousLocalsErrorFromCStruct(napi_env env, RENDER_AMBIGUOUS_LOCALS_ERROR_T* render_ambiguous_locals_error);
+napi_value RenderMissingLocalsErrorFromCStruct(napi_env env, RENDER_MISSING_LOCALS_ERROR_T* render_missing_locals_error);
+napi_value RenderNoArgumentsErrorFromCStruct(napi_env env, RENDER_NO_ARGUMENTS_ERROR_T* render_no_arguments_error);
+napi_value RenderConflictingPartialErrorFromCStruct(napi_env env, RENDER_CONFLICTING_PARTIAL_ERROR_T* render_conflicting_partial_error);
+napi_value RenderInvalidAsOptionErrorFromCStruct(napi_env env, RENDER_INVALID_AS_OPTION_ERROR_T* render_invalid_as_option_error);
+napi_value RenderObjectAndCollectionErrorFromCStruct(napi_env env, RENDER_OBJECT_AND_COLLECTION_ERROR_T* render_object_and_collection_error);
+napi_value RenderLayoutWithoutBlockErrorFromCStruct(napi_env env, RENDER_LAYOUT_WITHOUT_BLOCK_ERROR_T* render_layout_without_block_error);
 
 #endif

package/extension/extension_helpers.cpp

@@ -6,13 +6,13 @@
 extern "C" {
 #include "../extension/libherb/include/ast_nodes.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 "../extension/libherb/include/util/hb_array.h"
 #include "../extension/libherb/include/util/hb_buffer.h"
+#include "../extension/libherb/include/util/hb_string.h"
 }
 
 #include "error_helpers.h"
@@ -47,6 +47,12 @@ napi_value CreateString(napi_env env, const char* str) {
 }
 
 napi_value CreateStringFromHbString(napi_env env, hb_string_T string) {
+  if (hb_string_is_null(string)) {
+    napi_value null_value;
+    napi_get_null(env, &null_value);
+    return null_value;
+  }
+
   napi_value result;
   napi_create_string_utf8(env, string.data, string.length, &result);
   return result;
@@ -104,45 +110,19 @@ napi_value CreateToken(napi_env env, token_T* token) {
   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 value = CreateStringFromHbString(env, token->value);
   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);
+  napi_value type = CreateStringFromHbString(env, token_type_to_string(token->type));
 
-  // Type
-  napi_value type = CreateString(env, token_type_to_string(token->type));
+  napi_set_named_property(env, result, "value", value);
+  napi_set_named_property(env, result, "range", range);
+  napi_set_named_property(env, result, "location", location);
   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, hb_array_T* tokens, napi_value source) {
   napi_value result, tokens_array, errors_array, warnings_array;
 
@@ -151,10 +131,10 @@ napi_value CreateLexResult(napi_env env, hb_array_T* tokens, napi_value source)
   napi_create_array(env, &errors_array);
   napi_create_array(env, &warnings_array);
 
-  // Add tokens to array
   if (tokens) {
     for (size_t i = 0; i < hb_array_size(tokens); i++) {
       token_T* token = (token_T*)hb_array_get(tokens, i);
+
       if (token) {
         napi_value token_obj = CreateToken(env, token);
         napi_set_element(env, tokens_array, i, token_obj);
@@ -170,15 +150,15 @@ napi_value CreateLexResult(napi_env env, hb_array_T* tokens, napi_value source)
   return result;
 }
 
-napi_value CreateParseResult(napi_env env, AST_DOCUMENT_NODE_T* root, napi_value source) {
+napi_value CreateParseResult(napi_env env, AST_DOCUMENT_NODE_T* root, napi_value source, parser_options_T* options) {
   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 {
@@ -190,5 +170,30 @@ napi_value CreateParseResult(napi_env env, AST_DOCUMENT_NODE_T* root, napi_value
   napi_set_named_property(env, result, "warnings", warnings_array);
   napi_set_named_property(env, result, "errors", errors_array);
 
+  napi_value options_object;
+  napi_create_object(env, &options_object);
+
+  napi_value strict_value, track_whitespace_value, analyze_value, action_view_helpers_value, render_nodes_value, prism_program_value, prism_nodes_value, prism_nodes_deep_value;
+
+  napi_get_boolean(env, options->strict, &strict_value);
+  napi_get_boolean(env, options->track_whitespace, &track_whitespace_value);
+  napi_get_boolean(env, options->analyze, &analyze_value);
+  napi_get_boolean(env, options->action_view_helpers, &action_view_helpers_value);
+  napi_get_boolean(env, options->render_nodes, &render_nodes_value);
+  napi_get_boolean(env, options->prism_program, &prism_program_value);
+  napi_get_boolean(env, options->prism_nodes, &prism_nodes_value);
+  napi_get_boolean(env, options->prism_nodes_deep, &prism_nodes_deep_value);
+
+  napi_set_named_property(env, options_object, "strict", strict_value);
+  napi_set_named_property(env, options_object, "track_whitespace", track_whitespace_value);
+  napi_set_named_property(env, options_object, "analyze", analyze_value);
+  napi_set_named_property(env, options_object, "action_view_helpers", action_view_helpers_value);
+  napi_set_named_property(env, options_object, "render_nodes", render_nodes_value);
+  napi_set_named_property(env, options_object, "prism_program", prism_program_value);
+  napi_set_named_property(env, options_object, "prism_nodes", prism_nodes_value);
+  napi_set_named_property(env, options_object, "prism_nodes_deep", prism_nodes_deep_value);
+
+  napi_set_named_property(env, result, "options", options_object);
+
   return result;
 }

package/extension/extension_helpers.h

@@ -5,6 +5,7 @@
 
 extern "C" {
 #include "../extension/libherb/include/ast_nodes.h"
+#include "../extension/libherb/include/herb.h"
 #include "../extension/libherb/include/util/hb_array.h"
 #include "../extension/libherb/include/util/hb_string.h"
 }
@@ -12,9 +13,8 @@ extern "C" {
 char* CheckString(napi_env env, napi_value value);
 napi_value CreateString(napi_env env, const char* str);
 napi_value CreateStringFromHbString(napi_env env, hb_string_T string);
-napi_value ReadFileToString(napi_env env, const char* file_path);
 napi_value CreateLexResult(napi_env env, hb_array_T* tokens, napi_value source);
-napi_value CreateParseResult(napi_env env, AST_DOCUMENT_NODE_T* root, napi_value source);
+napi_value CreateParseResult(napi_env env, AST_DOCUMENT_NODE_T* root, napi_value source, parser_options_T* options);
 
 napi_value CreateLocation(napi_env env, location_T location);
 napi_value CreateToken(napi_env env, token_T* token);

package/extension/herb.cpp

@@ -1,10 +1,11 @@
 extern "C" {
-#include "../extension/libherb/include/analyze.h"
 #include "../extension/libherb/include/ast_nodes.h"
+#include "../extension/libherb/include/extract.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 "../extension/libherb/include/util/hb_allocator.h"
 #include "../extension/libherb/include/util/hb_array.h"
 #include "../extension/libherb/include/util/hb_buffer.h"
 }
@@ -31,34 +32,19 @@ napi_value Herb_lex(napi_env env, napi_callback_info info) {
   char* string = CheckString(env, args[0]);
   if (!string) { return nullptr; }
 
-  hb_array_T* tokens = herb_lex(string);
-  napi_value result = CreateLexResult(env, tokens, args[0]);
-
-  herb_free_tokens(&tokens);
-  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");
+  hb_allocator_T allocator;
+  if (!hb_allocator_init(&allocator, HB_ALLOCATOR_ARENA)) {
+    free(string);
+    napi_throw_error(env, nullptr, "Failed to initialize allocator");
     return nullptr;
   }
 
-  char* file_path = CheckString(env, args[0]);
-  if (!file_path) { return nullptr; }
-
-  hb_array_T* tokens = herb_lex_file(file_path);
-  napi_value source_value = ReadFileToString(env, file_path);
-  napi_value result = CreateLexResult(env, tokens, source_value);
+  hb_array_T* tokens = herb_lex(string, &allocator);
+  napi_value result = CreateLexResult(env, tokens, args[0]);
 
-  herb_free_tokens(&tokens);
-  free(file_path);
+  herb_free_tokens(&tokens, &allocator);
+  hb_allocator_destroy(&allocator);
+  free(string);
 
   return result;
 }
@@ -76,8 +62,7 @@ napi_value Herb_parse(napi_env env, napi_callback_info info) {
   char* string = CheckString(env, args[0]);
   if (!string) { return nullptr; }
 
-  parser_options_T* parser_options = nullptr;
-  parser_options_T opts = {0};
+  parser_options_T parser_options = HERB_DEFAULT_PARSER_OPTIONS;
 
   if (argc >= 2) {
     napi_valuetype valuetype;
@@ -85,35 +70,121 @@ napi_value Herb_parse(napi_env env, napi_callback_info info) {
 
     if (valuetype == napi_object) {
       napi_value track_whitespace_prop;
-      bool has_prop;
-      napi_has_named_property(env, args[1], "track_whitespace", &has_prop);
+      bool has_track_whitespace_prop;
+      napi_has_named_property(env, args[1], "track_whitespace", &has_track_whitespace_prop);
 
-      if (has_prop) {
+      if (has_track_whitespace_prop) {
         napi_get_named_property(env, args[1], "track_whitespace", &track_whitespace_prop);
         bool track_whitespace_value;
         napi_get_value_bool(env, track_whitespace_prop, &track_whitespace_value);
 
         if (track_whitespace_value) {
-          opts.track_whitespace = true;
-          parser_options = &opts;
+          parser_options.track_whitespace = true;
         }
       }
+
+      napi_value analyze_prop;
+      bool has_analyze_prop;
+      napi_has_named_property(env, args[1], "analyze", &has_analyze_prop);
+
+      if (has_analyze_prop) {
+        napi_get_named_property(env, args[1], "analyze", &analyze_prop);
+        bool analyze_value;
+        napi_get_value_bool(env, analyze_prop, &analyze_value);
+
+        if (!analyze_value) {
+          parser_options.analyze = false;
+        }
+      }
+
+      napi_value strict_prop;
+      bool has_strict_prop;
+      napi_has_named_property(env, args[1], "strict", &has_strict_prop);
+
+      if (has_strict_prop) {
+        napi_get_named_property(env, args[1], "strict", &strict_prop);
+        bool strict_value;
+        napi_get_value_bool(env, strict_prop, &strict_value);
+        parser_options.strict = strict_value;
+      }
+
+      napi_value action_view_helpers_prop;
+      bool has_action_view_helpers_prop;
+      napi_has_named_property(env, args[1], "action_view_helpers", &has_action_view_helpers_prop);
+
+      if (has_action_view_helpers_prop) {
+        napi_get_named_property(env, args[1], "action_view_helpers", &action_view_helpers_prop);
+        bool action_view_helpers_value;
+        napi_get_value_bool(env, action_view_helpers_prop, &action_view_helpers_value);
+        parser_options.action_view_helpers = action_view_helpers_value;
+      }
+
+      napi_value render_nodes_prop;
+      bool has_render_nodes_prop;
+      napi_has_named_property(env, args[1], "render_nodes", &has_render_nodes_prop);
+
+      if (has_render_nodes_prop) {
+        napi_get_named_property(env, args[1], "render_nodes", &render_nodes_prop);
+        bool render_nodes_value;
+        napi_get_value_bool(env, render_nodes_prop, &render_nodes_value);
+        parser_options.render_nodes = render_nodes_value;
+      }
+
+      napi_value prism_nodes_prop;
+      bool has_prism_nodes_prop;
+      napi_has_named_property(env, args[1], "prism_nodes", &has_prism_nodes_prop);
+
+      if (has_prism_nodes_prop) {
+        napi_get_named_property(env, args[1], "prism_nodes", &prism_nodes_prop);
+        bool prism_nodes_value;
+        napi_get_value_bool(env, prism_nodes_prop, &prism_nodes_value);
+        parser_options.prism_nodes = prism_nodes_value;
+      }
+
+      napi_value prism_nodes_deep_prop;
+      bool has_prism_nodes_deep_prop;
+      napi_has_named_property(env, args[1], "prism_nodes_deep", &has_prism_nodes_deep_prop);
+
+      if (has_prism_nodes_deep_prop) {
+        napi_get_named_property(env, args[1], "prism_nodes_deep", &prism_nodes_deep_prop);
+        bool prism_nodes_deep_value;
+        napi_get_value_bool(env, prism_nodes_deep_prop, &prism_nodes_deep_value);
+        parser_options.prism_nodes_deep = prism_nodes_deep_value;
+      }
+
+      napi_value prism_program_prop;
+      bool has_prism_program_prop;
+      napi_has_named_property(env, args[1], "prism_program", &has_prism_program_prop);
+
+      if (has_prism_program_prop) {
+        napi_get_named_property(env, args[1], "prism_program", &prism_program_prop);
+        bool prism_program_value;
+        napi_get_value_bool(env, prism_program_prop, &prism_program_value);
+        parser_options.prism_program = prism_program_value;
+      }
     }
   }
 
-  AST_DOCUMENT_NODE_T* root = herb_parse(string, parser_options);
-  herb_analyze_parse_tree(root, string);
-  napi_value result = CreateParseResult(env, root, args[0]);
+  hb_allocator_T allocator;
+  if (!hb_allocator_init(&allocator, HB_ALLOCATOR_ARENA)) {
+    free(string);
+    napi_throw_error(env, nullptr, "Failed to initialize allocator");
+    return nullptr;
+  }
+
+  AST_DOCUMENT_NODE_T* root = herb_parse(string, &parser_options, &allocator);
+  napi_value result = CreateParseResult(env, root, args[0], &parser_options);
 
-  ast_node_free((AST_NODE_T *) root);
+  ast_node_free((AST_NODE_T *) root, &allocator);
+  hb_allocator_destroy(&allocator);
   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_value Herb_extract_ruby(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
+  napi_value args[2];
   napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
 
   if (argc < 1) {
@@ -121,28 +192,72 @@ napi_value Herb_parse_file(napi_env env, napi_callback_info info) {
     return nullptr;
   }
 
-  char* file_path = CheckString(env, args[0]);
-  if (!file_path) { return nullptr; }
+  char* string = CheckString(env, args[0]);
+  if (!string) { return nullptr; }
 
-  napi_value source_value = ReadFileToString(env, file_path);
+  hb_allocator_T allocator;
+  if (!hb_allocator_init(&allocator, HB_ALLOCATOR_ARENA)) {
+    free(string);
+    napi_throw_error(env, nullptr, "Failed to initialize allocator");
+    return nullptr;
+  }
 
-  char* string = CheckString(env, source_value);
-  if (!string) {
-    free(file_path);
+  hb_buffer_T output;
+  if (!hb_buffer_init(&output, strlen(string), &allocator)) {
+    hb_allocator_destroy(&allocator);
+    free(string);
+    napi_throw_error(env, nullptr, "Failed to initialize buffer");
     return nullptr;
   }
 
-  AST_DOCUMENT_NODE_T* root = herb_parse(string, nullptr);
-  napi_value result = CreateParseResult(env, root, source_value);
+  herb_extract_ruby_options_T extract_options = HERB_EXTRACT_RUBY_DEFAULT_OPTIONS;
 
-  ast_node_free((AST_NODE_T *) root);
-  free(file_path);
-  free(string);
+  if (argc >= 2) {
+    napi_valuetype valuetype;
+    napi_typeof(env, args[1], &valuetype);
+
+    if (valuetype == napi_object) {
+      napi_value prop;
+      bool has_prop;
+
+      napi_has_named_property(env, args[1], "semicolons", &has_prop);
+      if (has_prop) {
+        napi_get_named_property(env, args[1], "semicolons", &prop);
+        bool value;
+        napi_get_value_bool(env, prop, &value);
+        extract_options.semicolons = value;
+      }
+
+      napi_has_named_property(env, args[1], "comments", &has_prop);
+      if (has_prop) {
+        napi_get_named_property(env, args[1], "comments", &prop);
+        bool value;
+        napi_get_value_bool(env, prop, &value);
+        extract_options.comments = value;
+      }
+
+      napi_has_named_property(env, args[1], "preserve_positions", &has_prop);
+      if (has_prop) {
+        napi_get_named_property(env, args[1], "preserve_positions", &prop);
+        bool value;
+        napi_get_value_bool(env, prop, &value);
+        extract_options.preserve_positions = value;
+      }
+    }
+  }
+
+  herb_extract_ruby_to_buffer_with_options(string, &output, &extract_options, &allocator);
+
+  napi_value result;
+  napi_create_string_utf8(env, output.value, NAPI_AUTO_LENGTH, &result);
 
+  hb_buffer_free(&output);
+  hb_allocator_destroy(&allocator);
+  free(string);
   return result;
 }
 
-napi_value Herb_extract_ruby(napi_env env, napi_callback_info info) {
+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);
@@ -155,24 +270,33 @@ napi_value Herb_extract_ruby(napi_env env, napi_callback_info info) {
   char* string = CheckString(env, args[0]);
   if (!string) { return nullptr; }
 
+  hb_allocator_T allocator;
+  if (!hb_allocator_init(&allocator, HB_ALLOCATOR_ARENA)) {
+    free(string);
+    napi_throw_error(env, nullptr, "Failed to initialize allocator");
+    return nullptr;
+  }
+
   hb_buffer_T output;
-  if (!hb_buffer_init(&output, strlen(string))) {
+  if (!hb_buffer_init(&output, strlen(string), &allocator)) {
+    hb_allocator_destroy(&allocator);
     free(string);
     napi_throw_error(env, nullptr, "Failed to initialize buffer");
     return nullptr;
   }
 
-  herb_extract_ruby_to_buffer(string, &output);
+  herb_extract_html_to_buffer(string, &output, &allocator);
 
   napi_value result;
   napi_create_string_utf8(env, output.value, NAPI_AUTO_LENGTH, &result);
 
-  free(output.value);
+  hb_buffer_free(&output);
+  hb_allocator_destroy(&allocator);
   free(string);
   return result;
 }
 
-napi_value Herb_extract_html(napi_env env, napi_callback_info info) {
+napi_value Herb_parse_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);
@@ -185,20 +309,27 @@ napi_value Herb_extract_html(napi_env env, napi_callback_info info) {
   char* string = CheckString(env, args[0]);
   if (!string) { return nullptr; }
 
-  hb_buffer_T output;
-  if (!hb_buffer_init(&output, strlen(string))) {
+  herb_ruby_parse_result_T* parse_result = herb_parse_ruby(string, strlen(string));
+
+  if (!parse_result) {
     free(string);
-    napi_throw_error(env, nullptr, "Failed to initialize buffer");
     return nullptr;
   }
 
-  herb_extract_html_to_buffer(string, &output);
+  pm_buffer_t buffer = { 0 };
+  pm_serialize(&parse_result->parser, parse_result->root, &buffer);
 
-  napi_value result;
-  napi_create_string_utf8(env, output.value, NAPI_AUTO_LENGTH, &result);
+  napi_value result = nullptr;
 
-  free(output.value);
+  if (buffer.length > 0) {
+    void* data;
+    napi_create_buffer_copy(env, buffer.length, buffer.value, &data, &result);
+  }
+
+  pm_buffer_free(&buffer);
+  herb_free_ruby_parse_result(parse_result);
   free(string);
+
   return result;
 }
 
@@ -219,11 +350,10 @@ 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 },
     { "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 },
+    { "parseRuby", nullptr, Herb_parse_ruby, nullptr, nullptr, nullptr, napi_default, nullptr },
   };
 
   napi_define_properties(env, exports, sizeof(descriptors) / sizeof(descriptors[0]), descriptors);