error_highlight 0.5.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97374a7c69ab159c324e0592fae950fa9c065e9f3cd51130dbc2d39b65caa9c4
-  data.tar.gz: 470ef6d7ce73943e6e0260a581211987286fd366cde3663ad06a25dccb5f7234
+  metadata.gz: c61fd8e89a64b337d10859ca487015ad69c87555057ce7f15b274ce799a5beb3
+  data.tar.gz: 946058938dc70f583672f9adf1450a1514e4922638e051b2755545017f266963
 SHA512:
-  metadata.gz: 6fceb2e95ac91526ebbb3b51e19c3a03cb888e77642045b4ab9b050abc0ab09f5e783a93edf7b22587e811d6b85cd1a798551ea2cebcaf1c82364318cee5c89b
-  data.tar.gz: 5972069a5065563327401a9fcff877ecaaeda664c15d3bf4cc6285f97366d46ede0742c6ebc81e2a86738bc39f0193a32164c59eb10675c43e540ed8bb414d2b
+  metadata.gz: b5a627e7b0a5710be27e62444a5127353e592cb5dd075ec0a25aa957fdf92e7c3e730b30a0fe5b4d1d35eabd9cde9dd6abafbc22a3f071ad7af8f39f991ee634
+  data.tar.gz: 6e72a445acf82b23d8a6deb6537504dfe64b50d74a808ff33104da5dccad6970256f115ef1dc786a25136457ce18b801d0d466b7b8c8dac4ba0d70ab3b5732cc

data/.github/workflows/ruby.yml

@@ -9,13 +9,20 @@ on:
       - 'master'
 
 jobs:
+  ruby-versions:
+    uses: ruby/actions/.github/workflows/ruby_versions.yml@master
+    with:
+      engine: cruby
+      min_version: 3.1
+
   build:
+    needs: ruby-versions
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: [ 'ruby-head', '3.1' ]
+        ruby: ${{ fromJson(needs.ruby-versions.outputs.versions) }}
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{ matrix.ruby }}
@@ -25,3 +32,15 @@ jobs:
     - name: Run the test suite
       run: |
         RUBYOPT=--disable-error_highlight bundle exec rake TESTOPT=-v
+
+  prism:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: head
+        bundler-cache: true
+    - name: Run the test suite
+      run: |
+        RUBYOPT="--disable-error_highlight --parser=prism" bundle exec rake TESTOPT=-v

data/lib/error_highlight/base.rb

@@ -54,11 +54,20 @@ module ErrorHighlight
 
       return nil unless Thread::Backtrace::Location === loc
 
-      node = RubyVM::AbstractSyntaxTree.of(loc, keep_script_lines: true)
+      node =
+        begin
+          RubyVM::AbstractSyntaxTree.of(loc, keep_script_lines: true)
+        rescue RuntimeError => error
+          # RubyVM::AbstractSyntaxTree.of raises an error with a message that
+          # includes "prism" when the ISEQ was compiled with the prism compiler.
+          # In this case, we'll try to parse again with prism instead.
+          raise unless error.message.include?("prism")
+          prism_find(loc)
+        end
 
       Spotter.new(node, **opts).spot
 
-    when RubyVM::AbstractSyntaxTree::Node
+    when RubyVM::AbstractSyntaxTree::Node, Prism::Node
       Spotter.new(obj, **opts).spot
 
     else
@@ -72,6 +81,21 @@ module ErrorHighlight
     return nil
   end
 
+  # Accepts a Thread::Backtrace::Location object and returns a Prism::Node
+  # corresponding to the backtrace location in the source code.
+  def self.prism_find(location)
+    require "prism"
+    return nil if Prism::VERSION < "1.0.0"
+
+    absolute_path = location.absolute_path
+    return unless absolute_path
+
+    node_id = RubyVM::AbstractSyntaxTree.node_id_for_backtrace_location(location)
+    Prism.parse_file(absolute_path).value.breadth_first_search { |node| node.node_id == node_id }
+  end
+
+  private_class_method :prism_find
+
   class Spotter
     class NonAscii < Exception; end
     private_constant :NonAscii
@@ -98,9 +122,58 @@ module ErrorHighlight
       end
     end
 
+    OPT_GETCONSTANT_PATH = (RUBY_VERSION.split(".").map {|s| s.to_i } <=> [3, 2]) >= 0
+    private_constant :OPT_GETCONSTANT_PATH
+
     def spot
       return nil unless @node
 
