cool stuff indeed

Author: KristofferC

docs/src/toml-files.md

@@ -12,7 +12,6 @@ UUIDs etc.
     [Code Loading](https://docs.julialang.org/en/v1/manual/code-loading/)
     in the Julia manual.
 
-
 ## `Project.toml`
 
 The project file describes the project on a high level, for example, the package/project
@@ -542,3 +541,10 @@ uuid = "edca9bc6-334e-11e9-3554-9595dbb4349c"
 
 There is now an array of the two `B` packages, and the `[deps]` section for `A` has been
 expanded to be explicit about which `B` package `A` depends on.
+## Portable scripts
+
+Julia scripts can embed project and manifest data inline with fenced
+comments such as `#!project … #!project end` and `#!manifest … #!manifest end`.
+When the active project is set to a `.jl` file, Pkg reads and writes inline project metadata
+from that file. All commands that modify the project or manifest
+content (e.g. `Pkg.add`, `Pkg.rm`, `Pkg.update`) will update the inline sections accordingly.

src/Operations.jl

@@ -1537,8 +1537,8 @@ end
 ################################
 
 function prune_manifest(env::EnvCache)
-    # if project uses another manifest, only prune project entry in manifest
-    if isempty(env.workspace) && dirname(env.project_file) != dirname(env.manifest_file)
+    # if project uses another manifest (and we are not a portable script), only prune project entry in manifest
+    if isempty(env.workspace) && dirname(env.project_file) != dirname(env.manifest_file) && !endswith(env.project_file, ".jl")
         proj_entry = env.manifest[env.project.uuid]
         proj_entry.deps = env.project.deps
     else

src/Types.jl

@@ -130,22 +130,57 @@ function _find_inline_section(source::String, kind::Symbol)
     line_start = findprev(isequal('\n'), source, first(begin_idx))
     line_start = line_start === nothing ? 1 : line_start + 1
 
+    # Check if there's a #region marker on the line before
+    region_marker = "#region $(kind_str)"
+    if line_start > 1
+        prev_line_end = line_start - 1  # This is the newline character
+        prev_line_start = findprev(isequal('\n'), source, prev_line_end - 1)
+        prev_line_start = prev_line_start === nothing ? 1 : prev_line_start + 1
+        prev_line = source[prev_line_start:prev_line_end-1]
+        if strip(prev_line) == region_marker
+            line_start = prev_line_start
+        end
+    end
+
     # Determine format by checking if there's a #= after the begin marker
     # Look at content between begin and end markers
     content_start = last(begin_idx) + 1
     content_end = first(end_idx) - 1
     content_between = source[content_start:content_end]
     format = contains(content_between, "#=") ? :multiline : :line
 
-    # Find the newline after the end marker (if it exists)
+    # Find the newline after the end marker
     char_after_end = last(end_idx) < lastindex(source) ? source[nextind(source, last(end_idx))] : nothing
+    included_newline = false
     span_end_pos = if char_after_end == '\n' || (char_after_end == '\r' && last(end_idx) + 1 < lastindex(source) && source[last(end_idx) + 2] == '\n')
         # Include the newline in the span
+        included_newline = true
         char_after_end == '\r' ? last(end_idx) + 2 : last(end_idx) + 1
     else
         last(end_idx)
     end
 
+    # Check if there's a #endregion marker on the next line after end marker
+    endregion_marker = "#endregion $(kind_str)"
+    if included_newline && span_end_pos < lastindex(source)
+        # If we included a newline, start looking at the next character
+        next_line_start = span_end_pos + 1
+        next_line_end = findnext(isequal('\n'), source, next_line_start)
+        if next_line_end !== nothing
+            next_line = source[next_line_start:next_line_end-1]
+            if strip(next_line) == endregion_marker
+                # Include the #endregion line and its newline in the span
+                span_end_pos = next_line_end + 1
+            end
+        elseif next_line_start <= lastindex(source)
+            # No newline found, check if rest of file is the endregion marker
+            next_line = source[next_line_start:end]
+            if strip(next_line) == endregion_marker
+                span_end_pos = lastindex(source)
+            end
+        end
+    end
+
     return (
         span_start = line_start,
         span_end = span_end_pos,
@@ -154,21 +189,43 @@ function _find_inline_section(source::String, kind::Symbol)
     )
 end
 
-function update_inline_project!(path::AbstractString, toml::String)
+function _update_inline_section!(path::AbstractString, kind::Symbol, toml::String)
     source = read(path, String)
-    section = _find_inline_section(source, :project)
+    section = _find_inline_section(source, kind)
 
     if section === nothing
-        # No existing section, add one at the beginning
+        # No existing section, add appropriately
         newline = contains(source, "\r\n") ? "\r\n" : "\n"
-        replacement = _render_inline_block(:project, toml, newline, :line)
-        new_source = isempty(source) ? replacement : replacement * newline * source
+        replacement = _render_inline_block(kind, toml, newline, :line)
+
+        if kind === :project
+            # Project goes at the beginning
+            new_source = isempty(source) ? replacement : replacement * newline * source
+        else
+            # Manifest goes at the bottom
+            project_section = _find_inline_section(source, :project)
+            if project_section === nothing
+                # No project section either, add empty project at top and manifest at bottom
+                project_block = _render_inline_block(:project, "", newline, :line)
+                if isempty(source)
+                    new_source = project_block * newline * replacement
+                else
+                    new_source = project_block * newline * source * newline * replacement
+                end
+            else
+                # Add manifest at the bottom of the file
+                replacement = _render_inline_block(kind, toml, project_section.newline, project_section.format)
+                new_source = source * project_section.newline * replacement
+            end
+        end
     else
         # Replace existing section
-        replacement = _render_inline_block(:project, toml, section.newline, section.format)
+        replacement = _render_inline_block(kind, toml, section.newline, section.format)
         prefix = section.span_start == firstindex(source) ? "" : source[firstindex(source):prevind(source, section.span_start)]
         suffix = section.span_end == lastindex(source) ? "" : source[nextind(source, section.span_end):lastindex(source)]
-        new_source = prefix * replacement * suffix
+        # Add a blank line after the section if there's content after it
+        separator = !isempty(suffix) && !startswith(suffix, section.newline) ? section.newline : ""
+        new_source = prefix * replacement * separator * suffix
     end
 
     open(path, "w") do io
@@ -177,42 +234,29 @@ function update_inline_project!(path::AbstractString, toml::String)
     return nothing
 end
 
-function update_inline_manifest!(path::AbstractString, toml::String)
+function remove_inline_section!(path::AbstractString, kind::Symbol)
     source = read(path, String)
-    project_section = _find_inline_section(source, :project)
-    manifest_section = _find_inline_section(source, :manifest)
-
-    if manifest_section === nothing
-        # No existing manifest section, add one at the bottom
-        if project_section === nothing
-            # No project section either, add project at top and manifest at bottom
-            newline = contains(source, "\r\n") ? "\r\n" : "\n"
-            project_block = _render_inline_block(:project, "", newline, :line)
-            manifest_block = _render_inline_block(:manifest, toml, newline, :line)
-            if isempty(source)
-                new_source = project_block * newline * manifest_block
-            else
-                new_source = project_block * newline * source * newline * manifest_block
-            end
-        else
-            # Add manifest at the bottom of the file
-            replacement = _render_inline_block(:manifest, toml, project_section.newline, project_section.format)
-            new_source = source * project_section.newline * replacement
-        end
-    else
-        # Replace existing manifest section
-        replacement = _render_inline_block(:manifest, toml, manifest_section.newline, manifest_section.format)
-        prefix = manifest_section.span_start == firstindex(source) ? "" : source[firstindex(source):prevind(source, manifest_section.span_start)]
-        suffix = manifest_section.span_end == lastindex(source) ? "" : source[nextind(source, manifest_section.span_end):lastindex(source)]
-        new_source = prefix * replacement * suffix
-    end
+    section = _find_inline_section(source, kind)
 
-    open(path, "w") do io
-        write(io, new_source)
+    if section !== nothing
+        prefix = section.span_start == firstindex(source) ? "" : source[firstindex(source):prevind(source, section.span_start)]
+        suffix = section.span_end >= lastindex(source) ? "" : source[nextind(source, section.span_end):lastindex(source)]
+        new_source = prefix * suffix
+        open(path, "w") do io
+            write(io, new_source)
+        end
     end
     return nothing
 end
 
+function update_inline_project!(path::AbstractString, toml::String)
+    return _update_inline_section!(path, :project, toml)
+end
+
+function update_inline_manifest!(path::AbstractString, toml::String)
+    return _update_inline_section!(path, :manifest, toml)
+end
+
 ###############
 # PackageSpec #
 ###############
@@ -592,10 +636,38 @@ function EnvCache(env::Union{Nothing, String} = nothing)
     end
 
     dir = abspath(project_dir)
-    # For .jl files, always use the same file for both project and manifest (inline)
+
+    # Save the original project before any modifications
+    original_project = deepcopy(project)
+
+    # For .jl files, handle inline_manifest flag and fix inconsistent states
     if endswith(project_file, ".jl")
-        manifest_file = project_file
+        inline_manifest = get(project.other, "inline_manifest", true)::Bool
+
+        # Case 1: inline_manifest=false but no manifest path
+        # User wants external manifest but hasn't set it up yet
+        if !inline_manifest && project.manifest === nothing
+            # Generate a new UUID and set manifest path
+            script_uuid = string(uuid4())
+            script_name = splitext(basename(project_file))[1]
+            manifest_file = joinpath(depots1(), "environments", "scripts", "$(script_name)_$(script_uuid)", "Manifest.toml")
+            project.manifest = manifest_file
+        # Case 2: inline_manifest=true (or default) but has manifest path
+        # User wants inline manifest but still has external path set
+        elseif inline_manifest && project.manifest !== nothing
+            # Load from external path for reading this time
+            manifest_file = isabspath(project.manifest) ? project.manifest : abspath(dir, project.manifest)
+            # But clear the path so it gets written inline later
+            # (We'll clean up the external file in write_env)
+        # Case 3: inline_manifest=false and has manifest path (consistent state)
+        elseif !inline_manifest && project.manifest !== nothing
+            manifest_file = isabspath(project.manifest) ? project.manifest : abspath(dir, project.manifest)
+        # Case 4: inline_manifest=true and no manifest path (consistent state, default)
+        else
+            manifest_file = project_file
+        end
     else
+        # For regular .toml files, use standard logic
         manifest_file = manifest_file !== nothing ?
             (isabspath(manifest_file) ? manifest_file : abspath(dir, manifest_file)) :
             manifestfile_path(dir)::String
@@ -611,7 +683,7 @@ function EnvCache(env::Union{Nothing, String} = nothing)
         project,
         workspace,
         manifest,
-        deepcopy(project),
+        original_project,
         deepcopy(manifest),
     )
 
