Merge branch 'main' into origin/dev

Author: dev1bryant

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Havlik Marcell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Project.toml

@@ -1,4 +1,7 @@
 name = "RelevanceStacktrace"
 uuid = "6c8a4c8a-cd07-4735-95b7-b1ced2eaf8fd"
-authors = ["Your Name <you@example.com>"]
-version = "1.0.1"
+authors = ["Marcell Havlik <havlikmarcell@gmail.com>"]
+version = "0.1.8"
+
+[compat]
+julia = "^1.7"

README.md

@@ -1,41 +1,105 @@
 # RelevanceStacktrace.jl
-Julia relevance Stacktrace. 
+**Find the error as fast as possible!**
 
-# Goal
-What are you searching during development?
-99% of the time for the **TOP error of the stacktrace from your project's files**. >> **So it highlights it! :)**
-1% you can use the unhighlighted parts. :)
+Most important elements in the stacktrace:
+1. error **source file that you edit** 
+	1. **file + filename + line number**
+	2. function name
+	3. stack depth counter
+	4. modul name
+2. other project files
+3. other internal files
+
+So let's design it like this! -> RelevanceStacktrace
 
 # Why
-Julia stacktrace is for finding error. Why don't we use it to help us right? ;) 
 
-# Usage
-Many way... but easiest:
+**Stacktrace is for locating the error. Let's FOCUS ONLY on that.**
+
+With this package in the past years I literally forgot what does searching for error is as I just click on the **BOLD GREEN** filename with a ctrl + click in vscode each time.
+  
+**Green!** Because locating the error is a good thing. Not bad! So "Julia locate the right file and highlight it for us! ;) "
+
+I think 99% of the time the error will be in the **the first error of the stacktrace from your project's files**. >> **So it highlights it! :)**
 
-`include(path_to_file * "RelevanceStacktrace.jl/src/RelevanceStacktrace.jl")`
+Any other time you will always have the unhighlighted parts. :)
 
-or terminal
+# Demo
+Artificial error, to see it's power:
+```
+using RelevanceStacktrace
+func4(x) = begin
+	x+=x
+	x=sum(x) .* [5, 3]
+	x=sum(x[3])
+	return x/3
+end
+func3(x) = x+5 + func4(x)
+func2(x) = x+3 + func3(x)
+func1(x) = begin
+	func2(x)
+end
+func1(3)
+```
+![artificial error example](/assets/artificial_error.png)
+In real life example it is even more useful.
 
+Long stacktrace error:
+```
+sum([])
 ```
-julia
+![long internal error example](/assets/sum([])_error.png)
+This is still nice I think, but to be honest RelevanceStacktrace shines better when the error is in some of your project file.
+
+# INSTALL
+
+Many way... but easiest:
+
+```julia
 ] add https://github.com/Cvikli/RelevanceStacktrace.jl.git
-then: using RelevanceStacktrace
+using RelevanceStacktrace
 ```
 
-or from a folder next to the cloned repo you can try using this version
+or
 
+```julia
+include(path_to_file * "RelevanceStacktrace.jl/src/RelevanceStacktrace.jl")
+using .RelevanceStacktrace
 ```
+
+or from a folder next to the cloned repo you can try using this version
+
+```julia
 push!(LOAD_PATH, "../RelevanceStacktrace.jl/"); Base.load_path()
 using RelevanceStacktrace
 ```
-
-But for me it doesn't perform well in certain situation, which I didn't have time to figure out... It only loads the package for the second time in this case...
+or 
+```
+using Pkg; Pkg.add(url="https://github.com/Cvikli/RelevanceStacktrace.jl.git")
+using RelevanceStacktrace
+```
 
 # Fun fact
-**Debug the Debug.** :D We catch the error in the error handling and do a very basic error printing mechanism, so we can debug the backtrace printing error. 
-We overloaded the Base.print_stackframe... so basically any stackprinting will be changed with this method. :) 
+
+**Debug the Debug.** :D We catch the error in the error handling and do a very basic error printing mechanism, so we can debug the backtrace printing error.
 
 **The relevant errors are green, because finding one is a good thing!** ;)
 
+**Fallback to raw stacktrace printing.** As the project is sort of experimental, if a special case happen that we just don't bother to handle, it will fall back to print it in a basic format.
+
+# Future works?
+**Module names are useless.** Actually we could drop the modul names as it just waste of space
+
+**Function param types are pretty useless.** Maybe we could just show function names and parameters::types if it is actually matters... (As it is used very very rarely!) 
+
+**AbbreviatedStackTraces sounds interesting** We could merge it into this project with an optional flag maybe later on? 
+
+# Great stacktraces
+- AbbreviatedStackTraces: great project. :) https://github.com/BioTurboNick/AbbreviatedStackTraces.jl As UX decision I didn't merged it as the variation of stacktrace can create interruption in the thinking. We expect the output to be always the same. But of course more test should be done if someone believe it can be useful. 
+- ClearStacktrace: was great for inspiration! https://github.com/jkrumbiegel/ClearStacktrace.jl
+
 # Note
-(**only tested on Ubuntu for Julia 1.6!** )
+
+(**only tested on Ubuntu for Julia 1.8!** )
+
+(**later version was tested on Ubuntu for Julia 1.6 and 1.7!** )

assets/artificial_error.png