+      if OPT_GETCONSTANT_PATH
+        # In Ruby 3.2 or later, a nested constant access (like `Foo::Bar::Baz`)
+        # is compiled to one instruction (opt_getconstant_path).
+        # @node points to the node of the whole `Foo::Bar::Baz` even if `Foo`
+        # or `Foo::Bar` causes NameError.
+        # So we try to spot the sub-node that causes the NameError by using
+        # `NameError#name`.
+        case @node.type
+        when :COLON2
+          subnodes = []
+          node = @node
+          while node.type == :COLON2
+            node2, const = node.children
+            subnodes << node if const == @name
+            node = node2
+          end
+          if node.type == :CONST || node.type == :COLON3
+            if node.children.first == @name
+              subnodes << node
+            end
+
+            # If we found only one sub-node whose name is equal to @name, use it
+            return nil if subnodes.size != 1
+            @node = subnodes.first
+          else
+            # Do nothing; opt_getconstant_path is used only when the const base is
+            # NODE_CONST (`Foo`) or NODE_COLON3 (`::Foo`)
+          end
+        when :constant_path_node
+          subnodes = []
+          node = @node
+
+          begin
+            subnodes << node if node.name == @name
+          end while (node = node.parent).is_a?(Prism::ConstantPathNode)
+
+          if node.is_a?(Prism::ConstantReadNode) && node.name == @name
+            subnodes << node
+          end
+
+          # If we found only one sub-node whose name is equal to @name, use it
+          return nil if subnodes.size != 1
+          @node = subnodes.first
+        end
+      end
+
       case @node.type
 
       when :CALL, :QCALL
@@ -165,6 +238,48 @@ module ErrorHighlight
 
       when :OP_CDECL
         spot_op_cdecl
+
+      when :call_node
+        case @point_type
+        when :name
+          prism_spot_call_for_name
+        when :args
+          prism_spot_call_for_args
+        end
+
+      when :local_variable_operator_write_node
+        case @point_type
+        when :name
+          prism_spot_local_variable_operator_write_for_name
+        when :args
+          prism_spot_local_variable_operator_write_for_args
+        end
+
+      when :call_operator_write_node
+        case @point_type
+        when :name
+          prism_spot_call_operator_write_for_name
+        when :args
+          prism_spot_call_operator_write_for_args
+        end
+
+      when :index_operator_write_node
+        case @point_type
+        when :name
+          prism_spot_index_operator_write_for_name
+        when :args
+          prism_spot_index_operator_write_for_args
+        end
+
+      when :constant_read_node
+        prism_spot_constant_read
+
+      when :constant_path_node
+        prism_spot_constant_path
+
+      when :constant_path_operator_write_node
+        prism_spot_constant_path_operator_write
+
       end
 
       if @snippet && @beg_column && @end_column && @beg_column < @end_column
@@ -508,6 +623,207 @@ module ErrorHighlight
       @beg_lineno = @end_lineno = lineno
       @snippet = @fetch[lineno]
     end
