herb 0.8.10-arm-linux-gnu → 0.9.1-arm-linux-gnu

data/lib/herb/lex_result.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module Herb
   class LexResult < Result

data/lib/herb/location.rb

@@ -2,6 +2,10 @@
 # typed: true
 
 module Herb
+  #: type serialized_location = {
+  #| start: serialized_position,
+  #| end: serialized_position
+  #| }
   class Location
     attr_reader :start #: Position
     attr_reader :end #: Position
@@ -28,9 +32,9 @@ module Herb
     #: () -> serialized_location
     def to_hash
       {
-        start: start,
-        end: self.end,
-      } #: Herb::serialized_location
+        start: start.to_hash,
+        end: self.end.to_hash,
+      }
     end
 
     #: (?untyped) -> String

data/lib/herb/parse_result.rb

@@ -1,15 +1,25 @@
 # frozen_string_literal: true
+# typed: true
 
 require "json"
 
 module Herb
   class ParseResult < Result
     attr_reader :value #: Herb::AST::DocumentNode
+    attr_reader :options #: Herb::ParserOptions
 
-    #: (Herb::AST::DocumentNode, String, Array[Herb::Warnings::Warning], Array[Herb::Errors::Error]) -> void
-    def initialize(value, source, warnings, errors)
+    #: (Herb::AST::DocumentNode, String, Array[Herb::Warnings::Warning], Array[Herb::Errors::Error], Herb::ParserOptions) -> void
+    def initialize(value, source, warnings, errors, options)
       @value = value
+      @options = options
       super(source, warnings, errors)
+
+      if options.prism_nodes || options.prism_nodes_deep
+        value.source = source
+      elsif options.prism_program
+        # Using `instance_variable_set` doesn't propagate the source being set on the whole tree
+        value.instance_variable_set(:@source, source)
+      end
     end
 
     #: () -> Array[Herb::Errors::Error]

data/lib/herb/parser_options.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Herb
+  class ParserOptions
+    attr_reader :strict #: bool
+    attr_reader :track_whitespace #: bool
+    attr_reader :analyze #: bool
+    attr_reader :action_view_helpers #: bool
+    attr_reader :render_nodes #: bool
+    attr_reader :prism_program #: bool
+    attr_reader :prism_nodes #: bool
+    attr_reader :prism_nodes_deep #: bool
+
+    DEFAULT_STRICT = true #: bool
+    DEFAULT_TRACK_WHITESPACE = false #: bool
+    DEFAULT_ANALYZE = true #: bool
+    DEFAULT_ACTION_VIEW_HELPERS = false #: bool
+    DEFAULT_RENDER_NODES = false #: bool
+    DEFAULT_PRISM_PROGRAM = false #: bool
+    DEFAULT_PRISM_NODES = false #: bool
+    DEFAULT_PRISM_NODES_DEEP = false #: bool
+
+    #: (?strict: bool, ?track_whitespace: bool, ?analyze: bool, ?action_view_helpers: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool) -> void
+    def initialize(strict: DEFAULT_STRICT, track_whitespace: DEFAULT_TRACK_WHITESPACE, analyze: DEFAULT_ANALYZE, action_view_helpers: DEFAULT_ACTION_VIEW_HELPERS, render_nodes: DEFAULT_RENDER_NODES, prism_nodes: DEFAULT_PRISM_NODES, prism_nodes_deep: DEFAULT_PRISM_NODES_DEEP, prism_program: DEFAULT_PRISM_PROGRAM)
+      @strict = strict
+      @track_whitespace = track_whitespace
+      @analyze = analyze
+      @action_view_helpers = action_view_helpers
+      @render_nodes = render_nodes
+      @prism_nodes = prism_nodes
+      @prism_nodes_deep = prism_nodes_deep
+      @prism_program = prism_program
+    end
+
+    #: () -> Hash[Symbol, bool]
+    def to_h
+      {
+        strict: @strict,
+        track_whitespace: @track_whitespace,
+        analyze: @analyze,
+        action_view_helpers: @action_view_helpers,
+        render_nodes: @render_nodes,
+        prism_nodes: @prism_nodes,
+        prism_nodes_deep: @prism_nodes_deep,
+        prism_program: @prism_program,
+      }
+    end
+
+    #: () -> String
+    def inspect
+      "#<#{self.class.name}\n  " \
+        "strict=#{@strict}\n  " \
+        "track_whitespace=#{@track_whitespace}\n  " \
+        "analyze=#{@analyze}\n  " \
+        "action_view_helpers=#{@action_view_helpers}\n  " \
+        "render_nodes=#{@render_nodes}\n  " \
+        "prism_nodes=#{@prism_nodes}\n  " \
+        "prism_nodes_deep=#{@prism_nodes_deep}\n  " \
+        "prism_program=#{@prism_program}>"
+    end
+  end
+end