@@ -1,15 +1,15 @@
 module RelevanceStacktrace
 import Base: find_source_file, show_full_backtrace, StackFrame, fixup_stdlib_path,
-stacktrace_expand_basepaths, stacktrace_contract_userdir, contractuser
+stacktrace_expand_basepaths, stacktrace_contract_userdir, contractuser, something
 
-KNOWN_MODULES = ["VSCodeServer", "Core", "Distributed"]
-KNOWN_MODULES_PATHS_1 = ["."]
-KNOWN_MODULES_PATHS_2 = [".vscode", ".julia", "buildworker"]
+const KNOWN_MODULES = ["VSCodeServer", "Core", "Distributed"]
+const KNOWN_MODULES_PATHS_BASE = ["."]
+const KNOWN_MODULES_PATHS = [".vscode", ".julia", "buildworker"]
 
 is_project_file(modul, pathparts) = (
 	!(string(modul) in KNOWN_MODULES) && 
-	!(pathparts[1] in KNOWN_MODULES_PATHS_1) && 
-	!(length(pathparts)>1 && pathparts[2] in KNOWN_MODULES_PATHS_2))
+	!(pathparts[1] in KNOWN_MODULES_PATHS_BASE) && 
+	!any(pathpart in KNOWN_MODULES_PATHS for pathpart in pathparts))  
 
 # This is useful because of  
 function print_stackframe_relevance(io, i, frame::Base.StackFrame, n::Int, digit_align_width, modulecolordict, ownmodulescounter)
@@ -82,7 +82,8 @@ function print_stackframe_relevance_print(io, i, frame::Base.StackFrame, n::Int,
 end
 
 
-function Base.show_full_backtrace(io::IO, trace::Vector; print_linebreaks::Bool)
+Base.show_full_backtrace(io::IO, trace::Vector; print_linebreaks::Bool) = show_full_backtrace_relevance(io, trace, print_linebreaks)
+function show_full_backtrace_relevance(io::IO, trace, print_linebreaks::Bool)
   num_frames = length(trace)
   ndigits_max = ndigits(num_frames)
 
@@ -92,12 +93,16 @@ function Base.show_full_backtrace(io::IO, trace::Vector; print_linebreaks::Bool)
   println(io, "\nStacktrace:")
 
   try
-    for (i, (frame, n)) in enumerate(trace)
+    trace_fix = convert(Vector{Tuple{StackFrame, Int}}, trace)
+    i=1
+    while length(trace_fix) >= i
+      frame, n = trace_fix[i]
       print_stackframe_relevance(io, i, frame, n, ndigits_max, modulecolordict, ownmodulescounter)
       if i < num_frames
           println(io)
           print_linebreaks && println(io)
       end
+      i+=1
     end
   catch e
     println(io)

assets/sum([])_error.png

@@ -6,7 +6,12 @@ using Revise
 includet("../src/RelevanceStacktrace.jl")
 
 
-func4(x) = x .* ["32", 3]
+func4(x) = begin
+	x+=x
+	x=sum(x) .* [5, 3]
+	x=sum(x[3])
+	return x/3
+end
 func3(x) = x+5 + func4(x)
 func2(x) = x+3 + func3(x)
 func1(x) = begin
@@ -15,17 +20,59 @@ end
 func1(3)
 
 #%%
+show_full_backtrace(io::IO, trace::Vector{Tuple{Base.StackTraces.StackFrame, Int}}; print_linebreaks::Bool)
+#%%
+using Plots
+using BenchmarkTools, Plots
+plot([1,2,3], seriestype=:blah)
+# @btime plot([1,2,3], seriestype=:blah)
+#%%
+sum([])
+#%%
+
+# func4(x) = x .* ["32", 3]
+# func3(x) = x+5 + func4(x)
+# func2(x) = x+3 + func3(x)
+# func1(x) = begin
+# 	func2(x)
+# end
+# func1(3)
+using Base: stacktrace_linebreaks, process_backtrace, StackFrame
+using .RelevanceStacktrace: show_full_backtrace_relevance
 try
-	eval(Meta.parse("invalidfn()"))
+	# eval(Meta.parse("invalidfn()"))
+	func1(3)
 catch e
+	# x= process_backtrace(catch_backtrace())
+	# @show x
+	# for (f,i) in x
+	# 	@show typeof(f)
+	# 	@show typeof(i)
+	# end
+	# @show e
+	# @show process_backtrace(catch_backtrace())
+	# @show "eq"
+	# @show convert(Vector{Tuple{StackFrame, Int}}, process_backtrace(catch_backtrace()))
+	@code_warntype show_full_backtrace_relevance(stdout, process_backtrace(catch_backtrace()), false)
 	# @edit showerror(stdout, e, catch_backtrace())
 	# showerror(stdout, e)
-	@edit Base.show_backtrace(stdout, catch_backtrace())
+	# @edit Base.show_backtrace(stdout, catch_backtrace())
 end
 #%%
+@code_warntype catch_backtrace()
+#%%
+typeof(catch_backtrace())
+#%%
+process_backtrace(catch_backtrace())
+#%%
+using Base: stacktrace_linebreaks,process_backtrace
+stacktrace_linebreaks()
+#%%
+
+process_backtrace(catch_backtrace())
 
-Base.show_full_backtrace(io, filtered; print_linebreaks = stacktrace_linebreaks())
 #%%
+error("bla")
 #%%