Also format YAML and Project.toml files (#18)

Author: mtfishman

.github/dependabot.yml

@@ -1,7 +1,6 @@
-# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
 version: 2
 updates:
   - package-ecosystem: "github-actions"
-    directory: "/" # Location of package manifests
+    directory: "/"
     schedule:
       interval: "weekly"

Project.toml

@@ -1,6 +1,6 @@
 name = "ITensorFormatter"
 uuid = "b6bf39f1-c9d3-4bad-aad8-593d802f65fd"
-version = "0.2.11"
+version = "0.2.12"
 authors = ["ITensor developers <support@itensor.org> and contributors"]
 
 [workspace]
@@ -9,13 +9,20 @@ projects = ["benchmark", "dev", "docs", "examples", "test"]
 [deps]
 JuliaFormatter = "98e50ef6-434e-11e9-1051-2b60c6c9e899"
 JuliaSyntax = "70703baa-626e-46a2-a12c-08ffd08c73b4"
+OrderedCollections = "bac558e1-5e72-5ebc-8fee-abe8a469f55d"
 Runic = "62bfec6d-59d7-401d-8490-b29ee721c001"
+TOML = "fa267f1f-6049-4f14-aa54-33bafae1ed76"
+YAML = "ddb6d928-2868-570f-bddf-ab3f9cf99eb6"
 
 [compat]
 JuliaFormatter = "2.3"
 JuliaSyntax = "0.4.10"
+OrderedCollections = "1.8.1"
 Runic = "1.5.1"
+TOML = "1.0.3"
+YAML = "0.4.16"
 julia = "1.10"
 
-
-[apps.itfmt]
+[apps]
+itfmt = {}
+itpkgfmt = { submodule = "ITensorPkgFormatter" }

src/ITensorFormatter.jl

@@ -6,307 +6,12 @@ if VERSION >= v"1.11.0-DEV.469"
     end
 end
 
-using JuliaFormatter: JuliaFormatter
-using JuliaSyntax: JuliaSyntax, @K_str, SyntaxNode, children, kind, parseall, span
-using Runic: Runic
-
-# JuliaFormatter options chosen to be compatible with Runic.
-# JuliaFormatter handles line wrapping (which Runic doesn't do),
-# then Runic runs last to canonicalize everything else.
-const JULIAFORMATTER_OPTIONS = (
-    style = JuliaFormatter.DefaultStyle(),
-    indent = 4,
-    margin = 92,
-    always_for_in = true,
-    for_in_replacement = "in",
-    # Semantic transformations consistent with Runic
-    always_use_return = true,
-    import_to_using = true,
-    pipe_to_function_call = true,
-    short_to_long_function_def = true,
-    long_to_short_function_def = false,
-    conditional_to_if = true,
-    short_circuit_to_if = false,
-    # Whitespace options consistent with Runic
-    whitespace_typedefs = true,
-    whitespace_ops_in_indices = true,
-    whitespace_in_kwargs = true,
-    # Annotation/structural changes
-    annotate_untyped_fields_with_any = true,
-    format_docstrings = true,
-    remove_extra_newlines = true,
-    indent_submodule = true,
-    separate_kwargs_with_semicolon = true,
-    surround_whereop_typeparameters = true,
-    disallow_single_arg_nesting = false,
-    normalize_line_endings = "unix",
-    # Line-wrapping-related options
-    trailing_comma = false,
-    join_lines_based_on_source = true,
-    # Floating point formatting options
-    trailing_zero = true,
-)
-
-is_using_or_import(x::SyntaxNode) = kind(x) === K"using" || kind(x) === K"import"
-
-function find_using_or_import(x::SyntaxNode)
-    if is_using_or_import(x)
-        return x.parent
-    elseif iszero(length(children(x)))
-        return nothing
-    else
-        for child in children(x)
-            result = find_using_or_import(child)
-            isnothing(result) || return result
-        end
-        return nothing
-    end
-end
-
-# JuliaSyntax nodes report (position, span) in *bytes*.
-# Julia strings must be sliced using *valid string indices* (start bytes of UTF-8 chars).
-#
-# Convert a node's byte range into a safe `UnitRange` of valid string indices.
-# (O(1): fix endpoints with `thisind`.)
-function node_char_range(n::SyntaxNode, src::AbstractString)
-    startb = n.position
-    nspan = span(n)
-    nspan <= 0 && return startb:(startb - 1) # empty range
-    stopb = min(startb + nspan - 1, ncodeunits(src))
-    return thisind(src, startb):thisind(src, stopb)
-end
-
-function organize_import_blocks_string(s::AbstractString)
-    jst = parseall(SyntaxNode, String(s))
-    return organize_import_blocks(jst)
-end
-
-function organize_import_blocks_file(f::AbstractString)
-    return organize_import_blocks_string(read(f, String))
-end
-
-# Sort symbols, but keep the module self-reference (bare and all aliases) first if present
-function sort_with_self_first(syms::Vector{String}, self::String)
-    syms = unique(syms)
-    selfs = self in syms ? [self] : String[]
-    self_aliases = sort!(filter(s -> startswith(s, self * " as "), syms))
-    rest = sort!(setdiff(syms, [selfs; self_aliases]))
-    return [selfs; self_aliases; rest]
-end
-
-# Organize a single block of adjacent import/using statements
-function organize_import_block(siblings::AbstractVector{<:SyntaxNode}, node_text)
-    using_mods = Set{String}()
-    using_syms = Dict{String, Vector{String}}()
-    import_mods = Set{String}()
-    import_syms = Dict{String, Vector{String}}()
-
-    for s in siblings
-        isusing = kind(s) === K"using"
-        for a in children(s)
-            if kind(a) === K":"
-                a_args = children(a)
-                mod = String(node_text(a_args[1]))
-                set = get!(() -> String[], isusing ? using_syms : import_syms, mod)
-                for i in 2:length(a_args)
-                    push!(set, String(node_text(a_args[i])))
-                end
-            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,
-                    String(node_text(a_args[1])) * " as " * String(node_text(a_args[end]))
-                )
-            else
-                error("Unexpected syntax in using/import statement.")
-            end
-        end
-    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_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_with_self_first(s, m), ", "))
-    end
-    io = IOBuffer()
-    if !isempty(import_lines)
-        print(io, join(sort!(import_lines), "\n"))
-    end
-    if !isempty(import_lines) && !isempty(using_lines)
-        print(io, "\n")
-    end
-    if !isempty(using_lines)
-        print(io, join(sort!(using_lines), "\n"))
-    end
-    return String(take!(io))
-end
-
-function organize_import_blocks(input::SyntaxNode)
-    # Keep a stable copy for slicing: node positions/spans refer to this text.
-    src0 = JuliaSyntax.sourcetext(input)
-    x = find_using_or_import(input)
-    isnothing(x) && return src0
-    child_nodes = children(x)
-    # Find all groups of adjacent import/using statements
-    groups = Vector{SyntaxNode}[]
-    i = 1
-    while i <= length(child_nodes)
-        if is_using_or_import(child_nodes[i])
-            group_start = i
-            while i <= length(child_nodes) && is_using_or_import(child_nodes[i])
-                i += 1
-            end
-            push!(groups, child_nodes[group_start:(i - 1)])
-        else
-            i += 1
-        end
-    end
-    # Extract the source text of a node, trimming whitespace (Unicode-safe).
-    # Always slice from src0 (stable offsets), not the rewritten `src`.
-    node_text(n::SyntaxNode) = strip(src0[node_char_range(n, src0)])
-    # Rewritten output source.
-    src = src0
-    # Process each group from right to left to preserve positions
-    for siblings in reverse(groups)
-        formatted = organize_import_block(siblings, node_text)
-        # Compute splice bounds using src0 (node offsets), then splice into src.
-        first_pos = first(node_char_range(first(siblings), src0))
-        last_pos = last(node_char_range(last(siblings), src0))
-        # Unicode-safe splice boundaries (never do ±1 on raw integer indices)
-        before =
-            first_pos == firstindex(src) ? "" :
-            src[firstindex(src):prevind(src, first_pos)]
-        after_start = nextind(src, last_pos)
-        after = after_start > lastindex(src) ? "" : src[after_start:end]
-        src = before * chomp(formatted) * after
-    end
-    return src
-end
-
-const ITENSORFORMATTER_VERSION = pkgversion(@__MODULE__)
-
-# Print a typical cli program help message
-function print_help()
-    io = stdout
-    printstyled(io, "NAME"; bold = true)
-    println(io)
-    println(io, "       ITensorFormatter.main - format Julia source code")
-    println(io)
-    printstyled(io, "SYNOPSIS"; bold = true)
-    println(io)
-    println(io, "       julia -m ITensorFormatter [<options>] <path>...")
-    println(io)
-    printstyled(io, "DESCRIPTION"; bold = true)
-    println(io)
-    println(
-        io, """
-               `ITensorFormatter.main` (typically invoked as `julia -m ITensorFormatter`)
-               formats Julia source code using the ITensorFormatter.jl formatter.
-        """
-    )
-    printstyled(io, "OPTIONS"; bold = true)
-    println(io)
-    println(
-        io, """
-               <path>...
-                   Input path(s) (files and/or directories) to process. For directories,
-                   all files (recursively) with the '*.jl' suffix are used as input files.
-
-               --help
-                   Print this message.
-
-               --version
-                   Print ITensorFormatter and julia version information.
-        """
-    )
-    return
-end
-
-function print_version()
-    print(stdout, "itfmt version ")
-    print(stdout, ITENSORFORMATTER_VERSION)
-    print(stdout, ", julia version ")
-    print(stdout, VERSION)
-    println(stdout)
-    return
-end
-
-"""
-    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.
-
-# Examples
-
-```julia-repl
-julia> using ITensorFormatter: ITensorFormatter
-
-julia> ITensorFormatter.main(["."]);
-
-julia> ITensorFormatter.main(["file1.jl", "file2.jl"]);
-
-```
-"""
-function main(argv)
-    argv_options = filter(startswith("--"), argv)
-    if !isempty(argv_options)
-        if "--help" in argv_options
-            print_help()
-            return 0
-        elseif "--version" in argv_options
-            print_version()
-            return 0
-        else
-            return error("Options not supported: `$argv_options`.")
-        end
-    end
-    # `argv` doesn't have any options, so treat all arguments as file/directory paths.
-    isempty(argv) && return error("No input paths provided.")
-    inputfiles = String[]
-    for x in argv
-        if isdir(x)
-            Runic.scandir!(inputfiles, x)
-        elseif isfile(x)
-            push!(inputfiles, x) # Assume it is a file for now
-        else
-            error("Input path is not a file or directory: `$x`.")
-        end
-    end
-    isempty(inputfiles) && return 0
-    # Pass 1: Organize import/using blocks
-    for inputfile in inputfiles
-        content = organize_import_blocks_file(inputfile)
-        write(inputfile, content)
-    end
-    # Pass 2: Formatting via JuliaFormatter
-    JuliaFormatter.format(inputfiles; JULIAFORMATTER_OPTIONS...)
-    # Pass 3: Re-organize imports (fix up any changes from JuliaFormatter, e.g. import_to_using)
-    for inputfile in inputfiles
-        content = organize_import_blocks_file(inputfile)
-        write(inputfile, content)
-    end
-    # Pass 4: Format via JuliaFormatter again to fix import line wrapping
-    JuliaFormatter.format(inputfiles; JULIAFORMATTER_OPTIONS...)
-    # Pass 5: Canonicalize via Runic
-    Runic.main(["--inplace"; inputfiles])
-    return 0
-end
-
-@static if isdefined(Base, Symbol("@main"))
-    @main
-end
+include("utils.jl")
+include("format_imports.jl")
+include("format_yaml.jl")
+include("format_project_toml.jl")
+include("main.jl")
+include("generate_readme.jl")
+include("ITensorPkgFormatter.jl")
 
 end

src/ITensorPkgFormatter.jl

@@ -0,0 +1,16 @@
+module ITensorPkgFormatter
+
+using ITensorFormatter: ITensorFormatter
+
+function main(argv)
+    ITensorFormatter.main(argv)
+    paths = filter(!startswith("--"), argv)
+    ITensorFormatter.generate_readmes!(paths)
+    return nothing
+end
+
+@static if isdefined(Base, Symbol("@main"))
+    @main
+end
+
+end