herb 0.1.1-x86-linux-gnu → 0.2.0-x86-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75cad17d367e32029ace08418c524393db0115c5621f55e250ac43ff2b8ca443
-  data.tar.gz: 18bea6391d7d26ddc92c877521866c1bd593ea6892bc0f134e7bab4ed81d060c
+  metadata.gz: 6057887b415fcab355abaee6d221b8485bd26cab4bea36954b396cc1041e5dca
+  data.tar.gz: 417ba20abcc762eefd122e86686285bdff911bec16ef6994192c9285cd6897b0
 SHA512:
-  metadata.gz: 825f8dcfd459710d29c327ed7da74e3cefe19b238330db0c4d9dea664fc2c628ceeaac7013baf1be87fcdd41c735a8e18585046aff69e0c95112b68cc3af6b2c
-  data.tar.gz: 4917b27cc6580f57bcf31e16a073c212a305ea965ada749244802b4ec165ae4b2c5aa5a8525a4e6f3ea0ad2bb5c4a42427fd85729222c70df7d0d562c33f15af
+  metadata.gz: 0f58f16240608e315917c3ec8295ad75b247d7c3b6ccaf9ad1d902875fae546a1d166723011d69b28995ccfda97d68a3e4683d6e5cc86473a435b80899e9a45e
+  data.tar.gz: d235f68088a5e0fa380c7e9f07c8d2e69cf07a7c6c166a54064b4ba4edca80966c23dcea1b24b8bf3a707375a212889e7a527269f4888318d39075f16630730b

data/Rakefile

@@ -59,7 +59,7 @@ begin
 
   task "gem:native" do
     require "rake_compiler_dock"
-    # sh "bundle config set cache_all true"
+    sh "bundle config set cache_all true"
 
     PLATFORMS.each do |platform|
       RakeCompilerDock.sh "bundle && rake native:#{platform} gem", platform: platform
@@ -75,7 +75,7 @@ begin
       require "rake_compiler_dock"
       require "io/console"
 
-      # sh "bundle config set cache_all true"
+      sh "bundle config set cache_all true"
       sh "cp ~/.gem/gem-*.pem build/gem/ || true"
 
       gemspec_path = File.expand_path("./herb.gemspec", __dir__)
@@ -181,4 +181,22 @@ namespace :parse do
   end
 end
 
+task :rbs_inline do
+  require "open3"
+
+  command = "bundle exec rbs-inline --opt-out --output=sig/ lib/"
+
+  _stdout, stderr, status = Open3.capture3(command)
+
+  puts "Running `#{command}`"
+
+  if stderr.strip == "🎉 Generated 0 RBS files under sig/"
+    puts "RBS files in sig/ are up to date"
+    exit status.exitstatus
+  else
+    puts "RBS files in sig/ are not up to date"
+    exit 1
+  end
+end
+
 task default: [:templates, :make, :compile, :test]

data/ext/herb/extension.c

@@ -1,17 +1,31 @@
 #include <ruby.h>
 
 #include "error_helpers.h"
+#include "extension.h"
 #include "extension_helpers.h"
 #include "nodes.h"
 
 #include "../../src/include/analyze.h"
 
+VALUE mHerb;
+VALUE cPosition;
+VALUE cLocation;
+VALUE cRange;
+VALUE cToken;
+VALUE cResult;
+VALUE cLexResult;
+VALUE cParseResult;
+
 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);
