refactoring precompilation

Author: Janis Erdmanis

recipes/macos/dmg_settings.py

@@ -4,48 +4,7 @@ SCRIPT_DIR=$(dirname "$0")
 BUNDLE_DIR=$(realpath $(dirname $(dirname $SCRIPT_DIR)))
 
 APP_NAME={{APP_NAME}}
-WITH_SPLASH_SCREEN={{WITH_SPLASH_SCREEN}}
+#WITH_SPLASH_SCREEN={{WITH_SPLASH_SCREEN}}
 
-JULIA_HOME="$SCRIPT_DIR/julia"
-export JULIA="$JULIA_HOME/bin/julia"
-
-if [ -z "$APP_SANDBOX_CONTAINER_ID" ]; then
-    echo "Running outside SandBox environment"
-
-    CACHE_DIR="$HOME/.cache/$APP_NAME"
-    export USER_DATA="$HOME/.config/$APP_NAME"
-else
-    echo "Running in a SandBox environment"
-
-    CACHE_DIR="$HOME/Library/Caches/depot"
-    export USER_DATA="$HOME/Library/Application Support/Local"
-fi
-
-mkdir -p "$USER_DATA"
-
-export JULIA_LOAD_PATH="$SCRIPT_DIR/packages:@stdlib:@" 
-export JULIA_PROJECT="$SCRIPT_DIR/$APP_NAME"
-
-JULIA_MAIN="$SCRIPT_DIR/$APP_NAME/main.jl"
-
-export JULIA_DEPOT_PATH="$CACHE_DIR:$SCRIPT_DIR/"
-
-PRECOMPILED="$CACHE_DIR/precompiled"
-
-if [ -e $PRECOMPILED ] || [ -d "$SCRIPT_DIR/compiled" ]; then
-
-    $JULIA --startup-file=no -L "$SCRIPT_DIR/startup/init.jl" $JULIA_MAIN
-    
-else
-
-    if $WITH_SPLASH_SCREEN ; then
-        $JULIA --startup-file=no "$SCRIPT_DIR/startup/configure.jl"
-    else
-        $JULIA --startup-file=no "$SCRIPT_DIR/startup/precompile.jl"
-    fi
-
-    mkdir -p $(dirname $PRECOMPILED)
-    touch "$PRECOMPILED"
-    open --new $BUNDLE_DIR # This likelly does not work in a sandbox
-
-fi
+JULIA="$SCRIPT_DIR/julia/bin/julia"
+$JULIA -L "$SCRIPT_DIR/startup/init.jl" "$SCRIPT_DIR/{{MODULE_NAME}}/main.jl"

recipes/macos/main.sh

@@ -0,0 +1,37 @@
+# This file should contain site-specific commands to be executed on Julia startup;
+# Users may store their own personal commands in `~/.julia/config/startup.jl`.
+
+if haskey(ENV, "USER_DATA")
+    println("Using USER_DATA environment variable to run in custom location")
+    cache_dir = joinpath(ENV["USER_DATA"], "depot")
+elseif !haskey(ENV, "APP_SANDBOX_CONTAINER_ID")
+    println("Running outside SandBox environment")
+    cache_dir = joinpath(homedir(), ".cache", "{{APP_NAME}}")
+    ENV["USER_DATA"] = joinpath(homedir(), ".config", "{{APP_NAME}}")
+else
+    println("Running in a SandBox environment")
+    cache_dir = joinpath(homedir(), "Library", "Caches", "depot")
+    ENV["USER_DATA"] = joinpath(homedir(), "Library", "Application Support", "Local")
+end
+
+libdir = dirname(dirname(dirname(@__DIR__)))
+
+Base.ACTIVE_PROJECT[] = joinpath(libdir, "{{MODULE_NAME}}")
+
+empty!(LOAD_PATH)
+push!(LOAD_PATH, joinpath(libdir, "packages"), "@stdlib", "@")
+
+# Modify DEPOT_PATH (equivalent to JULIA_DEPOT_PATH)
+empty!(DEPOT_PATH)
+push!(DEPOT_PATH, cache_dir, libdir, joinpath(libdir, "julia/share/julia"))
+
+@info "Active project is $(Base.ACTIVE_PROJECT[])"
+@info "LOAD_PATH = $LOAD_PATH"
+@info "DEPOT_PATH = $DEPOT_PATH"
+@info "USER_DATA = $(ENV["USER_DATA"])"
+
+
+function _precompile()
+    popfirst!(DEPOT_PATH)
+    @eval using {{MODULE_NAME}}
+end

