Issue #21960 has been updated by byroot (Jean Boussier). Tracker changed from Misc to Feature I believe this would be a good change, we did make a similar decision to use spaces over other symbols in [Feature #14145], so that it's easier to select. This however has some small backward compatibly consequences, as code parsing backtraces with regexps isn't that rare. That being said, most of the time, this sort of code would be much better to use `backtrace_locations` instead, one downside however is that in rare cases, some exceptions do have a `#backtrace` but no `#backtrace_locations`. ---------------------------------------- Feature #21960: Improve #backtrace to not confuse terminals https://bugs.ruby-lang.org/issues/21960#change-116791 * Author: svoop (Sven Schwyn) * Status: Open ---------------------------------------- The `#backtrace` of exceptions are currently printed like so: ``` /path/to/whatever.rb:8:in `/' /path/to/whatever.rb:8:in `show' (...) ``` Most terminals recognize `/path/to/whatever.rb:8` as a local file and make it clickable as "open in editor", however, some (e.g. Ghostty) include everything up to the next whitespace, in this case `/path/to/whatever.rb:8:in`. This is then used as an argument to `open` (on macOS) which will not work due to the `:in` part. There are two ways to improve this: ## Replace the colon with a space Given the existence of `#backtrace_locations` which is better suited for programmatically working with backtrace locations, it should not break things to slightly modify the `#backtrace` to look like this: ``` /path/to/whatever.rb:8 in `/' /path/to/whatever.rb:8 in `show' (...) ^^^ space instead of colon ``` ## Add OCS 8 sequences [OCS 8](https://github.com/Alhadis/OSC8-Adoption) are the `<a>` tag for terminal output. While many terminals support it, it might cause visual noise in logs and therefore would have to be an opt-in feature e.g. via a Ruby interpreter argument. -- https://bugs.ruby-lang.org/

Issue #21960 has been updated by svoop (Sven Schwyn). @Eregon You're right, my bad, I happened to be on a project which still runs on Ruby 3.1. However, the colon is present on Ruby 4.0 as well: ``` path/to/test.rb:1:in 'Integer#/': divided by 0 (ZeroDivisionError) from path/to/test.rb:1:in '<main>' ``` ---------------------------------------- Feature #21960: Improve #backtrace to not confuse terminals https://bugs.ruby-lang.org/issues/21960#change-116793 * Author: svoop (Sven Schwyn) * Status: Open ---------------------------------------- The `#backtrace` of exceptions are currently printed like so: ``` /path/to/whatever.rb:8:in `/' /path/to/whatever.rb:8:in `show' (...) ``` Most terminals recognize `/path/to/whatever.rb:8` as a local file and make it clickable as "open in editor", however, some (e.g. Ghostty) include everything up to the next whitespace, in this case `/path/to/whatever.rb:8:in`. This is then used as an argument to `open` (on macOS) which will not work due to the `:in` part. There are two ways to improve this: ## Replace the colon with a space Given the existence of `#backtrace_locations` which is better suited for programmatically working with backtrace locations, it should not break things to slightly modify the `#backtrace` to look like this: ``` /path/to/whatever.rb:8 in `/' /path/to/whatever.rb:8 in `show' (...) ^^^ space instead of colon ``` ## Add OCS 8 sequences [OCS 8](https://github.com/Alhadis/OSC8-Adoption) are the `<a>` tag for terminal output. While many terminals support it, it might cause visual noise in logs and therefore would have to be an opt-in feature e.g. via a Ruby interpreter argument. -- https://bugs.ruby-lang.org/

Issue #21960 has been updated by byroot (Jean Boussier).

This is typically not the case for test suites

