error_highlight 0.6.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33a97fb38c24c4c0f5637b458a73525e7fcb3a1803e15d6478f009fd590afa0c
-  data.tar.gz: 16646ee686117659558ee48bb3b56f4fc48f01e7549b60240495f8f830794da8
+  metadata.gz: e6a847df9db6582ba1912ba3a2a64a76ba18e38d43c38413ac885fb993cbce07
+  data.tar.gz: c6e6872fd7276af7fac719d173da9f07af9fed0760d05385d1b6b6217449b9f0
 SHA512:
-  metadata.gz: 228531308329b907adb5d78c8c3b031b954b49338cb13d2fb31aa30919b870a61c3809b17b9a67f0d7449049c6c456f33d47e7a1abb7597aad45f09262a5682d
-  data.tar.gz: 293349ee401c24887dea1459b84dbf3b2b76a93934d02759b1ccf8ff3cdb376f66025dc664f16ab5bb484982661e3804078e474e7fadcfb602d3657f581f7095
+  metadata.gz: 9699f20efc393a3fc7c09312a29818416bb255c3078c45a4a4f75deda3f2becefe415bc98565928a001ff88638433868d89656d9382b6b736a781f51d17e1901
+  data.tar.gz: 48410be2cb3bbfd0c241ded954d11c960abc551fc896c907ed05d6c49ea37ec116ee92556cd713c9b5fe2f033fe3eb16606e788b97a61196f97a2050f839ded2

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.2
+
   build:
+    needs: ruby-versions
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: [ 'ruby-head', '3.1', '3.2' ]
+        ruby: ${{ fromJson(needs.ruby-versions.outputs.versions) }}
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - 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@v6
+    - 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/.github/workflows/sync-ruby.yml

@@ -0,0 +1,33 @@
+name: Sync ruby
+on:
+  push:
+    branches: [master]
+jobs:
+  sync:
+    name: Sync ruby
+    runs-on: ubuntu-latest
+    if: ${{ github.repository_owner == 'ruby' }}
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Create GitHub App token
+        id: app-token
+        uses: actions/create-github-app-token@v2
+        with:
+          app-id: 2060836
+          private-key: ${{ secrets.RUBY_SYNC_DEFAULT_GEMS_PRIVATE_KEY }}
+          owner: ruby
+          repositories: ruby
+
+      - name: Sync to ruby/ruby
+        uses: convictional/trigger-workflow-and-wait@v1.6.5
+        with:
+          owner: ruby
+          repo: ruby
+          workflow_file_name: sync_default_gems.yml
+          github_token: ${{ steps.app-token.outputs.token }}
+          ref: master
+          client_payload: |
+            {"gem":"${{ github.event.repository.name }}","before":"${{ github.event.before }}","after":"${{ github.event.after }}"}
+          propagate_failure: true
+          wait_interval: 10

data/error_highlight.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://github.com/ruby/error_highlight"
 
   spec.license       = "MIT"
-  spec.required_ruby_version = Gem::Requirement.new(">= 3.1.0.dev")
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.2.0")
 
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }

data/lib/error_highlight/base.rb

@@ -1,13 +1,13 @@
 require_relative "version"
 
 module ErrorHighlight
-  # Identify the code fragment at that a given exception occurred.
+  # Identify the code fragment where a given exception occurred.
   #
   # Options:
   #
   # point_type: :name | :args
-  #   :name (default) points the method/variable name that the exception occurred.
-  #   :args points the arguments of the method call that the exception occurred.
+  #   :name (default) points to the method/variable name where the exception occurred.
+  #   :args points to the arguments of the method call where the exception occurred.
   #
   # backtrace_location: Thread::Backtrace::Location
   #   It locates the code fragment of the given backtrace_location.
@@ -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
@@ -89,7 +113,7 @@ module ErrorHighlight
         snippet = @node.script_lines[lineno - 1 .. last_lineno - 1].join("")
         snippet += "\n" unless snippet.end_with?("\n")
 
-        # It require some work to support Unicode (or multibyte) characters.
+        # It requires some work to support Unicode (or multibyte) characters.
         # Tentatively, we stop highlighting if the code snippet has non-ascii characters.
         # See https://github.com/ruby/error_highlight/issues/4
         raise NonAscii unless snippet.ascii_only?
@@ -98,19 +122,17 @@ 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 && @node.type == :COLON2
-        # 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`.
+      # 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
@@ -130,6 +152,21 @@ module ErrorHighlight
           # 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
 
       case @node.type