recipes/macos/precompile.sh

@@ -1,3 +1,5 @@
+mkpath(ENV["USER_DATA"])
+
 LOGFILE_PATH = joinpath(ENV["USER_DATA"], "session.log")
 rm(LOGFILE_PATH, force=true)
 logfile = open(LOGFILE_PATH, "w")

recipes/macos/startup.jl

@@ -3,7 +3,6 @@ using Xorriso_jll: xorriso
 using rcodesign_jll: rcodesign
 
 
-
 function generate_self_signing_pfx(source, destination; password = "PASSWORD")
 
     run(`$(rcodesign()) generate-self-signed-certificate --person-name="AppBundler" --p12-file="$destination" --p12-password="$password"`)
@@ -13,7 +12,7 @@ end
 # MACOS_PFX_PASSWORD = ...
 # if unset a self signing certificate could be used instead
 # placing it at the meta folder as macos.pfx seems like a good option
-function build_app(platform::MacOS, source, destination; compress::Bool = isext(destination, ".dmg"), compression =:lzma, debug = true, precompile = true)
+function build_app(platform::MacOS, source, destination; compress::Bool = isext(destination, ".dmg"), compression =:lzma, debug = true, precompile = true, incremental = true)
 
     if precompile && (!Sys.isapple() || (Sys.ARCH == "x86_64" && arch(platform) != Sys.ARCH))
         error("Precompilation can only be done on MacOS as currently Julia does not support cross compilation. Set `precompile=false` to make a bundle without precompilation.")
