use invokelatest to use reflection functions in the latest world (#1101)

Author: KristofferC

README.md

@@ -19,9 +19,6 @@
 </p>
 </h2>
 
-> [!WARNING]  
-> Franklin is depending on Julia internals concerning the world age. These internals changed in Julia 1.12, such that Franklin.jl currently only works up to version Julia 1.11.
-
 Franklin is a simple **static site generator** (SSG) oriented towards technical blogging (code, maths, ...), flexibility and extensibility.
 The base syntax is plain markdown with a few extensions such as the ability to define and use LaTeX-like commands in or outside of maths environments and the possibility to evaluate code blocks on the fly.
 

src/Franklin.jl

@@ -93,7 +93,7 @@ const FD_ENV = LittleDict(
 
 utils_name()   = "Utils_$(FD_ENV[:UTILS_COUNTER]::Int)"
 utils_symb()   = Symbol(utils_name())
-utils_module() = getproperty(Main, utils_symb())
+utils_module() = @invokelatest getproperty(Main, utils_symb())
 utils_hash()   = nothing
 
 # HACK avoid stackoverflow for pagevar cycle (see juliacomputing issue #891)

src/converter/html/blocks.jl

@@ -179,7 +179,7 @@ function process_html_for(hs::AS, qblocks::Vector{AbstractBlock},
             "Please make sure it's defined."))
     end
     if iname ∈ UTILS_NAMES # can only happen if Utils is defined.
-        iter = getfield(utils_module(), Symbol(iname))
+        iter = @invokelatest getglobal(utils_module(), Symbol(iname))
     else
         iter = locvar(iname)
     end

src/converter/html/functions.jl

@@ -8,14 +8,14 @@ function convert_html_fblock(β::HFun)::String
     fun = Symbol("hfun_" * lowercase(β.fname))
     ex  = isempty(β.params) ? :($fun()) : :($fun($β.params))
     # see if a hfun was defined in utils
-    if isdefined(Main, utils_symb()) && isdefined(utils_module(), fun)
+    if @invokelatest(isdefined(Main, utils_symb())) && @invokelatest(isdefined(utils_module(), fun))
         # skip eval if the page is delayed
         isdelayed() && return ""
         res = Core.eval(utils_module(), ex)
         return string(res)
     end
     # see if a hfun was defined internally
-    isdefined(Franklin, fun) && return eval(ex)
+    @invokelatest(isdefined(Franklin, fun)) && return eval(ex)
     # if zero parameters, see if can fill (case: {{vname}})
     if isempty(β.params) &&
         (!isnothing(locvar(β.fname)) || β.fname in UTILS_NAMES)
@@ -53,7 +53,7 @@ function hfun_fill(params::Vector{String})::String
     vname = params[1]
     if length(params) == 1
         if vname in UTILS_NAMES
-            repl = string(getfield(utils_module(), Symbol(vname)))
+            repl = string(@invokelatest(getglobal(utils_module(), Symbol(vname))))
         else
             tmp_repl = locvar(vname)
             if isnothing(tmp_repl)

src/converter/latex/latex.jl

@@ -34,7 +34,7 @@ function resolve_lxobj(lxo::LxObj, lxdefs::Vector{LxDef};
     # it will be `nothing` in math mode or when defined in utils
     if isnothing(lxd)
         # check if it's defined in Utils and act accordingly
-        if isdefined(Main, utils_symb()) && isdefined(utils_module(), fun)
+        if @invokelatest(isdefined(Main, utils_symb())) && @invokelatest(isdefined(utils_module(), fun))
             raw = Core.eval(utils_module(), :($fun($lxo, $lxdefs)))
             return reprocess(raw, lxdefs)
         else
@@ -49,7 +49,7 @@ function resolve_lxobj(lxo::LxObj, lxdefs::Vector{LxDef};
     # the output of lx_label is direct HTML.
     if (!env && isempty(lxd)) || (env && isempty(lxd.first) && isempty(lxd.second))
         name = getname(lxo)
-        isdefined(Franklin, fun) && return eval(:($fun($lxo, $lxdefs)))
+        @invokelatest(isdefined(Franklin, fun)) && return eval(:($fun($lxo, $lxdefs)))
         return ""
     end
 

src/converter/markdown/mddefs.jl

@@ -33,7 +33,7 @@ function process_mddefs(blocks::Vector{OCBlock}, isconfig::Bool,
         filter!(v -> v isa Symbol, vnames)
         for vname in vnames
             key    = String(vname)
-            value  = getproperty(mdl, vname)
+            value  = @invokelatest getglobal(mdl, vname)
             set_var!(curdict, key, value; isglobal=isconfig)
         end
     end

src/eval/codeblock.jl

@@ -128,9 +128,9 @@ function resolve_code_block(
         modname = modulename(locvar(:fd_rpath)::String)
         # >> check if relevant module exists, otherwise create one
         mod = ismodule(modname) ?
-                getfield(Main, Symbol(modname)) :
+                @invokelatest(getglobal(Main, Symbol(modname))) :
                 newmodule(modname)
-        
+
         # >> retrieve the code paths
         cp = form_codepaths(rpath)
         # >> write the code to file
@@ -172,7 +172,7 @@ function resolve_code_block(
                     chunk_ast = nothing
                 end
             end
-        
+
         # NOTE: shell, pkg, and help mode are currently fairly rudimentary
         # and should be considered experimental
 
@@ -239,7 +239,7 @@ function resolve_code_block(
     if any((repl, shell, help, pkg))
         s = repl ? :repl : shell ? :shell : help ? :help : :pkg
         return html_repl_code(repl_code_chunks, s)
-    
+
     elseif shortcut || locvar(:showall)::Bool
         return html_code(code, lang) *
                 reprocess("\\show{$rpath}", [GLOBAL_LXDEFS["\\show"]])

src/eval/module.jl

@@ -17,8 +17,8 @@ Checks whether a name is a defined module.
 """
 function ismodule(name::String)::Bool
     s = Symbol(name)
-    isdefined(Main, s) || return false
-    typeof(getfield(Main, s)) === Module
+    @invokelatest(isdefined(Main, s)) || return false
+    typeof(@invokelatest(getglobal(Main, s))) === Module
 end
 
 """

src/manager/file_utils.jl

@@ -81,7 +81,7 @@ function process_utils()::Nothing
     Base.include(utils_module(), utils)
 
     # keep track of utils names
-    ns = String.(names(utils_module(), all=true))
+    ns = String.(@invokelatest(names(utils_module(), all=true)))
     filter!(n -> n[1] != '#' && n ∉ ("eval", "include", "Utils"), ns)
     empty!(UTILS_NAMES)
     append!(UTILS_NAMES, ns)

src/parser/latex/blocks.jl

@@ -162,11 +162,11 @@ function get_lxdef_ref(lxname::SubString, lxdefs::Vector{LxDef},
     #  3. throw an error
     if isempty(ks)
         # check if defined in utils
-        if isdefined(Main, utils_symb())
+        if @invokelatest isdefined(Main, utils_symb())
             # env def 'env_***'
-            flag = isenv && isdefined(utils_module(), Symbol("env_$(lxname)"))
+            flag = isenv && @invokelatest isdefined(utils_module(), Symbol("env_$(lxname)"))
             # com def 'lx_***'
-            flag |= isdefined(utils_module(), Symbol("lx_$(lxname[2:end])"))
+            flag |= @invokelatest isdefined(utils_module(), Symbol("lx_$(lxname[2:end])"))
             flag && return (Ref(nothing), true)
         end
         # if we're here, and in math mode, let the math engine deal with it