herb 0.8.9-arm-linux-gnu → 0.8.10-arm-linux-gnu

data/src/extract.c

@@ -3,7 +3,9 @@
 #include "include/lexer.h"
 #include "include/util/hb_array.h"
 #include "include/util/hb_buffer.h"
+#include "include/util/string.h"
 
+#include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -22,11 +24,11 @@ void herb_extract_ruby_to_buffer(const char* source, hb_buffer_T* output) {
       }
 
       case TOKEN_ERB_START: {
-        if (strcmp(token->value, "<%#") == 0) {
+        if (string_equals(token->value, "<%#")) {
           skip_erb_content = true;
           is_comment_tag = true;
-        } else if (strcmp(token->value, "<%%") == 0 || strcmp(token->value, "<%%=") == 0
-                   || strcmp(token->value, "<%graphql") == 0) {
+        } else if (string_equals(token->value, "<%%") || string_equals(token->value, "<%%=")
+                   || string_equals(token->value, "<%graphql")) {
           skip_erb_content = true;
           is_comment_tag = false;
         } else {
@@ -129,6 +131,7 @@ char* herb_extract(const char* source, const herb_extract_language_T language) {
   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;
+    default: assert(0 && "invalid extract language");
   }
 
   return output.value;

data/src/include/analyze_helpers.h

@@ -34,26 +34,29 @@ bool is_brace_block(pm_location_t opening_location);
 bool is_closing_brace(pm_location_t location);
 bool has_valid_block_closing(pm_location_t opening_loc, pm_location_t closing_loc);
 
-bool search_if_nodes(const pm_node_t* node, void* data);
+bool search_begin_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_case_match_nodes(const pm_node_t* node, void* data);
-bool search_while_nodes(const pm_node_t* node, void* data);
+bool search_case_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_in_nodes(analyzed_ruby_T* analyzed);
-bool search_rescue_nodes(analyzed_ruby_T* analyzed);
-bool search_ensure_nodes(analyzed_ruby_T* analyzed);
-bool search_yield_nodes(const pm_node_t* node, void* data);
+bool search_if_nodes(const pm_node_t* node, void* data);
+bool search_in_nodes(const pm_node_t* node, void* data);
 bool search_then_keywords(const pm_node_t* node, void* data);
 bool search_unclosed_control_flows(const pm_node_t* node, void* data);
+bool search_unless_nodes(const pm_node_t* node, void* data);
+bool search_until_nodes(const pm_node_t* node, void* data);
+bool search_when_nodes(const pm_node_t* node, void* data);
+bool search_while_nodes(const pm_node_t* node, void* data);
+bool search_yield_nodes(const pm_node_t* node, void* data);
+
+bool search_unexpected_block_closing_nodes(analyzed_ruby_T* analyzed);
+bool search_unexpected_else_nodes(analyzed_ruby_T* analyzed);
+bool search_unexpected_elsif_nodes(analyzed_ruby_T* analyzed);
+bool search_unexpected_end_nodes(analyzed_ruby_T* analyzed);
+bool search_unexpected_ensure_nodes(analyzed_ruby_T* analyzed);
+bool search_unexpected_in_nodes(analyzed_ruby_T* analyzed);
+bool search_unexpected_rescue_nodes(analyzed_ruby_T* analyzed);
+bool search_unexpected_when_nodes(analyzed_ruby_T* analyzed);
 
 void check_erb_node_for_missing_end(const AST_NODE_T* node);
 

data/src/include/errors.h

@@ -24,6 +24,7 @@ typedef enum {
   ERB_CONTROL_FLOW_SCOPE_ERROR,
   MISSINGERB_END_TAG_ERROR,
   ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR,
+  ERB_CASE_WITH_CONDITIONS_ERROR,
 } error_type_T;
 
 typedef struct ERROR_STRUCT {
@@ -102,6 +103,11 @@ typedef struct {
   /* no additional fields */
 } ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T;
 
+typedef struct {
+  ERROR_T base;
+  /* no additional fields */
+} ERB_CASE_WITH_CONDITIONS_ERROR_T;
+
 UNEXPECTED_ERROR_T* unexpected_error_init(const char* description, const char* expected, const char* found, position_T start, position_T end);
 void append_unexpected_error(const char* description, const char* expected, const char* found, position_T start, position_T end, hb_array_T* errors);
 UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error_init(token_type_T expected_type, token_T* found, position_T start, position_T end);
@@ -126,6 +132,8 @@ MISSINGERB_END_TAG_ERROR_T* missingerb_end_tag_error_init(const char* keyword, p
 void append_missingerb_end_tag_error(const char* keyword, position_T start, position_T end, hb_array_T* errors);
 ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error_init(position_T start, position_T end);
 void append_erb_multiple_blocks_in_tag_error(position_T start, position_T end, hb_array_T* errors);
+ERB_CASE_WITH_CONDITIONS_ERROR_T* erb_case_with_conditions_error_init(position_T start, position_T end);
+void append_erb_case_with_conditions_error(position_T start, position_T end, hb_array_T* errors);
 
 void error_init(ERROR_T* error, error_type_T type, position_T start, position_T end);
 

data/src/include/util/string.h

@@ -0,0 +1,11 @@
+#ifndef HERB_UTILS_STRING_H
+#define HERB_UTILS_STRING_H
+
+#include <stdbool.h>
+#include <string.h>
+
+static inline bool string_equals(const char* a, const char* b) {
+  return strcmp(a, b) == 0;
+}
+
+#endif

data/src/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.8.9"
+#define HERB_VERSION "0.8.10"
 
 #endif

data/src/main.c

@@ -9,8 +9,10 @@
 #include "include/io.h"
 #include "include/ruby_parser.h"
 #include "include/util/hb_buffer.h"
+#include "include/util/string.h"
 
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <time.h>
 
@@ -34,22 +36,22 @@ void print_time_diff(const struct timespec start, const struct timespec end, con
 
 int main(const int argc, char* argv[]) {
   if (argc < 2) {
-    printf("./herb [command] [options]\n\n");
+    puts("./herb [command] [options]\n");
 
-    printf("Herb 🌿 Powerful and seamless HTML-aware ERB parsing and tooling.\n\n");
+    puts("Herb 🌿 Powerful and seamless HTML-aware ERB parsing and tooling.\n");
 
-    printf("./herb lex [file]      -  Lex a file\n");
-    printf("./herb parse [file]    -  Parse a file\n");
-    printf("./herb ruby [file]     -  Extract Ruby from a file\n");
-    printf("./herb html [file]     -  Extract HTML from a file\n");
-    printf("./herb prism [file]    -  Extract Ruby from a file and parse the Ruby source with Prism\n");
+    puts("./herb lex [file]      -  Lex a file");
+    puts("./herb parse [file]    -  Parse a file");
+    puts("./herb ruby [file]     -  Extract Ruby from a file");
+    puts("./herb html [file]     -  Extract HTML from a file");
+    puts("./herb prism [file]    -  Extract Ruby from a file and parse the Ruby source with Prism");
 
-    return 1;
+    return EXIT_FAILURE;
   }
 
   if (argc < 3) {
-    printf("Please specify input file.\n");
-    return 1;
+    puts("Please specify input file.");
+    return EXIT_FAILURE;
   }
 
   hb_buffer_T output;
@@ -61,38 +63,20 @@ int main(const int argc, char* argv[]) {
   struct timespec start, end;
   clock_gettime(CLOCK_MONOTONIC, &start);
 
-  if (strcmp(argv[1], "visit") == 0) {
-    AST_DOCUMENT_NODE_T* root = herb_parse(source, NULL);
-    clock_gettime(CLOCK_MONOTONIC, &end);
-
-    herb_analyze_parse_tree(root, source);
-
-    ast_pretty_print_node((AST_NODE_T*) root, 0, 0, &output);
-    printf("%s\n", output.value);
-
-    print_time_diff(start, end, "visiting");
-
-    ast_node_free((AST_NODE_T*) root);
-    free(output.value);
-    free(source);
-
-    return 0;
-  }
-
-  if (strcmp(argv[1], "lex") == 0) {
+  if (string_equals(argv[1], "lex")) {
     herb_lex_to_buffer(source, &output);
     clock_gettime(CLOCK_MONOTONIC, &end);
 
-    printf("%s\n", output.value);
+    puts(output.value);
     print_time_diff(start, end, "lexing");
 
     free(output.value);
     free(source);
 
-    return 0;
+    return EXIT_SUCCESS;
   }
 
-  if (strcmp(argv[1], "parse") == 0) {
+  if (string_equals(argv[1], "parse")) {
     AST_DOCUMENT_NODE_T* root = herb_parse(source, NULL);
 
     herb_analyze_parse_tree(root, source);
@@ -100,11 +84,11 @@ int main(const int argc, char* argv[]) {
     clock_gettime(CLOCK_MONOTONIC, &end);
 
     int silent = 0;
-    if (argc > 3 && strcmp(argv[3], "--silent") == 0) { silent = 1; }
+    if (argc > 3 && string_equals(argv[3], "--silent")) { silent = 1; }
 
     if (!silent) {
       ast_pretty_print_node((AST_NODE_T*) root, 0, 0, &output);
-      printf("%s\n", output.value);
+      puts(output.value);
 
       print_time_diff(start, end, "parsing");
     }
@@ -113,36 +97,36 @@ int main(const int argc, char* argv[]) {
     free(output.value);
     free(source);
 
-    return 0;
+    return EXIT_SUCCESS;
   }
 
-  if (strcmp(argv[1], "ruby") == 0) {
+  if (string_equals(argv[1], "ruby")) {
     herb_extract_ruby_to_buffer(source, &output);
     clock_gettime(CLOCK_MONOTONIC, &end);
 
-    printf("%s\n", output.value);
+    puts(output.value);
     print_time_diff(start, end, "extracting Ruby");
 
     free(output.value);
     free(source);
 
-    return 0;
+    return EXIT_SUCCESS;
   }
 
-  if (strcmp(argv[1], "html") == 0) {
+  if (string_equals(argv[1], "html")) {
     herb_extract_html_to_buffer(source, &output);
     clock_gettime(CLOCK_MONOTONIC, &end);
 
-    printf("%s\n", output.value);
+    puts(output.value);
     print_time_diff(start, end, "extracting HTML");
 
     free(output.value);
     free(source);
 
-    return 0;
+    return EXIT_SUCCESS;
   }
 
-  if (strcmp(argv[1], "prism") == 0) {
+  if (string_equals(argv[1], "prism")) {
     printf("HTML+ERB File: \n%s\n", source);
 
     char* ruby_source = herb_extract(source, HERB_EXTRACT_LANGUAGE_RUBY);
@@ -150,9 +134,13 @@ int main(const int argc, char* argv[]) {
 
     herb_parse_ruby_to_stdout(ruby_source);
 
-    return 0;
+    free(ruby_source);
+    free(output.value);
+    free(source);
+
+    return EXIT_SUCCESS;
   }
 
   printf("Unknown Command: %s\n", argv[1]);
-  return 1;
+  return EXIT_FAILURE;
 }

data/src/parser.c

@@ -12,6 +12,7 @@
 #include "include/util/hb_array.h"
 #include "include/util/hb_buffer.h"
 #include "include/util/hb_string.h"
+#include "include/util/string.h"
 #include "include/visitor.h"
 
 #include <stdio.h>
@@ -346,7 +347,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
   while (!token_is(parser, TOKEN_EOF)
          && !(
            token_is(parser, TOKEN_QUOTE) && opening_quote != NULL
-           && strcmp(parser->current_token->value, opening_quote->value) == 0
+           && string_equals(parser->current_token->value, opening_quote->value)
          )) {
     if (token_is(parser, TOKEN_ERB_START)) {
       parser_append_literal_node_from_buffer(parser, &buffer, children, start);
@@ -364,7 +365,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
       token_T* next_token = lexer_next_token(parser->lexer);
 
       if (next_token && next_token->type == TOKEN_QUOTE && opening_quote != NULL
-          && strcmp(next_token->value, opening_quote->value) == 0) {
+          && string_equals(next_token->value, opening_quote->value)) {
         hb_buffer_append(&buffer, parser->current_token->value);
         hb_buffer_append(&buffer, next_token->value);
 
@@ -387,7 +388,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
   }
 
   if (token_is(parser, TOKEN_QUOTE) && opening_quote != NULL
-      && strcmp(parser->current_token->value, opening_quote->value) == 0) {
+      && string_equals(parser->current_token->value, opening_quote->value)) {
     lexer_state_snapshot_T saved_state = lexer_save_state(parser->lexer);
 
     token_T* potential_closing = parser->current_token;
@@ -415,7 +416,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
       while (!token_is(parser, TOKEN_EOF)
              && !(
                token_is(parser, TOKEN_QUOTE) && opening_quote != NULL
-               && strcmp(parser->current_token->value, opening_quote->value) == 0
+               && string_equals(parser->current_token->value, opening_quote->value)
              )) {
         if (token_is(parser, TOKEN_ERB_START)) {
           parser_append_literal_node_from_buffer(parser, &buffer, children, start);
@@ -445,7 +446,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
 
   token_T* closing_quote = parser_consume_expected(parser, TOKEN_QUOTE, errors);
 
-  if (opening_quote != NULL && closing_quote != NULL && strcmp(opening_quote->value, closing_quote->value) != 0) {
+  if (opening_quote != NULL && closing_quote != NULL && !string_equals(opening_quote->value, closing_quote->value)) {
     append_quotes_mismatch_error(
       opening_quote,
       closing_quote,

data/vendor/prism/config.yml

@@ -1269,17 +1269,17 @@ nodes:
       - name: opening_loc
         type: location
         comment: |
-          Represents the location of the opening `|`.
+          Represents the location of the opening `{` or `do`.
 
               [1, 2, 3].each { |i| puts x }
-                               ^
+                             ^
       - name: closing_loc
         type: location
         comment: |
-          Represents the location of the closing `|`.
+          Represents the location of the closing `}` or `end`.
 
               [1, 2, 3].each { |i| puts x }
-                                 ^
+                                          ^
     comment: |
       Represents a block of ruby code.
 

data/vendor/prism/include/prism/ast.h

@@ -1826,20 +1826,20 @@ typedef struct pm_block_node {
     /**
      * BlockNode#opening_loc
      *
-     * Represents the location of the opening `|`.
+     * Represents the location of the opening `{` or `do`.
      *
      *     [1, 2, 3].each { |i| puts x }
-     *                      ^
+     *                    ^
      */
     pm_location_t opening_loc;
 
     /**
      * BlockNode#closing_loc
      *
-     * Represents the location of the closing `|`.
+     * Represents the location of the closing `}` or `end`.
      *
      *     [1, 2, 3].each { |i| puts x }
-     *                        ^
+     *                                 ^
      */
     pm_location_t closing_loc;
 } pm_block_node_t;

data/vendor/prism/include/prism/version.h

@@ -14,7 +14,7 @@
 /**
  * The minor version of the Prism library as an int.
  */
-#define PRISM_VERSION_MINOR 8
+#define PRISM_VERSION_MINOR 9
 
 /**
  * The patch version of the Prism library as an int.
@@ -24,6 +24,6 @@
 /**
  * The version of the Prism library as a constant string.
  */
-#define PRISM_VERSION "1.8.0"
+#define PRISM_VERSION "1.9.0"
 
 #endif

data/vendor/prism/src/prism.c

@@ -12438,7 +12438,7 @@ expect1_opening(pm_parser_t *parser, pm_token_type_t type, pm_diagnostic_id_t di
 
     pm_parser_err(parser, opening->start, opening->end, diag_id);
 
-    parser->previous.start = opening->end;
+    parser->previous.start = parser->previous.end;
     parser->previous.type = PM_TOKEN_MISSING;
 }
 

data/vendor/prism/templates/java/org/prism/Loader.java.erb

@@ -101,7 +101,7 @@ public class Loader {
         expect((byte) 'M', "incorrect prism header");
 
         expect((byte) 1, "prism major version does not match");
-        expect((byte) 8, "prism minor version does not match");
+        expect((byte) 9, "prism minor version does not match");
         expect((byte) 0, "prism patch version does not match");
 
         expect((byte) 1, "Loader.java requires no location fields in the serialized output");

data/vendor/prism/templates/javascript/src/deserialize.js.erb

@@ -1,7 +1,7 @@
 import * as nodes from "./nodes.js";
 
 const MAJOR_VERSION = 1;
-const MINOR_VERSION = 8;
+const MINOR_VERSION = 9;
 const PATCH_VERSION = 0;
 
 // The DataView getFloat64 function takes an optional second argument that

data/vendor/prism/templates/lib/prism/node.rb.erb

@@ -183,25 +183,13 @@ module Prism
     def tunnel(line, column)
       queue = [self] #: Array[Prism::node]
       result = [] #: Array[Prism::node]
+      offset = source.byte_offset(line, column)
 
       while (node = queue.shift)
         result << node
 
         node.each_child_node do |child_node|
-          child_location = child_node.location
-
-          start_line = child_location.start_line
-          end_line = child_location.end_line
-
-          if start_line == end_line
-            if line == start_line && column >= child_location.start_column && column < child_location.end_column
-              queue << child_node
-              break
-            end
-          elsif (line == start_line && column >= child_location.start_column) || (line == end_line && column < child_location.end_column)
-            queue << child_node
-            break
-          elsif line > start_line && line < end_line
+          if child_node.start_offset <= offset && offset < child_node.end_offset
             queue << child_node
             break
           end
@@ -212,7 +200,7 @@ module Prism
     end
 
     # Returns the first node that matches the given block when visited in a
-    # depth-first search. This is useful for finding a node that matches a
+    # breadth-first search. This is useful for finding a node that matches a
     # particular condition.
     #
     #     node.breadth_first_search { |node| node.node_id == node_id }
@@ -227,6 +215,26 @@ module Prism
 
       nil
     end
+    alias find breadth_first_search
+
+    # Returns all of the nodes that match the given block when visited in a
+    # breadth-first search. This is useful for finding all nodes that match a
+    # particular condition.
+    #
+    #     node.breadth_first_search_all { |node| node.is_a?(Prism::CallNode) }
+    #
+    def breadth_first_search_all(&block)
+      queue = [self] #: Array[Prism::node]
+      results = [] #: Array[Prism::node]
+
+      while (node = queue.shift)
+        results << node if yield node
+        queue.concat(node.compact_child_nodes)
+      end
+
+      results
+    end
+    alias find_all breadth_first_search_all
 
     # Returns a list of the fields that exist for this node class. Fields
     # describe the structure of the node. This kind of reflection is useful for

data/vendor/prism/templates/lib/prism/serialize.rb.erb

@@ -10,7 +10,7 @@ module Prism
 
     # The minor version of prism that we are expecting to find in the serialized
     # strings.
-    MINOR_VERSION = 8
+    MINOR_VERSION = 9
 
     # The patch version of prism that we are expecting to find in the serialized
     # strings.

data/vendor/prism/templates/rbi/prism/node.rbi.erb

@@ -49,6 +49,9 @@ class Prism::Node
   sig { params(block: T.proc.params(node: Prism::Node).returns(T::Boolean)).returns(T.nilable(Prism::Node)) }
   def breadth_first_search(&block); end
 
+  sig { params(block: T.proc.params(node: Prism::Node).returns(T::Boolean)).returns(T::Array[Prism::Node]) }
+  def breadth_first_search_all(&block); end
+
   sig { abstract.params(visitor: Prism::Visitor).returns(T.untyped) }
   def accept(visitor); end
 

data/vendor/prism/templates/sig/prism/node.rbs.erb

@@ -25,6 +25,9 @@ module Prism
     def to_dot: () -> String
     def tunnel: (Integer line, Integer column) -> Array[Prism::node]
     def breadth_first_search: () { (Prism::node) -> bool } -> Prism::node?
+    alias find breadth_first_search
+    def breadth_first_search_all: () { (Prism::node) -> bool } -> Array[Prism::node]
+    alias find_all breadth_first_search_all
     def newline!: (Array[untyped]) -> void
 
     def save: (_Repository repository) -> void

data/vendor/prism/templates/sig/prism.rbs.erb

@@ -23,15 +23,16 @@ module Prism
 
   def self.<%= method %>: (
     String source,
+    ?command_line: String,
     ?encoding: Encoding | false,
     ?filepath: String,
     ?freeze: bool,
     ?frozen_string_literal: bool,
     ?line: Integer,
     ?main_script: bool,
-    ?offset: Integer,
+    ?partial_script: bool,
     ?scopes: Array[Array[Symbol]],
-    ?verbose: bool
+    ?version: String
   ) -> <%= return_type %>
   <%- end -%>
 
@@ -41,10 +42,6 @@ module Prism
     ?bool freeze
   ) -> ParseResult
 
-  def self.lex_ripper: (
-    String source
-  ) -> Array[[[Integer, Integer], Symbol, String, untyped]]
-
   # Methods taking a path to a Ruby file:
   <%-
     {
@@ -61,14 +58,15 @@ module Prism
 
   def self.<%= method %>: (
     String filepath,
+    ?command_line: String,
     ?encoding: Encoding | false,
     ?freeze: bool,
     ?frozen_string_literal: bool,
     ?line: Integer,
     ?main_script: bool,
-    ?offset: Integer,
+    ?partial_script: bool,
     ?scopes: Array[Array[Symbol]],
-    ?verbose: bool
+    ?version: String
   ) -> <%= return_type %>
   <%- end -%>
 
@@ -78,15 +76,16 @@ module Prism
 
   def self.parse_stream: (
     _Stream stream,
+    ?command_line: String,
     ?encoding: Encoding | false,
     ?filepath: String,
     ?freeze: bool,
     ?frozen_string_literal: bool,
     ?line: Integer,
     ?main_script: bool,
-    ?offset: Integer,
+    ?partial_script: bool,
     ?scopes: Array[Array[Symbol]],
-    ?verbose: bool
+    ?version: String
   ) -> ParseResult
 
   def self.scope: (?locals: Array[Symbol], ?forwarding: Array[Symbol]) -> Scope

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: herb
 version: !ruby/object:Gem::Version
-  version: 0.8.9
+  version: 0.8.10
 platform: arm-linux-gnu
 authors:
 - Marco Roth
@@ -153,6 +153,7 @@ files:
 - src/include/util/hb_narray.h
 - src/include/util/hb_string.h
 - src/include/util/hb_system.h
+- src/include/util/string.h
 - src/include/version.h
 - src/include/visitor.h
 - src/io.c