+
+    # Take a location from the prism parser and set the necessary instance
+    # variables.
+    def prism_location(location)
+      @beg_lineno = location.start_line
+      @beg_column = location.start_column
+      @end_lineno = location.end_line
+      @end_column = location.end_column
+      @snippet = @fetch[@beg_lineno, @end_lineno]
+    end
+
+    # Example:
+    #   x.foo
+    #    ^^^^
+    #   x.foo(42)
+    #    ^^^^
+    #   x&.foo
+    #    ^^^^^
+    #   x[42]
+    #    ^^^^
+    #   x.foo = 1
+    #    ^^^^^^
+    #   x[42] = 1
+    #    ^^^^^^
+    #   x + 1
+    #     ^
+    #   +x
+    #   ^
+    #   foo(42)
+    #   ^^^
+    #   foo 42
+    #   ^^^
+    #   foo
+    #   ^^^
+    def prism_spot_call_for_name
+      # Explicitly turn off foo.() syntax because error_highlight expects this
+      # to not work.
+      return nil if @node.name == :call && @node.message_loc.nil?
+
+      location = @node.message_loc || @node.call_operator_loc || @node.location
+      location = @node.call_operator_loc.join(location) if @node.call_operator_loc&.start_line == location.start_line
+
+      # If the method name ends with "=" but the message does not, then this is
+      # a method call using the "attribute assignment" syntax
+      # (e.g., foo.bar = 1). In this case we need to go retrieve the = sign and
+      # add it to the location.
+      if (name = @node.name).end_with?("=") && !@node.message.end_with?("=")
+        location = location.adjoin("=")
+      end
+
+      prism_location(location)
+
+      if !name.end_with?("=") && !name.match?(/[[:alpha:]_\[]/)
+        # If the method name is an operator, then error_highlight only
+        # highlights the first line.
+        fetch_line(location.start_line)
+      end
+    end
+
+    # Example:
+    #   x.foo(42)
+    #         ^^
+    #   x[42]
+    #     ^^
+    #   x.foo = 1
+    #           ^
+    #   x[42] = 1
+    #     ^^^^^^^
+    #   x[] = 1
+    #     ^^^^^
+    #   x + 1
+    #       ^
+    #   foo(42)
+    #       ^^
+    #   foo 42
+    #       ^^
+    def prism_spot_call_for_args
+      # Disallow highlighting arguments if there are no arguments.
+      return if @node.arguments.nil?
+
+      # Explicitly turn off foo.() syntax because error_highlight expects this
+      # to not work.
+      return nil if @node.name == :call && @node.message_loc.nil?
+
+      if @node.name == :[]= && @node.opening == "[" && (@node.arguments&.arguments || []).length == 1
+        prism_location(@node.opening_loc.copy(start_offset: @node.opening_loc.start_offset + 1).join(@node.arguments.location))
+      else
+        prism_location(@node.arguments.location)
+      end
+    end
+
+    # Example:
+    #   x += 1
+    #     ^
+    def prism_spot_local_variable_operator_write_for_name
+      prism_location(@node.binary_operator_loc.chop)
+    end
+
+    # Example:
+    #   x += 1
+    #        ^
+    def prism_spot_local_variable_operator_write_for_args
+      prism_location(@node.value.location)
+    end
+
+    # Example:
+    #   x.foo += 42
+    #    ^^^     (for foo)
+    #   x.foo += 42
+    #         ^  (for +)
+    #   x.foo += 42
+    #    ^^^^^^^ (for foo=)
+    def prism_spot_call_operator_write_for_name
+      if !@name.start_with?(/[[:alpha:]_]/)
+        prism_location(@node.binary_operator_loc.chop)
+      else
+        location = @node.message_loc
+        if @node.call_operator_loc.start_line == location.start_line
+          location = @node.call_operator_loc.join(location)
+        end
+
+        location = location.adjoin("=") if @name.end_with?("=")
+        prism_location(location)
+      end
+    end
+
+    # Example:
+    #   x.foo += 42
+    #            ^^
+    def prism_spot_call_operator_write_for_args
+      prism_location(@node.value.location)
+    end
+
+    # Example:
+    #   x[1] += 42
+    #    ^^^    (for [])
+    #   x[1] += 42
+    #        ^  (for +)
+    #   x[1] += 42
+    #    ^^^^^^ (for []=)
+    def prism_spot_index_operator_write_for_name
+      case @name
+      when :[]
+        prism_location(@node.opening_loc.join(@node.closing_loc))
+      when :[]=
+        prism_location(@node.opening_loc.join(@node.closing_loc).adjoin("="))
+      else
+        # Explicitly turn off foo[] += 1 syntax when the operator is not on
+        # the same line because error_highlight expects this to not work.
+        return nil if @node.binary_operator_loc.start_line != @node.opening_loc.start_line
+
+        prism_location(@node.binary_operator_loc.chop)
+      end
+    end
+
+    # Example:
+    #   x[1] += 42
+    #     ^^^^^^^^
+    def prism_spot_index_operator_write_for_args
+      opening_loc =
+        if @node.arguments.nil?
+          @node.opening_loc.copy(start_offset: @node.opening_loc.start_offset + 1)
+        else
+          @node.arguments.location
+        end
+
+      prism_location(opening_loc.join(@node.value.location))
+    end
+
+    # Example:
+    #   Foo
+    #   ^^^
+    def prism_spot_constant_read
+      prism_location(@node.location)
+    end
+
+    # Example:
+    #   Foo::Bar
+    #      ^^^^^
+    def prism_spot_constant_path
+      if @node.parent && @node.parent.location.end_line == @node.location.end_line
+        fetch_line(@node.parent.location.end_line)
+        prism_location(@node.delimiter_loc.join(@node.name_loc))
+      else
+        fetch_line(@node.location.end_line)
+        location = @node.name_loc
+        location = @node.delimiter_loc.join(location) if @node.delimiter_loc.end_line == location.start_line
+        prism_location(location)
+      end
+    end
+
+    # Example:
+    #   Foo::Bar += 1
+    #      ^^^^^^^^
+    def prism_spot_constant_path_operator_write
+      if @name == (target = @node.target).name
+        prism_location(target.delimiter_loc.join(target.name_loc))
+      else
+        prism_location(@node.binary_operator_loc.chop)
+      end
+    end
   end
 
   private_constant :Spotter

data/lib/error_highlight/formatter.rb

@@ -1,15 +1,66 @@
 module ErrorHighlight
   class DefaultFormatter
+    MIN_SNIPPET_WIDTH = 20
+
     def self.message_for(spot)
       # currently only a one-line code snippet is supported
-      if spot[:first_lineno] == spot[:last_lineno]
-        indent = spot[:snippet][0...spot[:first_column]].gsub(/[^\t]/, " ")
-        marker = indent + "^" * (spot[:last_column] - spot[:first_column])
+      return "" unless spot[:first_lineno] == spot[:last_lineno]
+
+      snippet      = spot[:snippet]
+      first_column = spot[:first_column]
+      last_column  = spot[:last_column]
+      ellipsis     = "..."
+
+      # truncate snippet to fit in the viewport
+      if max_snippet_width && snippet.size > max_snippet_width
+        available_width = max_snippet_width - ellipsis.size
+        center          = first_column - max_snippet_width / 2
+
+        visible_start  = last_column < available_width ? 0 : [center, 0].max
+        visible_end    = visible_start + max_snippet_width
+        visible_start  = snippet.size - max_snippet_width if visible_end > snippet.size
+
+        prefix = visible_start.positive?    ? ellipsis : ""
+        suffix = visible_end < snippet.size ? ellipsis : ""
 
-        "\n\n#{ spot[:snippet] }#{ marker }"
-      else
-        ""
+        snippet = prefix + snippet[(visible_start + prefix.size)...(visible_end - suffix.size)] + suffix
+        snippet << "\n" unless snippet.end_with?("\n")
+
+        first_column -= visible_start
+        last_column  = [last_column - visible_start, snippet.size - 1].min
       end
+
+      indent = snippet[0...first_column].gsub(/[^\t]/, " ")
+      marker = indent + "^" * (last_column - first_column)
+
+      "\n\n#{ snippet }#{ marker }"
+    end
+
+    def self.max_snippet_width
+      return if Ractor.current[:__error_highlight_max_snippet_width__] == :disabled
+
+      Ractor.current[:__error_highlight_max_snippet_width__] ||= terminal_width
+    end
+
+    def self.max_snippet_width=(width)
+      return Ractor.current[:__error_highlight_max_snippet_width__] = :disabled if width.nil?
+
+      width = width.to_i
+
+      if width < MIN_SNIPPET_WIDTH
+        warn "'max_snippet_width' adjusted to minimum value of #{MIN_SNIPPET_WIDTH}."
+        width = MIN_SNIPPET_WIDTH
+      end
+
+      Ractor.current[:__error_highlight_max_snippet_width__] = width
+    end
+
+    def self.terminal_width
+      # lazy load io/console, so it's not loaded when 'max_snippet_width' is set
+      require "io/console"
+      STDERR.winsize[1] if STDERR.tty?
+    rescue LoadError, NoMethodError, SystemCallError
+      # do not truncate when window size is not available
     end
   end
 

data/lib/error_highlight/version.rb

@@ -1,3 +1,3 @@
 module ErrorHighlight
-  VERSION = "0.5.1"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: error_highlight
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.7.0
 platform: ruby
+original_platform: ''
 authors:
 - Yusuke Endoh
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-14 00:00:00.000000000 Z
+date: 2024-12-03 00:00:00.000000000 Z
 dependencies: []
 description: The gem enhances Exception#message by adding a short explanation where
   the exception is raised
@@ -35,7 +35,6 @@ homepage: https://github.com/ruby/error_highlight
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -50,8 +49,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
+rubygems_version: 3.6.0.dev
 specification_version: 4
 summary: Shows a one-line code snippet with an underline in the error backtrace
 test_files: []