@@ -37,15 +36,26 @@ function build_app(platform::MacOS, source, destination; compress::Bool = isext(
 
         if precompile
             @info "Precompiling"
-            precompile_script = "$app_stage/Contents/MacOS/precompile"
-            run(`$precompile_script`)
+
+            if !incremental
+                rm("$app_stage/Contents/Libraries/julia/share/julia/compiled", recursive=true)
+            end
+
+            julia = "$app_stage/Contents/Libraries/julia/bin/julia"
+            startup = "$app_stage/Contents/Libraries/julia/etc/julia/startup.jl"
+            
+            # Run the command with the modified environment
+            # withenv("JULIA_DEBUG" => "loading") do
+            run(`$julia --eval '_precompile()'`)
+            # end
+            
         else
             @info "Precompilation disabled. Precompilation will happen on the desitination system at first launch."
         end
 
         # I could write tests and check them with thoose ones
         run(`find $app_stage -name "._*" -delete`)
-        rm("$app_stage/Contents/MacOS/precompile")
+        #rm("$app_stage/Contents/MacOS/precompile")
     end
 
     password = get(ENV, "MACOS_PFX_PASSWORD", "")
@@ -57,7 +67,15 @@ function build_app(platform::MacOS, source, destination; compress::Bool = isext(
         generate_self_signing_pfx(source, pfx_path; password = "")
     end
 
-    run(`$(rcodesign()) sign --shallow --p12-file "$pfx_path" --p12-password "$password" --entitlements-xml-path "$app_stage/Contents/Resources/Entitlements.plist" "$app_stage"`)
+    entitlements_path = joinpath(source, "meta/macos/Entitlements.plist")
+    if isfile(entitlements_path)
+        @info "Using entitlements $entitlements_path"
+    else
+        @info "No override found at $entitlements_path; using default override"
+        entitlements_path = joinpath(dirname(@__DIR__), "recipes/macos/Entitlements.plist")
+    end
+
+    run(`$(rcodesign()) sign --shallow --p12-file "$pfx_path" --p12-password "$password" --entitlements-xml-path "$entitlements_path" "$app_stage"`)
 
     if compress
         rm(joinpath(dirname(app_stage), "Applications"); force=true)
@@ -72,5 +90,3 @@ function build_app(platform::MacOS, source, destination; compress::Bool = isext(
 
     return
 end
-
-

recipes/startup/init.jl

@@ -6,6 +6,7 @@ struct Rule
     dest::String
     template::Bool
     executable::Bool
+    override::Bool
 end
 
 isvalid(rule::Rule, default::String, override::String) =  ispath(joinpath(default, rule.origin)) || ispath(joinpath(override, rule.origin))
@@ -19,7 +20,7 @@ end
 Bundle(default::String, override::String) = Bundle(default, override, Rule[])
 
 add_rule!(bundle::Bundle, rule::Rule) = push!(bundle.rules, rule)
-add_rule!(bundle::Bundle, origin, dest; template=false, executable=false) = add_rule!(bundle, Rule(origin, dest, template, executable))
+add_rule!(bundle::Bundle, origin, dest; template=false, executable=false, override=false) = add_rule!(bundle, Rule(origin, dest, template, executable, override))
 
 function issubpath(path::String, subpath::String)
 
@@ -138,6 +139,8 @@ function get_bundle_parameters(project_toml)
 
     parameters = Dict{String, Any}()
 
+    parameters["MODULE_NAME"] = get(toml_dict, "name", "Main")
+
     app_name = haskey(toml_dict, "APP_NAME") ? toml_dict["APP_NAME"] : haskey(toml_dict, "name") ? toml_dict["name"] : basename(dirname(project_toml))
     parameters["APP_NAME"] = lowercase(join(split(app_name, " "), "-"))
     #parameters["APP_DIR_NAME"] = haskey(toml_dict, "name") ? toml_dict["name"] : basename(dirname(project_toml))

src/builder.jl

@@ -224,6 +224,28 @@ function copy_app(source, destination)
         cp(joinpath(source, i), joinpath(destination, i))
     end
 
+    # Creating a module if it does not exists
+
+    toml_dict = TOML.parsefile(joinpath(source, "Project.toml"))
+    module_name = get(toml_dict, "name", dirname(source))
+
+    path = joinpath(destination, "src/$module_name.jl")
+
+    if !isfile(path)
+
+        mkpath(joinpath(destination, "src"))
+
+        dependencies = toml_dict["deps"]
+        deps = join(["using $i" for i in keys(dependencies)], "\n")
+
+        write(path, """
+        module $module_name
+        $deps
+        end
+        """)
+
+    end
+
     return
 end
 

src/bundler.jl

@@ -1,13 +1,10 @@
-# function get_macos_launcher_path(arch)
-#     return AppBundlerUtils_jll.macos_launcher_path
-# end
-
 function bundle_app(platform::MacOS, source, destination; with_splash_screen = nothing)
 
     rm(destination, recursive=true, force=true)
 
     parameters = get_bundle_parameters("$source/Project.toml")
     app_name = parameters["APP_NAME"]
+    module_name = parameters["MODULE_NAME"]
 
     if isnothing(with_splash_screen) 
         with_splash_screen = parse(Bool, parameters["WITH_SPLASH_SCREEN"]) # When not set take a value 
@@ -24,32 +21,25 @@ function bundle_app(platform::MacOS, source, destination; with_splash_screen = n
     add_rule!(bundle, "macos/Resources", "Resources")
     add_rule!(bundle, "icon.icns", "Resources/icon.icns")
 
-    add_rule!(bundle, "precompile.jl", "Libraries/startup/precompile.jl")
     add_rule!(bundle, "startup", "Libraries/startup")
 
     add_rule!(bundle, "macos/main.sh", "Libraries/main", template=true, executable=true)
-    add_rule!(bundle, "macos/precompile.sh", "MacOS/precompile", template=true, executable=true)
     add_rule!(bundle, "macos/Info.plist", "Info.plist", template=true)
 
-    add_rule!(bundle, "macos/launcher.c", "Resources/launcher.c")
-    add_rule!(bundle, "macos/Entitlements.plist", "Resources/Entitlements.plist")
-    add_rule!(bundle, "macos/dmg_settings.py", "Resources/dmg_settings.py")
-
+    mkpath("$app_dir/Libraries")
+    copy_app(source, "$app_dir/Libraries/$module_name")
+    retrieve_julia(platform, "$app_dir/Libraries/julia")
+    
+    add_rule!(bundle, "macos/startup.jl", "$app_dir/Libraries/julia/etc/julia/startup.jl", template=true, override=true)
+    
     build(bundle, app_dir, parameters)
 
-    copy_app(source, "$app_dir/Libraries/$app_name")
-    retrieve_julia(platform, "$app_dir/Libraries/julia")
     retrieve_packages(source, "$app_dir/Libraries/packages"; with_splash_screen)
     retrieve_artifacts(platform, "$app_dir/Libraries/packages", "$app_dir/Libraries/artifacts")
 
-    
+    mkdir(joinpath(destination, "Contents/MacOS"))
     retrieve_macos_launcher(platform, joinpath(destination, "Contents/MacOS/$app_name"))
 
-    # arch = "arm64"
-    # launcher_path = get_macos_launcher_path(arch)
-    # cp(launcher_path, joinpath(destination, "Contents/MacOS/$app_name"); force=true)
-    # chmod(joinpath(destination, "Contents/MacOS/$app_name"), 0o755)
-
     return
 end