I'm not 100% sure I understand what you mean. But yes, this change would certainly require to update a bunch of test there and there, just like when we changed labels to use single quotes intead of backticks. ---------------------------------------- Feature #21960: Improve #backtrace to not confuse terminals https://bugs.ruby-lang.org/issues/21960#change-116795 * Author: svoop (Sven Schwyn) * Status: Open ---------------------------------------- The `#backtrace` of exceptions are currently printed like so: ``` /path/to/whatever.rb:8:in `/' /path/to/whatever.rb:8:in `show' (...) ``` Most terminals recognize `/path/to/whatever.rb:8` as a local file and make it clickable as "open in editor", however, some (e.g. Ghostty) include everything up to the next whitespace, in this case `/path/to/whatever.rb:8:in`. This is then used as an argument to `open` (on macOS) which will not work due to the `:in` part. There are two ways to improve this: ## Replace the colon with a space Given the existence of `#backtrace_locations` which is better suited for programmatically working with backtrace locations, it should not break things to slightly modify the `#backtrace` to look like this: ``` /path/to/whatever.rb:8 in `/' /path/to/whatever.rb:8 in `show' (...) ^^^ space instead of colon ``` ## Add OCS 8 sequences [OCS 8](https://github.com/Alhadis/OSC8-Adoption) are the `<a>` tag for terminal output. While many terminals support it, it might cause visual noise in logs and therefore would have to be an opt-in feature e.g. via a Ruby interpreter argument. -- https://bugs.ruby-lang.org/

Issue #21960 has been updated by svoop (Sven Schwyn). From my POV, some failing tests which are easy enough to find and fix are no deal breaker though, albeit other people's mileage may vary. Problematic is (untested) code failing in production which is not very likely in this case and would point to a bigger code smell at large. ---------------------------------------- Feature #21960: Improve #backtrace to not confuse terminals https://bugs.ruby-lang.org/issues/21960#change-116799 * Author: svoop (Sven Schwyn) * Status: Open ---------------------------------------- The `#backtrace` of exceptions are currently printed like so: ``` /path/to/whatever.rb:8:in `/' /path/to/whatever.rb:8:in `show' (...) ``` Most terminals recognize `/path/to/whatever.rb:8` as a local file and make it clickable as "open in editor", however, some (e.g. Ghostty) include everything up to the next whitespace, in this case `/path/to/whatever.rb:8:in`. This is then used as an argument to `open` (on macOS) which will not work due to the `:in` part. There are two ways to improve this: ## Replace the colon with a space Given the existence of `#backtrace_locations` which is better suited for programmatically working with backtrace locations, it should not break things to slightly modify the `#backtrace` to look like this: ``` /path/to/whatever.rb:8 in `/' /path/to/whatever.rb:8 in `show' (...) ^^^ space instead of colon ``` ## Add OCS 8 sequences [OCS 8](https://github.com/Alhadis/OSC8-Adoption) are the `<a>` tag for terminal output. While many terminals support it, it might cause visual noise in logs and therefore would have to be an opt-in feature e.g. via a Ruby interpreter argument. -- https://bugs.ruby-lang.org/

Issue #21960 has been updated by byroot (Jean Boussier). To be clear, my (limited) support of the change has nothing to do with Ghosty (never used it, no idea what its capabilities are), and not to support printing links. I only support replacing `:` with a space. As mentioned in https://bugs.ruby-lang.org/issues/14145#note-25, several terminals when double clicking on text will extend the selection until they reach spaces, but even without that feature (my terminal doesn't have it) it's much easier to read and select with a click+drag. So I do believe it's marginally better than the current format. Whether the benefits outweigh the cost of the churn, is however very debatable. ---------------------------------------- Feature #21960: Improve #backtrace to not confuse terminals https://bugs.ruby-lang.org/issues/21960#change-116803 * Author: svoop (Sven Schwyn) * Status: Open ---------------------------------------- The `#backtrace` of exceptions are currently printed like so: ``` /path/to/whatever.rb:8:in `/' /path/to/whatever.rb:8:in `show' (...) ``` Most terminals recognize `/path/to/whatever.rb:8` as a local file and make it clickable as "open in editor", however, some (e.g. Ghostty) include everything up to the next whitespace, in this case `/path/to/whatever.rb:8:in`. This is then used as an argument to `open` (on macOS) which will not work due to the `:in` part. There are two ways to improve this: ## Replace the colon with a space Given the existence of `#backtrace_locations` which is better suited for programmatically working with backtrace locations, it should not break things to slightly modify the `#backtrace` to look like this: ``` /path/to/whatever.rb:8 in `/' /path/to/whatever.rb:8 in `show' (...) ^^^ space instead of colon ``` ## Add OCS 8 sequences [OCS 8](https://github.com/Alhadis/OSC8-Adoption) are the `<a>` tag for terminal output. While many terminals support it, it might cause visual noise in logs and therefore would have to be an opt-in feature e.g. via a Ruby interpreter argument. -- https://bugs.ruby-lang.org/