@@ -196,6 +233,86 @@ module ErrorHighlight
 
       when :OP_CDECL
         spot_op_cdecl
+
+      when :DEFN
+        raise NotImplementedError if @point_type != :name
+        spot_defn
+
+      when :DEFS
+        raise NotImplementedError if @point_type != :name
+        spot_defs
+
+      when :LAMBDA
+        spot_lambda
+
+      when :ITER
+        spot_iter
+
+      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
+
+      when :def_node
+        case @point_type
+        when :name
+          prism_spot_def_for_name
+        when :args
+          raise NotImplementedError
+        end
+
+      when :lambda_node
+        case @point_type
+        when :name
+          prism_spot_lambda_for_name
+        when :args
+          raise NotImplementedError
+        end
+
+      when :block_node
+        case @point_type
+        when :name
+          prism_spot_block_for_name
+        when :args
+          raise NotImplementedError
+        end
+
       end
 
       if @snippet && @beg_column && @end_column && @beg_column < @end_column
@@ -260,6 +377,7 @@ module ErrorHighlight
         end
       elsif mid.to_s =~ /\A\W+\z/ && lines.match(/\G\s*(#{ Regexp.quote(mid) })=.*\n/, nd_recv.last_column)
         @snippet = $` + $&
+        @beg_lineno = @end_lineno = lineno
         @beg_column = $~.begin(1)
         @end_column = $~.end(1)
       end
@@ -386,7 +504,6 @@ module ErrorHighlight
     def spot_fcall_for_args
       _mid, nd_args = @node.children
       if nd_args && nd_args.first_lineno == nd_args.last_lineno
-        # binary operator
         fetch_line(nd_args.first_lineno)
         @beg_column = nd_args.first_column
         @end_column = nd_args.last_column
@@ -498,8 +615,9 @@ module ErrorHighlight
         @beg_column = nd_parent.last_column
         @end_column = @node.last_column
       else
-        @snippet = @fetch[@node.last_lineno]
+        fetch_line(@node.last_lineno)
         if @snippet[...@node.last_column].match(/#{ Regexp.quote(const) }\z/)
+          @beg_lineno = @end_lineno = @node.last_lineno
           @beg_column = $~.begin(0)
           @end_column = $~.end(0)
         end
@@ -513,7 +631,7 @@ module ErrorHighlight
       nd_lhs, op, _nd_rhs = @node.children
       *nd_parent_lhs, _const = nd_lhs.children
       if @name == op
-        @snippet = @fetch[nd_lhs.last_lineno]
+        fetch_line(nd_lhs.last_lineno)
         if @snippet.match(/\G\s*(#{ Regexp.quote(op) })=/, nd_lhs.last_column)
           @beg_column = $~.begin(1)
           @end_column = $~.end(1)
@@ -523,22 +641,297 @@ module ErrorHighlight
         @end_column = nd_lhs.last_column
         if nd_parent_lhs.empty? # example: ::C += 1
           if nd_lhs.first_lineno == nd_lhs.last_lineno
-            @snippet = @fetch[nd_lhs.last_lineno]
+            fetch_line(nd_lhs.last_lineno)
             @beg_column = nd_lhs.first_column
           end
         else # example: Foo::Bar::C += 1
           if nd_parent_lhs.last.last_lineno == nd_lhs.last_lineno
-            @snippet = @fetch[nd_lhs.last_lineno]
+            fetch_line(nd_lhs.last_lineno)
             @beg_column = nd_parent_lhs.last.last_column
           end
         end
       end
     end
 
+    # Example:
+    #   def bar; end
+    #       ^^^
+    def spot_defn
+      mid, = @node.children
+      fetch_line(@node.first_lineno)
+      if @snippet.match(/\Gdef\s+(#{ Regexp.quote(mid) }\b)/, @node.first_column)
+        @beg_column = $~.begin(1)
+        @end_column = $~.end(1)
+      end
+    end
+
+    # Example:
+    #   def Foo.bar; end
+    #          ^^^^
+    def spot_defs
+      nd_recv, mid, = @node.children
+      fetch_line(nd_recv.last_lineno)
+      if @snippet.match(/\G\s*(\.\s*#{ Regexp.quote(mid) }\b)/, nd_recv.last_column)
+        @beg_column = $~.begin(1)
+        @end_column = $~.end(1)
+      end
+    end
+
+    # Example:
+    #   -> { ... }
+    #   ^^
+    def spot_lambda
+      fetch_line(@node.first_lineno)
+      if @snippet.match(/\G->/, @node.first_column)
+        @beg_column = $~.begin(0)
+        @end_column = $~.end(0)
+      end
+    end
+
+    # Example:
+    #   lambda { ... }
+    #          ^
+    #   define_method :foo do
+    #                      ^^
+    def spot_iter
+      _nd_fcall, nd_scope = @node.children
+      fetch_line(nd_scope.first_lineno)
+      if @snippet.match(/\G(?:do\b|\{)/, nd_scope.first_column)
+        @beg_column = $~.begin(0)
+        @end_column = $~.end(0)
+      end
+    end
+
     def fetch_line(lineno)
       @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
+
+    # Example:
+    #   def foo()
+    #       ^^^
+    def prism_spot_def_for_name
+      location = @node.name_loc
+      location = @node.operator_loc.join(location) if @node.operator_loc
+      prism_location(location)
+    end
+
+    # Example:
+    #   -> x, y { }
+    #   ^^
+    def prism_spot_lambda_for_name
+      prism_location(@node.operator_loc)
+    end
+
+    # Example:
+    #   lambda { }
+    #          ^
+    #   define_method :foo do |x, y|
+    #                      ^
+    def prism_spot_block_for_name
+      prism_location(@node.opening_loc)
+    end
   end
 
   private_constant :Spotter

data/lib/error_highlight/core_ext.rb

@@ -3,9 +3,38 @@ require_relative "formatter"
 module ErrorHighlight
   module CoreExt
     private def generate_snippet
-      spot = ErrorHighlight.spot(self)
-      return "" unless spot
-      return ErrorHighlight.formatter.message_for(spot)
+      if ArgumentError === self && message =~ /\A(?:wrong number of arguments|missing keyword[s]?|unknown keyword[s]?|no keywords accepted)\b/
+        locs = self.backtrace_locations
+        return "" if locs.size < 2
+        callee_loc, caller_loc = locs
+        callee_spot = ErrorHighlight.spot(self, backtrace_location: callee_loc, point_type: :name)
+        caller_spot = ErrorHighlight.spot(self, backtrace_location: caller_loc, point_type: :name)
+        if caller_spot && callee_spot &&
+            caller_loc.path == callee_loc.path &&
+            caller_loc.lineno == callee_loc.lineno &&
+            caller_spot == callee_spot
+          callee_loc = callee_spot = nil
+        end
+        ret = +"\n"
+        [["caller", caller_loc, caller_spot], ["callee", callee_loc, callee_spot]].each do |header, loc, spot|
+          out = nil
+          if loc
+            out = "    #{ header }: #{ loc.path }:#{ loc.lineno }"
+            if spot
+              _, _, snippet, highlight = ErrorHighlight.formatter.message_for(spot).lines
+              out += "\n    | #{ snippet }      #{ highlight }"
+            else
+              # do nothing
+            end
+          end
+          ret << "\n" + out if out
+        end
+        ret
+      else
+        spot = ErrorHighlight.spot(self)
+        return "" unless spot
+        return ErrorHighlight.formatter.message_for(spot)
+      end
     end
 
     if Exception.method_defined?(:detailed_message)

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 to avoid loading it when 'max_snippet_width' is manually set
+      require "io/console"
+      $stderr.winsize[1] if $stderr.tty?
+    rescue LoadError, NoMethodError, SystemCallError
+      # skip truncation when terminal window size is unavailable
     end
   end
 

data/lib/error_highlight/version.rb

@@ -1,3 +1,3 @@
 module ErrorHighlight
-  VERSION = "0.6.0"
+  VERSION = "0.7.1"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: error_highlight
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Yusuke Endoh
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-12-09 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: The gem enhances Exception#message by adding a short explanation where
   the exception is raised
@@ -20,6 +19,7 @@ extra_rdoc_files: []
 files:
 - ".github/dependabot.yml"
 - ".github/workflows/ruby.yml"
+- ".github/workflows/sync-ruby.yml"
 - ".gitignore"
 - Gemfile
 - LICENSE.txt
@@ -35,7 +35,6 @@ homepage: https://github.com/ruby/error_highlight
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -43,15 +42,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0.dev
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.0.dev
-signing_key: 
+rubygems_version: 4.0.1
 specification_version: 4
 summary: Shows a one-line code snippet with an underline in the error backtrace
 test_files: []