herb 0.1.0-x86_64-linux-gnu

data/ext/herb/error_helpers.c

@@ -0,0 +1,302 @@
+// NOTE: This file is generated by the templates/template.rb script and should not
+// be modified manually. See /Users/marcoroth/Development/herb-release/templates/ext/herb/error_helpers.c.erb
+
+#include <ruby.h>
+
+#include "extension.h"
+#include "extension_helpers.h"
+#include "error_helpers.h"
+
+#include "../../src/include/errors.h"
+#include "../../src/include/herb.h"
+#include "../../src/include/token.h"
+
+VALUE rb_error_from_c_struct(ERROR_T* error);
+
+static VALUE rb_unexpected_error_from_c_struct(UNEXPECTED_ERROR_T* unexpected_error) {
+  if (unexpected_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &unexpected_error->base;
+
+  VALUE Herb = rb_define_module("Herb");
+  VALUE Errors = rb_define_module_under(Herb, "Errors");
+  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
+  VALUE UnexpectedError = rb_define_class_under(Errors, "UnexpectedError", Error);
+
+  VALUE type = rb_str_new_cstr(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_str_new_cstr(error->message);
+
+  VALUE unexpected_error_description = rb_str_new_cstr(unexpected_error->description);
+  VALUE unexpected_error_expected = rb_str_new_cstr(unexpected_error->expected);
+  VALUE unexpected_error_found = rb_str_new_cstr(unexpected_error->found);
+
+  VALUE args[6] = {
+    type,
+    location,
+    message,
+    unexpected_error_description,
+    unexpected_error_expected,
+    unexpected_error_found
+  };
+
+  return rb_class_new_instance(6, args, UnexpectedError);
+};
+
+static VALUE rb_unexpected_token_error_from_c_struct(UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error) {
+  if (unexpected_token_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &unexpected_token_error->base;
+
+  VALUE Herb = rb_define_module("Herb");
+  VALUE Errors = rb_define_module_under(Herb, "Errors");
+  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
+  VALUE UnexpectedTokenError = rb_define_class_under(Errors, "UnexpectedTokenError", Error);
+
+  VALUE type = rb_str_new_cstr(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_str_new_cstr(error->message);
+
+  VALUE unexpected_token_error_expected_type = rb_str_new_cstr(token_type_to_string(unexpected_token_error->expected_type));
+  VALUE unexpected_token_error_found = rb_token_from_c_struct(unexpected_token_error->found);
+
+  VALUE args[5] = {
+    type,
+    location,
+    message,
+    unexpected_token_error_expected_type,
+    unexpected_token_error_found
+  };
+
+  return rb_class_new_instance(5, args, UnexpectedTokenError);
+};
+
+static VALUE rb_missing_opening_tag_error_from_c_struct(MISSING_OPENING_TAG_ERROR_T* missing_opening_tag_error) {
+  if (missing_opening_tag_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &missing_opening_tag_error->base;
+
+  VALUE Herb = rb_define_module("Herb");
+  VALUE Errors = rb_define_module_under(Herb, "Errors");
+  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
+  VALUE MissingOpeningTagError = rb_define_class_under(Errors, "MissingOpeningTagError", Error);
+
+  VALUE type = rb_str_new_cstr(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_str_new_cstr(error->message);
+
+  VALUE missing_opening_tag_error_closing_tag = rb_token_from_c_struct(missing_opening_tag_error->closing_tag);
+
+  VALUE args[4] = {
+    type,
+    location,
+    message,
+    missing_opening_tag_error_closing_tag
+  };
+
+  return rb_class_new_instance(4, args, MissingOpeningTagError);
+};
+
+static VALUE rb_missing_closing_tag_error_from_c_struct(MISSING_CLOSING_TAG_ERROR_T* missing_closing_tag_error) {
+  if (missing_closing_tag_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &missing_closing_tag_error->base;
+
+  VALUE Herb = rb_define_module("Herb");
+  VALUE Errors = rb_define_module_under(Herb, "Errors");
+  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
+  VALUE MissingClosingTagError = rb_define_class_under(Errors, "MissingClosingTagError", Error);
+
+  VALUE type = rb_str_new_cstr(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_str_new_cstr(error->message);
+
+  VALUE missing_closing_tag_error_opening_tag = rb_token_from_c_struct(missing_closing_tag_error->opening_tag);
+
+  VALUE args[4] = {
+    type,
+    location,
+    message,
+    missing_closing_tag_error_opening_tag
+  };
+
+  return rb_class_new_instance(4, args, MissingClosingTagError);
+};
+
+static VALUE rb_tag_names_mismatch_error_from_c_struct(TAG_NAMES_MISMATCH_ERROR_T* tag_names_mismatch_error) {
+  if (tag_names_mismatch_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &tag_names_mismatch_error->base;
+
+  VALUE Herb = rb_define_module("Herb");
+  VALUE Errors = rb_define_module_under(Herb, "Errors");
+  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
+  VALUE TagNamesMismatchError = rb_define_class_under(Errors, "TagNamesMismatchError", Error);
+
+  VALUE type = rb_str_new_cstr(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_str_new_cstr(error->message);
+
+  VALUE tag_names_mismatch_error_opening_tag = rb_token_from_c_struct(tag_names_mismatch_error->opening_tag);
+  VALUE tag_names_mismatch_error_closing_tag = rb_token_from_c_struct(tag_names_mismatch_error->closing_tag);
+
+  VALUE args[5] = {
+    type,
+    location,
+    message,
+    tag_names_mismatch_error_opening_tag,
+    tag_names_mismatch_error_closing_tag
+  };
+
+  return rb_class_new_instance(5, args, TagNamesMismatchError);
+};
+
+static VALUE rb_quotes_mismatch_error_from_c_struct(QUOTES_MISMATCH_ERROR_T* quotes_mismatch_error) {
+  if (quotes_mismatch_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &quotes_mismatch_error->base;
+
+  VALUE Herb = rb_define_module("Herb");
+  VALUE Errors = rb_define_module_under(Herb, "Errors");
+  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
+  VALUE QuotesMismatchError = rb_define_class_under(Errors, "QuotesMismatchError", Error);
+
+  VALUE type = rb_str_new_cstr(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_str_new_cstr(error->message);
+
+  VALUE quotes_mismatch_error_opening_quote = rb_token_from_c_struct(quotes_mismatch_error->opening_quote);
+  VALUE quotes_mismatch_error_closing_quote = rb_token_from_c_struct(quotes_mismatch_error->closing_quote);
+
+  VALUE args[5] = {
+    type,
+    location,
+    message,
+    quotes_mismatch_error_opening_quote,
+    quotes_mismatch_error_closing_quote
+  };
+
+  return rb_class_new_instance(5, args, QuotesMismatchError);
+};
+
+static VALUE rb_void_element_closing_tag_error_from_c_struct(VOID_ELEMENT_CLOSING_TAG_ERROR_T* void_element_closing_tag_error) {
+  if (void_element_closing_tag_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &void_element_closing_tag_error->base;
+
+  VALUE Herb = rb_define_module("Herb");
+  VALUE Errors = rb_define_module_under(Herb, "Errors");
+  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
+  VALUE VoidElementClosingTagError = rb_define_class_under(Errors, "VoidElementClosingTagError", Error);
+
+  VALUE type = rb_str_new_cstr(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_str_new_cstr(error->message);
+
+  VALUE void_element_closing_tag_error_tag_name = rb_token_from_c_struct(void_element_closing_tag_error->tag_name);
+  VALUE void_element_closing_tag_error_expected = rb_str_new_cstr(void_element_closing_tag_error->expected);
+  VALUE void_element_closing_tag_error_found = rb_str_new_cstr(void_element_closing_tag_error->found);
+
+  VALUE args[6] = {
+    type,
+    location,
+    message,
+    void_element_closing_tag_error_tag_name,
+    void_element_closing_tag_error_expected,
+    void_element_closing_tag_error_found
+  };
+
+  return rb_class_new_instance(6, args, VoidElementClosingTagError);
+};
+
+static VALUE rb_unclosed_element_error_from_c_struct(UNCLOSED_ELEMENT_ERROR_T* unclosed_element_error) {
+  if (unclosed_element_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &unclosed_element_error->base;
+
+  VALUE Herb = rb_define_module("Herb");
+  VALUE Errors = rb_define_module_under(Herb, "Errors");
+  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
+  VALUE UnclosedElementError = rb_define_class_under(Errors, "UnclosedElementError", Error);
+
+  VALUE type = rb_str_new_cstr(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_str_new_cstr(error->message);
+
+  VALUE unclosed_element_error_opening_tag = rb_token_from_c_struct(unclosed_element_error->opening_tag);
+
+  VALUE args[4] = {
+    type,
+    location,
+    message,
+    unclosed_element_error_opening_tag
+  };
+
+  return rb_class_new_instance(4, args, UnclosedElementError);
+};
+
+static VALUE rb_ruby_parse_error_from_c_struct(RUBY_PARSE_ERROR_T* ruby_parse_error) {
+  if (ruby_parse_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &ruby_parse_error->base;
+
+  VALUE Herb = rb_define_module("Herb");
+  VALUE Errors = rb_define_module_under(Herb, "Errors");
+  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
+  VALUE RubyParseError = rb_define_class_under(Errors, "RubyParseError", Error);
+
+  VALUE type = rb_str_new_cstr(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_str_new_cstr(error->message);
+
+  VALUE ruby_parse_error_error_message = rb_str_new_cstr(ruby_parse_error->error_message);
+  VALUE ruby_parse_error_diagnostic_id = rb_str_new_cstr(ruby_parse_error->diagnostic_id);
+  VALUE ruby_parse_error_level = rb_str_new_cstr(ruby_parse_error->level);
+
+  VALUE args[6] = {
+    type,
+    location,
+    message,
+    ruby_parse_error_error_message,
+    ruby_parse_error_diagnostic_id,
+    ruby_parse_error_level
+  };
+
+  return rb_class_new_instance(6, args, RubyParseError);
+};
+
+
+VALUE rb_error_from_c_struct(ERROR_T* error) {
+  if (!error) { return Qnil; }
+
+  switch (error->type) {
+    case UNEXPECTED_ERROR: return rb_unexpected_error_from_c_struct((UNEXPECTED_ERROR_T*) error); break;
+    case UNEXPECTED_TOKEN_ERROR: return rb_unexpected_token_error_from_c_struct((UNEXPECTED_TOKEN_ERROR_T*) error); break;
+    case MISSING_OPENING_TAG_ERROR: return rb_missing_opening_tag_error_from_c_struct((MISSING_OPENING_TAG_ERROR_T*) error); break;
+    case MISSING_CLOSING_TAG_ERROR: return rb_missing_closing_tag_error_from_c_struct((MISSING_CLOSING_TAG_ERROR_T*) error); break;
+    case TAG_NAMES_MISMATCH_ERROR: return rb_tag_names_mismatch_error_from_c_struct((TAG_NAMES_MISMATCH_ERROR_T*) error); break;
+    case QUOTES_MISMATCH_ERROR: return rb_quotes_mismatch_error_from_c_struct((QUOTES_MISMATCH_ERROR_T*) error); break;
+    case VOID_ELEMENT_CLOSING_TAG_ERROR: return rb_void_element_closing_tag_error_from_c_struct((VOID_ELEMENT_CLOSING_TAG_ERROR_T*) error); break;
+    case UNCLOSED_ELEMENT_ERROR: return rb_unclosed_element_error_from_c_struct((UNCLOSED_ELEMENT_ERROR_T*) error); break;
+    case RUBY_PARSE_ERROR: return rb_ruby_parse_error_from_c_struct((RUBY_PARSE_ERROR_T*) error); break;
+  }
+
+  return Qnil;
+}
+
+VALUE rb_errors_array_from_c_array(array_T* array) {
+  VALUE rb_array = rb_ary_new();
+
+  if (array) {
+    for (size_t i = 0; i < array_size(array); i++) {
+      ERROR_T* child_node = (ERROR_T*) array_get(array, i);
+
+      if (child_node) {
+        VALUE rb_child = rb_error_from_c_struct(child_node);
+        rb_ary_push(rb_array, rb_child);
+      }
+    }
+  }
+
+  return rb_array;
+}

data/ext/herb/error_helpers.h

@@ -0,0 +1,15 @@
+// NOTE: This file is generated by the templates/template.rb script and should not
+// be modified manually. See /Users/marcoroth/Development/herb-release/templates/ext/herb/error_helpers.h.erb
+
+#ifndef HERB_EXTENSION_ERROR_HELPERS_H
+#define HERB_EXTENSION_ERROR_HELPERS_H
+
+#include "../../src/include/errors.h"
+#include "../../src/include/herb.h"
+
+#include <ruby.h>
+
+VALUE rb_error_from_c_struct(ERROR_T* error);
+VALUE rb_errors_array_from_c_array(array_T* array);
+
+#endif

data/ext/herb/extconf.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "mkmf"
+
+Dir.chdir(File.expand_path("../..", __dir__)) do
+  system("rake templates", exception: true)
+end
+
+extension_name = "herb"
+
+include_path = File.expand_path("../../src/include", __dir__)
+prism_path = `bundle show prism`.chomp
+prism_src_path = "#{prism_path}/src"
+prism_include_path = "#{prism_path}/include"
+
+$VPATH << "$(srcdir)/../../src"
+$VPATH << prism_src_path
+$VPATH << "#{prism_src_path}/util"
+
+$INCFLAGS << " -I#{prism_include_path}"
+$INCFLAGS << " -I#{include_path}"
+$INCFLAGS << " -I#{prism_src_path}"
+$INCFLAGS << " -I#{prism_src_path}/util"
+
+$CFLAGS << " -DPRISM_EXPORT_SYMBOLS=static "
+
+herb_src_files = Dir.glob("#{$srcdir}/../../src/**/*.c").map { |file| file.delete_prefix("../../../../ext/herb/") }.sort
+
+prism_main_files = %w[
+  diagnostic.c
+  encoding.c
+  node.c
+  options.c
+  pack.c
+  prettyprint.c
+  prism.c
+  regexp.c
+  serialize.c
+  static_literals.c
+  token_type.c
+]
+
+prism_util_files = %w[
+  pm_buffer.c
+  pm_char.c
+  pm_constant_pool.c
+  pm_integer.c
+  pm_list.c
+  pm_memchr.c
+  pm_newline_list.c
+  pm_string.c
+  pm_strncasecmp.c
+  pm_strpbrk.c
+]
+
+core_src_files = %w[
+  extension.c
+  nodes.c
+  error_helpers.c
+  extension_helpers.c
+]
+
+$srcs = core_src_files + herb_src_files + prism_main_files + prism_util_files
+
+puts "Sources to be compiled: #{$srcs.inspect}"
+
+abort("could not find prism.h") unless find_header("prism.h")
+abort("could not find herb.h") unless find_header("herb.h")
+
+abort("could not find nodes.h (run `ruby templates/template.rb` to generate the file)") unless find_header("nodes.h")
+abort("could not find extension.h") unless find_header("extension.h")
+abort("could not find extension_helpers.h") unless find_header("extension_helpers.h")
+
+create_header
+create_makefile("#{extension_name}/#{extension_name}")

data/ext/herb/extension.c

@@ -0,0 +1,110 @@
+#include <ruby.h>
+
+#include "error_helpers.h"
+#include "extension_helpers.h"
+#include "nodes.h"
+
+#include "../../src/include/analyze.h"
+
+static VALUE Herb_lex(VALUE self, VALUE source) {
+  char* string = (char*) check_string(source);
+
+  array_T* tokens = herb_lex(string);
+
+  return create_lex_result(tokens, source);
+}
+
+static VALUE Herb_lex_file(VALUE self, VALUE path) {
+  char* file_path = (char*) check_string(path);
+  array_T* tokens = herb_lex_file(file_path);
+
+  VALUE source_value = read_file_to_ruby_string(file_path);
+
+  return create_lex_result(tokens, source_value);
+}
+
+static VALUE Herb_parse(VALUE self, VALUE source) {
+  char* string = (char*) check_string(source);
+
+  AST_DOCUMENT_NODE_T* root = herb_parse(string);
+
+  herb_analyze_parse_tree(root, string);
+
+  return create_parse_result(root, source);
+}
+
+static VALUE Herb_parse_file(VALUE self, VALUE path) {
+  char* file_path = (char*) check_string(path);
+
+  VALUE source_value = read_file_to_ruby_string(file_path);
+  char* string = (char*) check_string(source_value);
+
+  AST_DOCUMENT_NODE_T* root = herb_parse(string);
+
+  return create_parse_result(root, source_value);
+}
+
+static VALUE Herb_lex_to_json(VALUE self, VALUE source) {
+  char* string = (char*) check_string(source);
+  buffer_T output;
+
+  if (!buffer_init(&output)) { return Qnil; }
+
+  herb_lex_json_to_buffer(string, &output);
+
+  VALUE result = rb_str_new(output.value, output.length);
+
+  buffer_free(&output);
+
+  return result;
+}
+
+static VALUE Herb_extract_ruby(VALUE self, VALUE source) {
+  char* string = (char*) check_string(source);
+  buffer_T output;
+
+  if (!buffer_init(&output)) { return Qnil; }
+
+  herb_extract_ruby_to_buffer(string, &output);
+
+  VALUE result = rb_str_new_cstr(output.value);
+  buffer_free(&output);
+
+  return result;
+}
+
+static VALUE Herb_extract_html(VALUE self, VALUE source) {
+  char* string = (char*) check_string(source);
+  buffer_T output;
+
+  if (!buffer_init(&output)) { return Qnil; }
+
+  herb_extract_html_to_buffer(string, &output);
+
+  VALUE result = rb_str_new_cstr(output.value);
+  buffer_free(&output);
+
+  return result;
+}
+
+static VALUE Herb_version(VALUE self) {
+  VALUE gem_version = rb_const_get(self, rb_intern("VERSION"));
+  VALUE libherb_version = rb_str_new_cstr(herb_version());
+  VALUE libprism_version = rb_str_new_cstr(herb_prism_version());
+  VALUE format_string = rb_str_new_cstr("herb gem v%s, libprism v%s, libherb v%s (Ruby C native extension)");
+
+  return rb_funcall(rb_mKernel, rb_intern("sprintf"), 4, format_string, gem_version, libprism_version, libherb_version);
+}
+
+void Init_herb(void) {
+  VALUE Herb = rb_define_module("Herb");
+
+  rb_define_singleton_method(Herb, "parse", Herb_parse, 1);
+  rb_define_singleton_method(Herb, "lex", Herb_lex, 1);
+  rb_define_singleton_method(Herb, "parse_file", Herb_parse_file, 1);
+  rb_define_singleton_method(Herb, "lex_file", Herb_lex_file, 1);
+  rb_define_singleton_method(Herb, "lex_to_json", Herb_lex_to_json, 1);
+  rb_define_singleton_method(Herb, "extract_ruby", Herb_extract_ruby, 1);
+  rb_define_singleton_method(Herb, "extract_html", Herb_extract_html, 1);
+  rb_define_singleton_method(Herb, "version", Herb_version, 0);
+}

data/ext/herb/extension.h

@@ -0,0 +1,6 @@
+#ifndef HERB_EXTENSION_H
+#define HERB_EXTENSION_H
+
+void Init_herb(void);
+
+#endif

data/ext/herb/extension_helpers.c

@@ -0,0 +1,117 @@
+#include <ruby.h>
+
+#include "extension_helpers.h"
+#include "nodes.h"
+
+#include "../../src/include/herb.h"
+#include "../../src/include/io.h"
+#include "../../src/include/location.h"
+#include "../../src/include/position.h"
+#include "../../src/include/token.h"
+
+const char* check_string(VALUE value) {
+  if (NIL_P(value)) { return NULL; }
+
+  if (!RB_TYPE_P(value, T_STRING)) {
+    rb_raise(rb_eTypeError, "wrong argument type %" PRIsVALUE " (expected String)", rb_obj_class(value));
+  }
+
+  return RSTRING_PTR(value);
+}
+
+VALUE rb_position_from_c_struct(position_T* position) {
+  if (!position) { return Qnil; }
+
+  VALUE args[2];
+  args[0] = SIZET2NUM(position->line);
+  args[1] = SIZET2NUM(position->column);
+
+  VALUE Herb = rb_define_module("Herb");
+  VALUE Position = rb_define_class_under(Herb, "Position", rb_cObject);
+
+  return rb_class_new_instance(2, args, Position);
+}
+
+VALUE rb_location_from_c_struct(location_T* location) {
+  if (!location) { return Qnil; }
+
+  VALUE args[2];
+  args[0] = rb_position_from_c_struct(location->start);
+  args[1] = rb_position_from_c_struct(location->end);
+
+  VALUE Herb = rb_define_module("Herb");
+  VALUE Location = rb_define_class_under(Herb, "Location", rb_cObject);
+
+  return rb_class_new_instance(2, args, Location);
+}
+
+VALUE rb_range_from_c_struct(range_T* range) {
+  if (!range) { return Qnil; }
+
+  VALUE args[2];
+  args[0] = SIZET2NUM(range->from);
+  args[1] = SIZET2NUM(range->to);
+
+  VALUE Herb = rb_define_module("Herb");
+  VALUE Range = rb_define_class_under(Herb, "Range", rb_cObject);
+
+  return rb_class_new_instance(2, args, Range);
+}
+
+VALUE rb_token_from_c_struct(token_T* token) {
+  if (!token) { return Qnil; }
+
+  VALUE value = token->value ? rb_str_new_cstr(token->value) : Qnil;
+
+  VALUE range = rb_range_from_c_struct(token->range);
+  VALUE location = rb_location_from_c_struct(token->location);
+  VALUE type = rb_str_new_cstr(token_type_to_string(token->type));
+
+  VALUE args[4] = { value, range, location, type };
+
+  VALUE Herb = rb_define_module("Herb");
+  VALUE Token = rb_define_class_under(Herb, "Token", rb_cObject);
+
+  return rb_class_new_instance(4, args, Token);
+}
+
+VALUE create_lex_result(array_T* tokens, VALUE source) {
+  VALUE value = rb_ary_new();
+  VALUE warnings = rb_ary_new();
+  VALUE errors = rb_ary_new();
+
+  for (size_t i = 0; i < array_size(tokens); i++) {
+    token_T* token = array_get(tokens, i);
+    if (token != NULL) { rb_ary_push(value, rb_token_from_c_struct(token)); }
+  }
+
+  VALUE Herb = rb_define_module("Herb");
+  VALUE Result = rb_define_class_under(Herb, "Result", rb_cObject);
+  VALUE LexResult = rb_define_class_under(Herb, "LexResult", Result);
+
+  herb_free_tokens(&tokens);
+  VALUE args[4] = { value, source, warnings, errors };
+  return rb_class_new_instance(4, args, LexResult);
+}
+
+VALUE create_parse_result(AST_DOCUMENT_NODE_T* root, VALUE source) {
+  VALUE value = rb_node_from_c_struct((AST_NODE_T*) root);
+  VALUE warnings = rb_ary_new();
+  VALUE errors = rb_ary_new();
+
+  VALUE Herb = rb_define_module("Herb");
+  VALUE Result = rb_define_class_under(Herb, "Result", rb_cObject);
+  VALUE ParseResult = rb_define_class_under(Herb, "ParseResult", Result);
+
+  VALUE args[4] = { value, source, warnings, errors };
+  return rb_class_new_instance(4, args, ParseResult);
+}
+
+VALUE read_file_to_ruby_string(const char* file_path) {
+  char* source = herb_read_file(file_path);
+  VALUE source_value = rb_str_new_cstr(source);
+
+  free(source);
+
+  return source_value;
+}

data/ext/herb/extension_helpers.h

@@ -0,0 +1,24 @@
+#ifndef HERB_EXTENSION_HERB_H
+#define HERB_EXTENSION_HERB_H
+
+#include <ruby.h>
+
+#include "../../src/include/herb.h"
+#include "../../src/include/location.h"
+#include "../../src/include/position.h"
+#include "../../src/include/range.h"
+#include "../../src/include/token.h"
+
+const char* check_string(VALUE value);
+VALUE read_file_to_ruby_string(const char* file_path);
+
+VALUE rb_position_from_c_struct(position_T* position);
+VALUE rb_location_from_c_struct(location_T* location);
+
+VALUE rb_token_from_c_struct(token_T* token);
+VALUE rb_range_from_c_struct(range_T* range);
+
+VALUE create_lex_result(array_T* tokens, VALUE source);
+VALUE create_parse_result(AST_DOCUMENT_NODE_T* root, VALUE source);
+
+#endif