Issue #21960 has been updated by svoop (Sven Schwyn). You're right about `open` failing on line numbers, @mame, sorry for the confusion. I was experimenting with a wrapper for `open` higher up in the $PATH and accidentally hit it – which looked as if `open` handled line numbers correctly. Ghostty is just the reason I tripped over the colon, by no means a good reason for such a change. However, as @byroot mentioned, there are likely more situations where the second colon causes hickups. For instance, Zed does support a second colon: ``` Arguments: [PATHS_WITH_POSITION]... The paths to open in Zed (space-separated). Use `path:line:column` syntax to open a file at the given line and column. ``` No idea what Zed makes of `:in` for a column, but I'd be happy to investigate further if there's any interest. Please just close this issue otherwise. ---------------------------------------- Feature #21960: Improve #backtrace to not confuse terminals https://bugs.ruby-lang.org/issues/21960#change-116807 * Author: svoop (Sven Schwyn) * Status: Open ---------------------------------------- The `#backtrace` of exceptions are currently printed like so: ``` /path/to/whatever.rb:8:in `/' /path/to/whatever.rb:8:in `show' (...) ``` Most terminals recognize `/path/to/whatever.rb:8` as a local file and make it clickable as "open in editor", however, some (e.g. Ghostty) include everything up to the next whitespace, in this case `/path/to/whatever.rb:8:in`. This is then used as an argument to `open` (on macOS) which will not work due to the `:in` part. There are two ways to improve this: ## Replace the colon with a space Given the existence of `#backtrace_locations` which is better suited for programmatically working with backtrace locations, it should not break things to slightly modify the `#backtrace` to look like this: ``` /path/to/whatever.rb:8 in `/' /path/to/whatever.rb:8 in `show' (...) ^^^ space instead of colon ``` ## Add OCS 8 sequences [OCS 8](https://github.com/Alhadis/OSC8-Adoption) are the `<a>` tag for terminal output. While many terminals support it, it might cause visual noise in logs and therefore would have to be an opt-in feature e.g. via a Ruby interpreter argument. -- https://bugs.ruby-lang.org/

Issue #21960 has been updated by Eregon (Benoit Daloze). There is also a good point that what follows a second `:` should be the column and not `in`, that's standard in many tools, including `gcc` and `clang` which look like: ``` $ echo 'int main() {' > foo.c $ gcc a.c a.c: In function ‘main’: a.c:1:1: error: expected declaration or statement at end of input 1 | int main() { | ^~~ $ clang a.c a.c:1:13: error: expected '}' 1 | int main() { | ^ a.c:1:12: note: to match this '{' 1 | int main() { | ^ 1 error generated. ``` Since Ruby doesn't show the column, there should be no second `:`. (FWIW gcc/clang have a third `:` but at least there is a space after) ---------------------------------------- Feature #21960: Improve #backtrace to not confuse terminals https://bugs.ruby-lang.org/issues/21960#change-116810 * Author: svoop (Sven Schwyn) * Status: Open ---------------------------------------- The `#backtrace` of exceptions are currently printed like so: ``` /path/to/whatever.rb:8:in `/' /path/to/whatever.rb:8:in `show' (...) ``` Most terminals recognize `/path/to/whatever.rb:8` as a local file and make it clickable as "open in editor", however, some (e.g. Ghostty) include everything up to the next whitespace, in this case `/path/to/whatever.rb:8:in`. This is then used as an argument to `open` (on macOS) which will not work due to the `:in` part. There are two ways to improve this: ## Replace the colon with a space Given the existence of `#backtrace_locations` which is better suited for programmatically working with backtrace locations, it should not break things to slightly modify the `#backtrace` to look like this: ``` /path/to/whatever.rb:8 in `/' /path/to/whatever.rb:8 in `show' (...) ^^^ space instead of colon ``` ## Add OCS 8 sequences [OCS 8](https://github.com/Alhadis/OSC8-Adoption) are the `<a>` tag for terminal output. While many terminals support it, it might cause visual noise in logs and therefore would have to be an opt-in feature e.g. via a Ruby interpreter argument. -- https://bugs.ruby-lang.org/