data/lib/herb/position.rb

@@ -2,6 +2,7 @@
 # typed: true
 
 module Herb
+  #: type serialized_position = { line: Integer, column: Integer }
   class Position
     attr_reader :line #: Integer
     attr_reader :column #: Integer

data/lib/herb/prism_inspect.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Herb
+  module PrismInspect
+    SKIP_FIELDS = [:node_id, :location, :flags].freeze
+
+    class << self
+      #: (String, String, String) -> String
+      def inspect_prism_serialized(serialized_bytes, source, prefix)
+        return "∅" unless serialized_bytes
+
+        begin
+          require "prism"
+        rescue LoadError
+          return "(#{serialized_bytes.bytesize} bytes, prism gem not available)"
+        end
+
+        node = Prism.load(source, serialized_bytes).value
+        return "∅" unless node
+
+        tree = inspect_prism_node(node, source, "#{prefix}    ")
+
+        "\n#{prefix}└── #{tree.strip}"
+      rescue StandardError => e
+        "(#{serialized_bytes.bytesize} bytes, deserialize error: #{e.message})"
+      end
+
+      #: (Prism::Node, String, String) -> String
+      def inspect_prism_node(node, source, prefix)
+        output = +""
+        node_name = node.class.name&.split("::")&.last || "Node"
+        output << "@ #{node_name} (location: #{format_location(node.location)})\n"
+
+        fields = display_fields(node)
+
+        fields.each_with_index do |(name, value), i|
+          is_last = i == fields.size - 1
+          symbol = is_last ? "└── " : "├── "
+          child_prefix = prefix + (is_last ? "    " : "│   ")
+
+          output << inspect_field(name, value, source, prefix, symbol, child_prefix)
+        end
+
+        output
+      end
+
+      private
+
+      #: (Symbol, untyped, String, String, String, String) -> String
+      def inspect_field(name, value, source, prefix, symbol, child_prefix)
+        case value
+        when nil
+          "#{prefix}#{symbol}#{name}: ∅\n"
+        when Prism::Node
+          inspect_node_field(name, value, source, prefix, symbol, child_prefix)
+        when Array
+          inspect_array_field(name, value, source, prefix, symbol, child_prefix)
+        when Prism::Location
+          "#{prefix}#{symbol}#{name}: #{format_location(value)}\n"
+        when Symbol
+          "#{prefix}#{symbol}#{name}: :#{value}\n"
+        when Integer, Float, true, false
+          "#{prefix}#{symbol}#{name}: #{value}\n"
+        else
+          "#{prefix}#{symbol}#{name}: #{value.inspect}\n"
+        end
+      end
+
+      #: (Symbol, Prism::Node, String, String, String, String) -> String
+      def inspect_node_field(name, value, source, prefix, symbol, child_prefix)
+        output = +""
+
+        output << "#{prefix}#{symbol}#{name}:\n"
+        output << "#{child_prefix}└── "
+        output << inspect_prism_node(value, source, "#{child_prefix}    ").lstrip
+
+        output
+      end
+
+      #: (Symbol, Array[untyped], String, String, String, String) -> String
+      def inspect_array_field(name, value, source, prefix, symbol, child_prefix)
+        output = "#{prefix}#{symbol}#{name}: "
+
+        if value.empty?
+          output << "[]\n"
+        else
+          output << "(#{value.size} #{value.size == 1 ? "item" : "items"})\n"
+
+          value.each_with_index do |item, j|
+            is_last_item = j == value.size - 1
+            item_symbol = is_last_item ? "└── " : "├── "
+            item_prefix = child_prefix + (is_last_item ? "    " : "│   ")
+
+            if item.is_a?(Prism::Node)
+              output << "#{child_prefix}#{item_symbol}"
+              output << inspect_prism_node(item, source, item_prefix).lstrip
+            else
+              output << "#{child_prefix}#{item_symbol}#{item.inspect}\n"
+            end
+          end
+        end
+
+        output
+      end
+
+      #: (untyped) -> Array[[Symbol, untyped]]
+      def display_fields(node)
+        node.deconstruct_keys(nil).except(*SKIP_FIELDS).to_a
+      end
+
+      #: (Prism::Location) -> String
+      def format_location(location)
+        start_line = location.start_line + 1
+        end_line = location.end_line + 1
+
+        "(#{start_line}:#{location.start_column})-(#{end_line}:#{location.end_column})"
+      end
+    end
+  end
+end