+  VALUE result = create_lex_result(tokens, source);
+
+  herb_free_tokens(&tokens);
+
+  return result;
 }
 
 static VALUE Herb_lex_file(VALUE self, VALUE path) {
@@ -19,8 +33,11 @@ static VALUE Herb_lex_file(VALUE self, VALUE path) {
   array_T* tokens = herb_lex_file(file_path);
 
   VALUE source_value = read_file_to_ruby_string(file_path);
+  VALUE result = create_lex_result(tokens, source_value);
+
+  herb_free_tokens(&tokens);
 
-  return create_lex_result(tokens, source_value);
+  return result;
 }
 
 static VALUE Herb_parse(VALUE self, VALUE source) {
@@ -30,7 +47,11 @@ static VALUE Herb_parse(VALUE self, VALUE source) {
 
   herb_analyze_parse_tree(root, string);
 
-  return create_parse_result(root, source);
+  VALUE result = create_parse_result(root, source);
+
+  ast_node_free((AST_NODE_T*) root);
+
+  return result;
 }
 
 static VALUE Herb_parse_file(VALUE self, VALUE path) {
@@ -41,7 +62,11 @@ static VALUE Herb_parse_file(VALUE self, VALUE path) {
 
   AST_DOCUMENT_NODE_T* root = herb_parse(string);
 
-  return create_parse_result(root, source_value);
+  VALUE result = create_parse_result(root, source_value);
+
+  ast_node_free((AST_NODE_T*) root);
+
+  return result;
 }
 
 static VALUE Herb_lex_to_json(VALUE self, VALUE source) {
@@ -97,14 +122,21 @@ static VALUE Herb_version(VALUE self) {
 }
 
 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);
+  mHerb = rb_define_module("Herb");
+  cPosition = rb_define_class_under(mHerb, "Position", rb_cObject);
+  cLocation = rb_define_class_under(mHerb, "Location", rb_cObject);
+  cRange = rb_define_class_under(mHerb, "Range", rb_cObject);
+  cToken = rb_define_class_under(mHerb, "Token", rb_cObject);
+  cResult = rb_define_class_under(mHerb, "Result", rb_cObject);
+  cLexResult = rb_define_class_under(mHerb, "LexResult", cResult);
+  cParseResult = rb_define_class_under(mHerb, "ParseResult", cResult);
+
+  rb_define_singleton_method(mHerb, "parse", Herb_parse, 1);
+  rb_define_singleton_method(mHerb, "lex", Herb_lex, 1);
+  rb_define_singleton_method(mHerb, "parse_file", Herb_parse_file, 1);
+  rb_define_singleton_method(mHerb, "lex_file", Herb_lex_file, 1);
+  rb_define_singleton_method(mHerb, "lex_to_json", Herb_lex_to_json, 1);
+  rb_define_singleton_method(mHerb, "extract_ruby", Herb_extract_ruby, 1);
+  rb_define_singleton_method(mHerb, "extract_html", Herb_extract_html, 1);
+  rb_define_singleton_method(mHerb, "version", Herb_version, 0);
 }

data/ext/herb/extension.h

@@ -3,4 +3,13 @@
 
 void Init_herb(void);
 
+extern VALUE mHerb;
+extern VALUE cPosition;
+extern VALUE cLocation;
+extern VALUE cRange;
+extern VALUE cToken;
+extern VALUE cResult;
+extern VALUE cLexResult;
+extern VALUE cParseResult;
+
 #endif

data/ext/herb/extension_helpers.c

@@ -1,5 +1,6 @@
 #include <ruby.h>
 
+#include "extension.h"
 #include "extension_helpers.h"
 #include "nodes.h"
 
@@ -26,10 +27,7 @@ VALUE rb_position_from_c_struct(position_T* position) {
   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);
+  return rb_class_new_instance(2, args, cPosition);
 }
 
 VALUE rb_location_from_c_struct(location_T* location) {
@@ -39,10 +37,7 @@ VALUE rb_location_from_c_struct(location_T* location) {
   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);
+  return rb_class_new_instance(2, args, cLocation);
 }
 
 VALUE rb_range_from_c_struct(range_T* range) {
@@ -52,10 +47,7 @@ VALUE rb_range_from_c_struct(range_T* range) {
   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);
+  return rb_class_new_instance(2, args, cRange);
 }
 
 VALUE rb_token_from_c_struct(token_T* token) {
@@ -69,10 +61,7 @@ VALUE rb_token_from_c_struct(token_T* token) {
 
   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);
+  return rb_class_new_instance(4, args, cToken);
 }
 
 VALUE create_lex_result(array_T* tokens, VALUE source) {
@@ -85,13 +74,9 @@ VALUE create_lex_result(array_T* tokens, VALUE source) {
     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);
+
+  return rb_class_new_instance(4, args, cLexResult);
 }
 
 VALUE create_parse_result(AST_DOCUMENT_NODE_T* root, VALUE source) {
@@ -99,12 +84,9 @@ VALUE create_parse_result(AST_DOCUMENT_NODE_T* root, VALUE source) {
   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);
+
+  return rb_class_new_instance(4, args, cParseResult);
 }
 
 VALUE read_file_to_ruby_string(const char* file_path) {

data/ext/herb/nodes.c

@@ -415,7 +415,7 @@ static VALUE rb_erb_content_node_from_c_struct(AST_ERB_CONTENT_NODE_T* erb_conte
   VALUE erb_content_node_tag_opening = rb_token_from_c_struct(erb_content_node->tag_opening);
   VALUE erb_content_node_content = rb_token_from_c_struct(erb_content_node->content);
   VALUE erb_content_node_tag_closing = rb_token_from_c_struct(erb_content_node->tag_closing);
-  /* #<Herb::Template::AnalyzedRubyField:0x00007fffe32e8a20 @name="analyzed_ruby", @options={kind: nil}> */
+  /* #<Herb::Template::AnalyzedRubyField:0x00007ffffed61860 @name="analyzed_ruby", @options={kind: nil}> */
   VALUE erb_content_node_analyzed_ruby = Qnil;
   VALUE erb_content_node_parsed = (erb_content_node->parsed) ? Qtrue : Qfalse;
   VALUE erb_content_node_valid = (erb_content_node->valid) ? Qtrue : Qfalse;
@@ -637,6 +637,44 @@ static VALUE rb_erb_case_node_from_c_struct(AST_ERB_CASE_NODE_T* erb_case_node)
   return rb_class_new_instance(10, args, ERBCaseNode);
 };
 
+static VALUE rb_erb_case_match_node_from_c_struct(AST_ERB_CASE_MATCH_NODE_T* erb_case_match_node) {
+  if (erb_case_match_node == NULL) { return Qnil; }
+
+  AST_NODE_T* node = &erb_case_match_node->base;
+
+  VALUE Herb = rb_define_module("Herb");
+  VALUE AST = rb_define_module_under(Herb, "AST");
+  VALUE Node = rb_define_class_under(AST, "Node", rb_cObject);
+  VALUE ERBCaseMatchNode = rb_define_class_under(AST, "ERBCaseMatchNode", Node);
+
+  VALUE type = rb_str_new_cstr(ast_node_type_to_string(node));
+  VALUE location = rb_location_from_c_struct(node->location);
+  VALUE errors = rb_errors_array_from_c_array(node->errors);
+
+  VALUE erb_case_match_node_tag_opening = rb_token_from_c_struct(erb_case_match_node->tag_opening);
+  VALUE erb_case_match_node_content = rb_token_from_c_struct(erb_case_match_node->content);
+  VALUE erb_case_match_node_tag_closing = rb_token_from_c_struct(erb_case_match_node->tag_closing);
+  VALUE erb_case_match_node_children = rb_nodes_array_from_c_array(erb_case_match_node->children);
+  VALUE erb_case_match_node_conditions = rb_nodes_array_from_c_array(erb_case_match_node->conditions);
+  VALUE erb_case_match_node_else_clause = rb_node_from_c_struct((AST_NODE_T*) erb_case_match_node->else_clause);
+  VALUE erb_case_match_node_end_node = rb_node_from_c_struct((AST_NODE_T*) erb_case_match_node->end_node);
+
+  VALUE args[10] = {
+    type,
+    location,
+    errors,
+    erb_case_match_node_tag_opening,
+    erb_case_match_node_content,
+    erb_case_match_node_tag_closing,
+    erb_case_match_node_children,
+    erb_case_match_node_conditions,
+    erb_case_match_node_else_clause,
+    erb_case_match_node_end_node
+  };
+
+  return rb_class_new_instance(10, args, ERBCaseMatchNode);
+};
+
 static VALUE rb_erb_while_node_from_c_struct(AST_ERB_WHILE_NODE_T* erb_while_node) {
   if (erb_while_node == NULL) { return Qnil; }
 
@@ -881,6 +919,68 @@ static VALUE rb_erb_unless_node_from_c_struct(AST_ERB_UNLESS_NODE_T* erb_unless_
   return rb_class_new_instance(9, args, ERBUnlessNode);
 };
 
+static VALUE rb_erb_yield_node_from_c_struct(AST_ERB_YIELD_NODE_T* erb_yield_node) {
+  if (erb_yield_node == NULL) { return Qnil; }
+
+  AST_NODE_T* node = &erb_yield_node->base;
+
+  VALUE Herb = rb_define_module("Herb");
+  VALUE AST = rb_define_module_under(Herb, "AST");
+  VALUE Node = rb_define_class_under(AST, "Node", rb_cObject);
+  VALUE ERBYieldNode = rb_define_class_under(AST, "ERBYieldNode", Node);
+
+  VALUE type = rb_str_new_cstr(ast_node_type_to_string(node));
+  VALUE location = rb_location_from_c_struct(node->location);
+  VALUE errors = rb_errors_array_from_c_array(node->errors);
+
+  VALUE erb_yield_node_tag_opening = rb_token_from_c_struct(erb_yield_node->tag_opening);
+  VALUE erb_yield_node_content = rb_token_from_c_struct(erb_yield_node->content);
+  VALUE erb_yield_node_tag_closing = rb_token_from_c_struct(erb_yield_node->tag_closing);
+
+  VALUE args[6] = {
+    type,
+    location,
+    errors,
+    erb_yield_node_tag_opening,
+    erb_yield_node_content,
+    erb_yield_node_tag_closing
+  };
+
+  return rb_class_new_instance(6, args, ERBYieldNode);
+};
+
+static VALUE rb_erb_in_node_from_c_struct(AST_ERB_IN_NODE_T* erb_in_node) {
+  if (erb_in_node == NULL) { return Qnil; }
+
+  AST_NODE_T* node = &erb_in_node->base;
+
+  VALUE Herb = rb_define_module("Herb");
+  VALUE AST = rb_define_module_under(Herb, "AST");
+  VALUE Node = rb_define_class_under(AST, "Node", rb_cObject);
+  VALUE ERBInNode = rb_define_class_under(AST, "ERBInNode", Node);
+
+  VALUE type = rb_str_new_cstr(ast_node_type_to_string(node));
+  VALUE location = rb_location_from_c_struct(node->location);
+  VALUE errors = rb_errors_array_from_c_array(node->errors);
+
+  VALUE erb_in_node_tag_opening = rb_token_from_c_struct(erb_in_node->tag_opening);
+  VALUE erb_in_node_content = rb_token_from_c_struct(erb_in_node->content);
+  VALUE erb_in_node_tag_closing = rb_token_from_c_struct(erb_in_node->tag_closing);
+  VALUE erb_in_node_statements = rb_nodes_array_from_c_array(erb_in_node->statements);
+
+  VALUE args[7] = {
+    type,
+    location,
+    errors,
+    erb_in_node_tag_opening,
+    erb_in_node_content,
+    erb_in_node_tag_closing,
+    erb_in_node_statements
+  };
+
+  return rb_class_new_instance(7, args, ERBInNode);
+};
+
 
 VALUE rb_node_from_c_struct(AST_NODE_T* node) {
   if (!node) { return Qnil; }
@@ -906,6 +1006,7 @@ VALUE rb_node_from_c_struct(AST_NODE_T* node) {
     case AST_ERB_BLOCK_NODE: return rb_erb_block_node_from_c_struct((AST_ERB_BLOCK_NODE_T*) node); break;
     case AST_ERB_WHEN_NODE: return rb_erb_when_node_from_c_struct((AST_ERB_WHEN_NODE_T*) node); break;
     case AST_ERB_CASE_NODE: return rb_erb_case_node_from_c_struct((AST_ERB_CASE_NODE_T*) node); break;
+    case AST_ERB_CASE_MATCH_NODE: return rb_erb_case_match_node_from_c_struct((AST_ERB_CASE_MATCH_NODE_T*) node); break;
     case AST_ERB_WHILE_NODE: return rb_erb_while_node_from_c_struct((AST_ERB_WHILE_NODE_T*) node); break;
     case AST_ERB_UNTIL_NODE: return rb_erb_until_node_from_c_struct((AST_ERB_UNTIL_NODE_T*) node); break;
     case AST_ERB_FOR_NODE: return rb_erb_for_node_from_c_struct((AST_ERB_FOR_NODE_T*) node); break;
@@ -913,6 +1014,8 @@ VALUE rb_node_from_c_struct(AST_NODE_T* node) {
     case AST_ERB_ENSURE_NODE: return rb_erb_ensure_node_from_c_struct((AST_ERB_ENSURE_NODE_T*) node); break;
     case AST_ERB_BEGIN_NODE: return rb_erb_begin_node_from_c_struct((AST_ERB_BEGIN_NODE_T*) node); break;
     case AST_ERB_UNLESS_NODE: return rb_erb_unless_node_from_c_struct((AST_ERB_UNLESS_NODE_T*) node); break;
+    case AST_ERB_YIELD_NODE: return rb_erb_yield_node_from_c_struct((AST_ERB_YIELD_NODE_T*) node); break;
+    case AST_ERB_IN_NODE: return rb_erb_in_node_from_c_struct((AST_ERB_IN_NODE_T*) node); break;
   }
 
   return Qnil;

data/herb.gemspec

@@ -22,11 +22,12 @@ Gem::Specification.new do |spec|
 
   spec.files = Dir[
     "herb.gemspec",
-    "License.txt",
+    "LICENSE.txt",
     "Makefile",
     "Rakefile",
     "README.md",
     "lib/**/*.rb",
+    "sig/**/*.rbs",
     "src/**/*.{c,h}",
     "ext/**/*.{c,h}",
     "exe/*"

data/lib/herb/ast/node.rb

@@ -1,16 +1,21 @@
 # frozen_string_literal: true
+# typed: true
 
 module Herb
   module AST
     class Node
-      attr_reader :type, :location, :errors
+      attr_reader :type #: String
+      attr_reader :location #: Location
+      attr_reader :errors #: Array[Herb::Errors::Error]
 
+      #: (String, Location, Array[Herb::Errors::Error]) -> void
       def initialize(type, location, errors = [])
         @type = type
         @location = location
         @errors = errors
       end
 
+      #: () -> serialized_node
       def to_hash
         {
           type: type,
@@ -19,20 +24,29 @@ module Herb
         }
       end
 
+      #: () -> String
+      def class_name
+        self.class.name || "Node"
+      end
+
+      #: () -> String
       def node_name
-        self.class.name.split("::").last
+        class_name.split("::").last || "Node"
       end
 
-      def to_json(*args)
-        to_hash.to_json(*args)
+      #: (?untyped) -> String
+      def to_json(state = nil)
+        to_hash.to_json(state)
       end
 
+      #: (?prefix: String) -> String
       def inspect_errors(prefix: "    ")
         return "" if errors.empty?
 
         "├── errors: #{inspect_array(errors, item_name: "error", prefix: prefix)}"
       end
 
+      #: (Array[Herb::AST::Node|Herb::Errors::Error], ?item_name: String, ?prefix: String) -> String
       def inspect_array(array, item_name: "item", prefix: "    ")
         output = +""
 
@@ -56,6 +70,28 @@ module Herb
 
         output
       end
+
+      #: (?Integer) -> String
+      def tree_inspect(_indent = 0)
+        raise NotImplementedError
+      end
+
+      #: (Visitor) -> void
+      def accept(_visitor)
+        raise NoMethodError, "undefined method `accept' for #{inspect}"
+      end
+
+      #: () -> Array[Herb::AST::Node?]
+      def child_nodes
+        raise NoMethodError, "undefined method `child_nodes' for #{inspect}"
+      end
+
+      alias deconstruct child_nodes
+
+      #: () -> Array[Herb::AST::Node]
+      def compact_child_nodes
+        child_nodes.compact
+      end
     end
   end
 end