Issue #21960 has been updated by byroot (Jean Boussier).

Is there any de-facto standard syntax that editors might interpret as a file + line combination?

Yes, it's `<path>:<lineno>`, support isn't universal, but that's the most widely supported pattern. Even github does support it in it's file browser. ---------------------------------------- Feature #21960: Improve #backtrace to not confuse terminals https://bugs.ruby-lang.org/issues/21960#change-116856 * Author: svoop (Sven Schwyn) * Status: Open ---------------------------------------- The `#backtrace` of exceptions are currently printed like so: ``` /path/to/whatever.rb:8:in `/' /path/to/whatever.rb:8:in `show' (...) ``` Most terminals recognize `/path/to/whatever.rb:8` as a local file and make it clickable as "open in editor", however, some (e.g. Ghostty) include everything up to the next whitespace, in this case `/path/to/whatever.rb:8:in`. This is then used as an argument to `open` (on macOS) which will not work due to the `:in` part. There are two ways to improve this: ## Replace the colon with a space Given the existence of `#backtrace_locations` which is better suited for programmatically working with backtrace locations, it should not break things to slightly modify the `#backtrace` to look like this: ``` /path/to/whatever.rb:8 in `/' /path/to/whatever.rb:8 in `show' (...) ^^^ space instead of colon ``` ## Add OCS 8 sequences [OCS 8](https://github.com/Alhadis/OSC8-Adoption) are the `<a>` tag for terminal output. While many terminals support it, it might cause visual noise in logs and therefore would have to be an opt-in feature e.g. via a Ruby interpreter argument. -- https://bugs.ruby-lang.org/

Issue #21960 has been updated by alanwu (Alan Wu). mame (Yusuke Endoh) wrote in #note-10:

I have to be blunt: this proposal asks us to break backward compatibility based on an unverified assumption. No one has demonstrated that it actually fixes anything. All pain, no gain. I strongly oppose making this change until Ghostty's `file:line` story is settled and someone can show a concrete improvement.

I also don't see replacing the colon with a space as a clear win. As people have said in the Ghostty discussion, there is just no standard for the format. The OSC 8 route might be viable, as there is a way to limit the blast radius without changing the text. We could add it for to-tty exception printouts, around check_highlight_keyword() who checks rb_stderr_tty_p(). And, maybe limit the addition to only the stock implementation of Exception#full_message. Terminals only started adding support for OSC 8 [around 4 years ago](https://github.com/Alhadis/OSC8-Adoption), but hopefully older terminals have the smarts to drop unrecognized OSC sequences without scrambling the output. ---------------------------------------- Feature #21960: Improve #backtrace to not confuse terminals https://bugs.ruby-lang.org/issues/21960#change-117478 * Author: svoop (Sven Schwyn) * Status: Open ---------------------------------------- The `#backtrace` of exceptions are currently printed like so: ``` /path/to/whatever.rb:8:in `/' /path/to/whatever.rb:8:in `show' (...) ``` Most terminals recognize `/path/to/whatever.rb:8` as a local file and make it clickable as "open in editor", however, some (e.g. Ghostty) include everything up to the next whitespace, in this case `/path/to/whatever.rb:8:in`. This is then used as an argument to `open` (on macOS) which will not work due to the `:in` part. There are two ways to improve this: ## Replace the colon with a space Given the existence of `#backtrace_locations` which is better suited for programmatically working with backtrace locations, it should not break things to slightly modify the `#backtrace` to look like this: ``` /path/to/whatever.rb:8 in `/' /path/to/whatever.rb:8 in `show' (...) ^^^ space instead of colon ``` ## Add OCS 8 sequences [OCS 8](https://github.com/Alhadis/OSC8-Adoption) are the `<a>` tag for terminal output. While many terminals support it, it might cause visual noise in logs and therefore would have to be an opt-in feature e.g. via a Ruby interpreter argument. -- https://bugs.ruby-lang.org/