@@ -1565,12 +1637,45 @@ function write_env(
         pkgerror("Cannot modify a readonly environment. The project at $(env.project_file) is marked as readonly.")
     end
 
+    # Handle transitions for portable scripts
+    transitioning_to_inline = false
+    if endswith(env.project_file, ".jl")
+        inline_manifest = get(env.project.other, "inline_manifest", true)::Bool
+
+        # If transitioning to inline and we had an external manifest, clean it up
+        if inline_manifest && env.project.manifest !== nothing
+            transitioning_to_inline = true
+            external_manifest_path = isabspath(env.project.manifest) ? env.project.manifest :
+                abspath(dirname(env.project_file), env.project.manifest)
+            # Clear the manifest path so it writes inline
+            env.project.manifest = nothing
+            # Update manifest_file to point to the script file for inline writing
+            env.manifest_file = env.project_file
+            # Clean up external manifest directory
+            external_dir = dirname(external_manifest_path)
+            if isdir(external_dir)
+                rm(external_dir; recursive=true, force=true)
+            end
+        end
+    end
+
     if (env.project != env.original_project) && (!skip_writing_project)
         write_project(env, skip_readonly_check)
     end
-    if env.manifest != env.original_manifest
+    # Force manifest write when transitioning to inline, even if manifest hasn't changed
+    if env.manifest != env.original_manifest || transitioning_to_inline
         write_manifest(env)
     end
+
+    # Remove inline manifest section if we have external manifest
+    if endswith(env.project_file, ".jl")
+        inline_manifest = get(env.project.other, "inline_manifest", true)::Bool
+        if !inline_manifest
+            # Remove the inline manifest section since we're using external
+            remove_inline_section!(env.project_file, :manifest)
+        end
+    end
+
     return update_undo && Pkg.API.add_snapshot_to_undo(env)
 end