Small fixes and tweaks (#1)

Author: mtfishman

Project.toml

@@ -1,6 +1,6 @@
 name = "ITensorFormatter"
 uuid = "b6bf39f1-c9d3-4bad-aad8-593d802f65fd"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["ITensor developers <support@itensor.org> and contributors"]
 
 [workspace]

docs/Project.toml

@@ -9,4 +9,4 @@ ITensorFormatter = {path = ".."}
 [compat]
 Documenter = "1"
 Literate = "2"
-ITensorFormatter = "0.1"
+ITensorFormatter = "0.2"

examples/Project.toml

@@ -5,4 +5,4 @@ ITensorFormatter = "b6bf39f1-c9d3-4bad-aad8-593d802f65fd"
 ITensorFormatter = {path = ".."}
 
 [compat]
-ITensorFormatter = "0.1"
+ITensorFormatter = "0.2"

examples/README.jl

@@ -1,5 +1,5 @@
 # # ITensorFormatter.jl
-# 
+#
 # [![Stable](https://img.shields.io/badge/docs-stable-blue.svg)](https://itensor.github.io/ITensorFormatter.jl/stable/)
 # [![Dev](https://img.shields.io/badge/docs-dev-blue.svg)](https://itensor.github.io/ITensorFormatter.jl/dev/)
 # [![Build Status](https://github.com/ITensor/ITensorFormatter.jl/actions/workflows/Tests.yml/badge.svg?branch=main)](https://github.com/ITensor/ITensorFormatter.jl/actions/workflows/Tests.yml?query=branch%3Amain)

src/ITensorFormatter.jl

@@ -1,8 +1,14 @@
 module ITensorFormatter
 
-using JuliaFormatter
-using JuliaSyntax: @K_str, JuliaSyntax, SyntaxNode, children, kind, parseall, span
-using Runic
+if VERSION >= v"1.11.0-DEV.469"
+    let str = "public main"
+        eval(Meta.parse(str))
+    end
+end
+
+using JuliaFormatter: JuliaFormatter
+using JuliaSyntax: JuliaSyntax, @K_str, SyntaxNode, children, kind, parseall, span
+using Runic: Runic
 
 function is_using_or_import(x)
     return kind(x) === K"using" || kind(x) === K"import"
@@ -22,7 +28,7 @@ function find_using_or_import(x)
     end
 end
 
-char_range(x) = x.position:(x.position + span(x))
+char_range(x) = x.position:(x.position + span(x) - 1)
 
 function organize_import_file(f)
     jst = parseall(SyntaxNode, read(f, String))
@@ -33,50 +39,49 @@ function organize_import_block(input)
     # Collect all sibling blocks that are also using/import expressions
 
     x = find_using_or_import(input)
-    isnothing(x) && return
+    isnothing(x) && return JuliaSyntax.sourcetext(input)
 
     siblings = []
 
     child_nodes = children(x)
-    ind = findfirst(is_using_or_import, child_nodes)
+    first_ind = findfirst(is_using_or_import, child_nodes)
 
-    while !isnothing(ind)
-        push!(siblings, popat!(child_nodes, ind))
-        ind = findfirst(is_using_or_import, child_nodes)
+    for ind in first_ind:length(child_nodes)
+        if is_using_or_import(child_nodes[ind])
+            push!(siblings, child_nodes[ind])
+        else
+            break
+        end
     end
 
+    src = JuliaSyntax.sourcetext(input)
+
     # Collect all modules and symbols
     using_mods = Set{String}()
     using_syms = Dict{String, Set{String}}()
     import_mods = Set{String}()
     import_syms = Dict{String, Set{String}}()
 
-    # Joins e.g. [".", ".", "Foo", "Bar"] (from "using ..Foo.Bar") to "..Foo.Bar"
-    function module_join(x)
-        io = IOBuffer()
-        for y in children(x)[1:(end - 1)]
-            print(io, y.val)
-            y.val == "." && continue
-            print(io, ".")
-        end
-        print(io, children(x)[end].val)
-        return String(take!(io))
-    end
+    # Extract the source text of a node, trimming whitespace
+    node_text(x) = strip(src[char_range(x)])
 
     for s in siblings
         isusing = kind(s) === K"using"
         for a in children(s)
             if kind(a) === K":"
                 a_args = children(a)
-                mod = module_join(a_args[1])
+                mod = node_text(a_args[1])
                 set = get!(Set, isusing ? using_syms : import_syms, mod)
                 for i in 2:length(a_args)
-                    push!(set, join(y.val for y in children(a_args[i])))
+                    push!(set, String(node_text(a_args[i])))
                 end
-            elseif kind(a) === K"."
-                push!(isusing ? using_mods : import_mods, module_join(a))
+            elseif kind(a) === K"." || kind(a) === K"importpath"
+                push!(isusing ? using_mods : import_mods, String(node_text(a)))
+            elseif !isusing && kind(a) === K"as"
+                a_args = children(a)
+                push!(import_mods, node_text(a_args[1]) * " as " * node_text(a_args[end]))
             else
-                error("unreachable?")
+                error("Unexpected syntax in using/import statement.")
             end
         end
     end
@@ -86,66 +91,78 @@ function organize_import_block(input)
     #       BlueStyle (modules, types, ..., functions) since usually CamelCase is used for
     #       modules, types, etc, but possibly this can be improved by using information
     #       available from SymbolServer
+    # Sort symbols, but keep the module self-reference first if present
+    function sort_with_self_first(syms, self)
+        self′ = pop!(syms, self, nothing)
+        sorted = sort!(collect(syms))
+        if self′ !== nothing
+            pushfirst!(sorted, self)
+        end
+        return sorted
+    end
+
     import_lines = String[]
     for m in import_mods
         push!(import_lines, "import " * m)
     end
     for (m, s) in import_syms
-        push!(import_lines, "import " * m * ": " * join(sort!(collect(s)), ", "))
+        push!(import_lines, "import " * m * ": " * join(sort_with_self_first(s, m), ", "))
     end
     using_lines = String[]
     for m in using_mods
         push!(using_lines, "using " * m)
     end
     for (m, s) in using_syms
-        push!(using_lines, "using " * m * ": " * join(sort!(collect(s)), ", "))
+        push!(using_lines, "using " * m * ": " * join(sort_with_self_first(s, m), ", "))
     end
     io = IOBuffer()
     join(io, sort!(import_lines), "\n")
-    length(import_lines) > 0 && print(io, "\n\n")
+    length(import_lines) > 0 && length(using_lines) > 0 && print(io, "\n")
     join(io, sort!(using_lines), "\n")
     str_to_fmt = String(take!(io))
 
     # Line wrap the using/import statements only
     formatted = JuliaFormatter.format_text(str_to_fmt; join_lines_based_on_source = true)
 
-    src = JuliaSyntax.sourcetext(input)
-
-    statement_range = char_range(siblings[1])
     first_pos = first(char_range(siblings[1]))
+    last_pos = last(char_range(siblings[end]))
 
-    content = src[1:first_pos-1] * formatted
-
-    content_to_append = ""
-
-    last_pos = last(char_range(siblings[1]))
-
-    # Get the content between the using/import statements
-    for s in siblings[2:end]
-        statement_range = char_range(s)
-        content_to_append *= src[last_pos + 1:(first(statement_range) - 1)]
-        last_pos = last(statement_range)
-    end
-
-    if length(content_to_append) > 1
-        content_to_append = "\n" * content_to_append
-    end
-    
-    # Tack this onto the end
-    content *= content_to_append * src[(last_pos + 1):end]
+    content = src[1:(first_pos - 1)] * chomp(formatted) * src[(last_pos + 1):end]
 
     return content
 end
 
-function (@main)(ARGS)
-    for file in ARGS
-        _, ext = splitext(file)
-        ext == ".jl" || error("Only .jl files are supported")
-        content = organize_import_file(file)
-        write(file, content)
+"""
+    ITensorFormatter.main(argv)
+
+Format Julia source files. Primarily formats using Runic formatting, but additionally
+organizes using/import statements by merging adjacent blocks, sorting modules and symbols,
+and line-wrapping. Accepts file paths and directories as arguments. Options starting with
+`--` are forwarded to Runic, see the
+[Runic documentation](https://github.com/fredrikekre/Runic.jl) for more details.
+"""
+function main(argv)
+    inputfiles = String[]
+    x = filter(!startswith("--"), argv)
+    for x in argv
+        if startswith(x, "--")
+            # Ignore options for now, they are assumed to be for Runic.
+        elseif isdir(x)
+            Runic.scandir!(inputfiles, x)
+        else # isfile(x)
+            push!(inputfiles, x) # Assume it is a file for now
+        end
+    end
+    for inputfile in inputfiles
+        content = organize_import_file(inputfile)
+        write(inputfile, content)
     end
-    Runic.main(ARGS)
+    Runic.main(argv)
     return 0
-end 
+end
+
+@static if isdefined(Base, Symbol("@main"))
+    @main
+end
 
 end

test/Project.toml

@@ -1,6 +1,7 @@
 [deps]
 Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595"
 ITensorFormatter = "b6bf39f1-c9d3-4bad-aad8-593d802f65fd"
+JuliaSyntax = "70703baa-626e-46a2-a12c-08ffd08c73b4"
 SafeTestsets = "1bc83da4-3b8d-516f-aca4-4fe02f6d838f"
 Suppressor = "fd094767-a336-5f1f-9728-57cf17d0bbfb"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
@@ -10,7 +11,8 @@ ITensorFormatter = {path = ".."}
 
 [compat]
 Aqua = "0.8"
-ITensorFormatter = "0.1"
+ITensorFormatter = "0.2"
+JuliaSyntax = "0.4.10"
 SafeTestsets = "0.1"
 Suppressor = "0.2"
 Test = "1.10"

test/test_basics.jl

@@ -1,6 +1,126 @@
 using ITensorFormatter: ITensorFormatter
+using JuliaSyntax: SyntaxNode, parseall
 using Test: @test, @testset
 
+function organize(s)
+    jst = parseall(SyntaxNode, s)
+    return ITensorFormatter.organize_import_block(jst)
+end
+
 @testset "ITensorFormatter" begin
-    # Tests go here.
+    @testset "no imports" begin
+        @test organize("x = 1\n") == "x = 1\n"
+    end
+
+    @testset "single using with colon" begin
+        @test organize("using Foo: bar\n") == "using Foo: bar\n"
+    end
+
+    @testset "single import with colon" begin
+        @test organize("import Foo: bar\n") == "import Foo: bar\n"
+    end
+
+    @testset "bare using Package" begin
+        @test organize("using Foo\n") == "using Foo\n"
+    end
+
+    @testset "bare import Package" begin
+        @test organize("import Foo\n") == "import Foo\n"
+    end
+
+    @testset "sort symbols alphabetically" begin
+        result = organize("using Foo: baz, bar\n")
+        @test result == "using Foo: bar, baz\n"
+    end
+
+    @testset "self-reference stays first" begin
+        result = organize("using Foo: bar, Foo\n")
+        @test result == "using Foo: Foo, bar\n"
+    end
+
+    @testset "sort mixed symbols with self-reference" begin
+        result = organize("using Foo: baz, Foo, Bar, bar\n")
+        @test result == "using Foo: Foo, Bar, bar, baz\n"
+    end
+
+    @testset "merge duplicate using statements" begin
+        result = organize("using Foo: bar\nusing Foo: baz\n")
+        @test result == "using Foo: bar, baz\n"
+    end
+
+    @testset "merge duplicate import statements" begin
+        result = organize("import Foo: bar\nimport Foo: baz\n")
+        @test result == "import Foo: bar, baz\n"
+    end
+
+    @testset "import before using" begin
+        result = organize("using Foo: foo\nimport Bar: bar\n")
+        @test result == "import Bar: bar\nusing Foo: foo\n"
+    end
+
+    @testset "preserve code after imports" begin
+        result = organize("using Foo: bar\nx = 1\n")
+        @test result == "using Foo: bar\nx = 1\n"
+    end
+
+    @testset "preserve code before imports" begin
+        result = organize("x = 1\nusing Foo: bar\n")
+        @test result == "x = 1\nusing Foo: bar\n"
+    end
+
+    @testset "relative import using .Package" begin
+        result = organize("using .Foo: bar\n")
+        @test result == "using .Foo: bar\n"
+    end
+
+    @testset "relative import using ..Package" begin
+        result = organize("using ..Foo: bar\n")
+        @test result == "using ..Foo: bar\n"
+    end
+
+    @testset "bare relative using" begin
+        result = organize("using .Foo\n")
+        @test result == "using .Foo\n"
+    end
+
+    @testset "dotted module path" begin
+        result = organize("using Foo.Bar: baz\n")
+        @test result == "using Foo.Bar: baz\n"
+    end
+
+    @testset "import as" begin
+        result = organize("import Foo as Bar\n")
+        @test result == "import Foo as Bar\n"
+    end
+
+    @testset "import relative as" begin
+        result = organize("import .Foo as Bar\n")
+        @test result == "import .Foo as Bar\n"
+    end
+
+    @testset "bare using and using with colon" begin
+        result = organize("using Foo\nusing Bar: baz\n")
+        @test result == "using Bar: baz\nusing Foo\n"
+    end
+
+    @testset "only adjacent imports are collected" begin
+        input = "using Foo: foo\nx = 1\nusing Bar: bar\n"
+        result = organize(input)
+        @test result == "using Foo: foo\nx = 1\nusing Bar: bar\n"
+    end
+
+    @testset "sort multiple using lines" begin
+        result = organize("using Zebra: z\nusing Alpha: a\n")
+        @test result == "using Alpha: a\nusing Zebra: z\n"
+    end
+
+    @testset "sort multiple import lines" begin
+        result = organize("import Zebra: z\nimport Alpha: a\n")
+        @test result == "import Alpha: a\nimport Zebra: z\n"
+    end
+
+    @testset "mixed bare and colon imports" begin
+        result = organize("import Foo\nimport Bar: baz\n")
+        @test result == "import Bar: baz\nimport Foo\n"
+    end
 end