RSS feed;""", fc)
14 | end
15 |
--------------------------------------------------------------------------------
/test/templating/fill.jl:
--------------------------------------------------------------------------------
1 | fs2()
2 | write(joinpath("_layout", "head.html"), "")
3 | write(joinpath("_layout", "foot.html"), "")
4 | write(joinpath("_layout", "page_foot.html"), "")
5 | write("config.md", "")
6 |
7 | @testset "fill2" begin
8 | write("index.md", """
9 | @def var = 5
10 | {{fill var page2}}
11 | """)
12 | write("page2.md", """
13 | @def var = 7
14 | {{fill var index}}
15 | """)
16 | F.serve(single=true, clear=true, cleanup=false)
17 | index = joinpath("__site", "index.html")
18 | pg2 = joinpath("__site", "page2", "index.html")
19 | @test isapproxstr(read(index, String), """
20 | 7
21 | """)
22 | @test isapproxstr(read(pg2, String), """
23 | 5
24 | """)
25 | end
26 |
--------------------------------------------------------------------------------
/test/manager/page_vars_html.jl:
--------------------------------------------------------------------------------
1 | fs2()
2 |
3 | @testset "Scope (#412)" begin
4 | write(joinpath(td, "config.md"), """
5 | @def title = "config"
6 | """)
7 | write(joinpath(td, "page.md"), """
8 | @def title = "page"
9 | """)
10 | write(joinpath(td, "index.html"), """
11 | {{insert head.html}}
12 | """)
13 | mkpath(joinpath(td, "_layout"))
14 | mkpath(joinpath(td, "_css"))
15 | write(joinpath(td, "_layout", "head.html"), "{{fill title}}
") 16 | write(joinpath(td, "_layout", "page_foot.html"), "") 17 | write(joinpath(td, "_layout", "foot.html"), "") 18 | serve(single=true) 19 | 20 | @test startswith(read(joinpath("__site", "index.html"), String), 21 | "config
") 22 | @test startswith(read(joinpath("__site", "page", "index.html"), String), 23 | "page
") 24 | end 25 | -------------------------------------------------------------------------------- /test/integration/literate_extras.jl: -------------------------------------------------------------------------------- 1 | fs2() 2 | 3 | @testset "(no)show" begin 4 | lit = raw""" 5 | # A 6 | 7 | 1 + 1 8 | 9 | # B 10 | 11 | 2^2; 12 | 13 | # C 14 | 15 | println("hello") 16 | 17 | # done. 18 | """ 19 | lp = mkpath(joinpath(F.PATHS[:folder], "_literate")) 20 | write(joinpath(lp, "ex1.jl"), lit) 21 | 22 | s = raw""" 23 | @def showall = true 24 | INI 25 | \literate{/_literate/ex1} 26 | """ 27 | 28 | h = s |> fd2html_td 29 | @test isapproxstr(h, """ 30 |INI A
31 |1 + 12B
33 |2^2;C
35 |println("hello")hello
36 | done.
38 | """) 39 | end 40 | -------------------------------------------------------------------------------- /test/templating/for.jl: -------------------------------------------------------------------------------- 1 | @testset "for-basic" begin 2 | s = """ 3 | @def v1 = [1, 2, 3] 4 | ~~~ 5 | {{for v in v1}} 6 | v: {{fill v}} 7 | {{end}} 8 | ~~~ 9 | """ |> fd2html_td 10 | @test isapproxstr(s, """ 11 | v: 1 12 | v: 2 13 | v: 3 14 | """) 15 | 16 | s = """ 17 | @def v1 = [[1,2], [3,4]] 18 | ~~~ 19 | {{for (a,b) in v1}} 20 | a: {{fill a}} b: {{fill b}} 21 | {{end}} 22 | ~~~ 23 | """ |> fd2html_td 24 | @test isapproxstr(s, """ 25 | a: 1 b: 2 26 | a: 3 b: 4 27 | """) 28 | 29 | s = """ 30 | @def v_1 = ("a"=>1, "b"=>2, "c"=>3) 31 | ~~~ 32 | {{for (a,b) in v_1}} 33 | a: {{fill a}} b: {{fill b}} 34 | {{end}} 35 | ~~~ 36 | """ |> fd2html_td 37 | @test isapproxstr(s, """ 38 | a: a b: 1 39 | a: b b: 2 40 | a: c b: 3 41 | """) 42 | end 43 | -------------------------------------------------------------------------------- /test/_dummies/151.md: -------------------------------------------------------------------------------- 1 | @def title = "Julia" 2 | @def hascode = true 3 | 4 | 5 | ```julia 6 | add OhMyREPL#master 7 | ``` 8 | 9 | AAA 10 | 11 | ~~~ 12 |"""
13 | bar(x[, y])
14 |
15 | BBB
16 |
17 | # Examples
18 | ```jldoctest
19 | D
20 | ```
21 | """
22 | function bar(x, y)
23 | ...
24 | end
25 | """
33 | matdiag(diag, nr, nc; <keyword arguments>)
34 |
35 | Create Matrix with number `vdiag` on the super- or subdiagonals and `vndiag`
36 | in the rest.
37 |
38 | # Arguments
39 | - `diag::Number`: `Number` to write into created super- or subdiagonal
40 |
41 | # Examples
42 | ```jldoctest
43 | julia> matdiag(true, 5, 5, sr=2, ec=3)
44 | ```
45 | """
46 | function
47 | matdiag(diag::Number, nr::Integer, nc::Integer;)
48 | ...
49 | end
50 | ABC 
ABC
// Image matching '/assets/index/unknown.png' not found. //
28 | """) 29 | 30 | s = raw""" 31 | @def fd_rpath = "blog/kaggle/index.md" 32 | ABC 33 | \fig{./foo.png} 34 | """ |> fd2html_td 35 | @test isapproxstr(s, """ 36 |ABC 
ABC
// Image matching '/assets/blog/kaggle/baz.png' not found. //
46 | """) 47 | end 48 | -------------------------------------------------------------------------------- /src/eval/module.jl: -------------------------------------------------------------------------------- 1 | #= 2 | Functionalities to generate a sandbox module. 3 | =# 4 | 5 | """ 6 | $SIGNATURES 7 | 8 | Return a sandbox module name corresponding to the page at `fpath`, effectively 9 | `FD_SANDBOX_*` where `*` is a hash of the path. 10 | """ 11 | modulename(fpath::AS) = "FD_SANDBOX_$(hash(fpath))" 12 | 13 | """ 14 | $SIGNATURES 15 | 16 | Checks whether a name is a defined module. 17 | """ 18 | function ismodule(name::String)::Bool 19 | s = Symbol(name) 20 | isdefined(Main, s) || return false 21 | typeof(getfield(Main, s)) === Module 22 | end 23 | 24 | """ 25 | $SIGNATURES 26 | 27 | Creates a new module with a given name, if the module exists, it is wiped. 28 | Discards the warning message that a module is replaced which may otherwise 29 | happen. Return a handle pointing to the module. 30 | """ 31 | function newmodule(name::String)::Module 32 | mod = nothing 33 | junk = tempname() 34 | open(junk, "w") do outf 35 | # discard the "WARNING: redefining module X" 36 | redirect_stderr(outf) do 37 | mod = Core.eval(Main, Meta.parse(""" 38 | module $name 39 | import Franklin 40 | import Franklin: @OUTPUT, fdplotly, locvar, 41 | pagevar, globvar, fd2html, get_url 42 | if isdefined(Main, :Utils) && typeof(Main.Utils) == Module 43 | import ..Utils 44 | end 45 | end 46 | """)) 47 | end 48 | end 49 | return mod 50 | end 51 | -------------------------------------------------------------------------------- /src/utils/errors.jl: -------------------------------------------------------------------------------- 1 | abstract type FranklinException <: Exception end 2 | 3 | # 4 | # Parsing related 5 | # 6 | 7 | """An OCBlock was not parsed properly (e.g. the closing token was not found).""" 8 | struct OCBlockError <: FranklinException 9 | m::String 10 | c::String 11 | end 12 | 13 | function Base.showerror(io::IO, be::OCBlockError) 14 | println(io, be.m) 15 | print(io, be.c) 16 | end 17 | 18 | """A `\\newcommand` was not parsed properly.""" 19 | struct LxDefError <: FranklinException 20 | m::String 21 | end 22 | 23 | """A latex command was found but could not be processed properly.""" 24 | struct LxComError <: FranklinException 25 | m::String 26 | end 27 | 28 | """A math block name failed to parse.""" 29 | struct MathBlockError <: FranklinException 30 | m::String 31 | end 32 | 33 | """A Page Variable wasn't set properly.""" 34 | struct PageVariableError <: FranklinException 35 | m::String 36 | end 37 | 38 | # 39 | # HTML related 40 | # 41 | 42 | """An HTML block (e.g. [`HCond`](@see)) was erroneous.""" 43 | struct HTMLBlockError <: FranklinException 44 | m::String 45 | end 46 | 47 | """An HTML function (e.g. `{{fill ...}}`) failed.""" 48 | struct HTMLFunctionError <: FranklinException 49 | m::String 50 | end 51 | 52 | # 53 | # ASSET PATH error 54 | # 55 | 56 | """A relative path was erroneous.""" 57 | struct RelativePathError <: FranklinException 58 | m::String 59 | end 60 | 61 | """A file was not found.""" 62 | struct FileNotFoundError <: FranklinException 63 | m::String 64 | end 65 | 66 | # 67 | # CODE 68 | # 69 | 70 | """A relative path was erroneous for Literate.""" 71 | struct LiterateRelativePathError <: FranklinException 72 | m::String 73 | end 74 | -------------------------------------------------------------------------------- /test/parser/footnotes+links.jl: -------------------------------------------------------------------------------- 1 | @testset "footnotes" begin 2 | set_curpath("index.md") 3 | st = """ 4 | A[^1] B[^blah] C 5 | """ 6 | @test isapproxstr(st |> seval, """ 7 | """) 10 | 11 | st = """ 12 | A[^1] B[^blah] 13 | C 14 | [^1]: first footnote 15 | [^blah]: second footnote 16 | """ 17 | @test isapproxstr(st |> seval, """ 18 |19 | A 20 | [1] 21 | B[2] 22 | C 23 |
| [1] | 26 |first footnote | 27 |
| [2] | 32 |second footnote | 33 |
this has[^1]
50 | [^1]: def
51 | A
B
44 | CHello
a=5
61 | x=3Ahello B
") 7 | s = raw""" 8 | \newcommand{\eqa}[1]{\begin{eqnarray}#1\end{eqnarray}} 9 | A\eqa{B}C 10 | \eqa{ 11 | D 12 | }E 13 | """ |> fd2html_td 14 | @test isapproxstr(s, raw""" 15 |16 | A\[\begin{array}{c} B\end{array}\]C 17 | \[\begin{array}{c} D\end{array}\]E 18 |
""") 19 | 20 | s = raw""" 21 | \newcommand{\eqa}[1]{\begin{eqnarray}#1\end{eqnarray}} 22 | \eqa{A\\ 23 | D 24 | }E 25 | """ |> fd2html_td 26 | @test isapproxstr(s, raw""" 27 | \[\begin{array}{c} A\\ 28 | D\end{array}\]E 29 | """) 30 | s = raw""" 31 | @def indented_code = false 32 | \newcommand{\eqa}[1]{\begin{eqnarray}#1\end{eqnarray}} 33 | \eqa{A\\ 34 | D}E""" |> fd2html_td 35 | @test isapproxstr(s, raw""" 36 | \[\begin{array}{c} A\\ 37 | D\end{array}\]E 38 | """) 39 | end 40 | 41 | @testset "latex-wspmath" begin 42 | s = raw""" 43 | \newcommand{\esp}{\quad\!\!} 44 | $$A\esp=B$$ 45 | """ |> fd2html_td 46 | @test isapproxstr(s, raw"\[A\quad\!\!=B\]") 47 | end 48 | 49 | @testset "code-wspace" begin 50 | s = raw""" 51 | A 52 | ``` 53 | C 54 | B 55 | E 56 | D 57 | ``` 58 | """ |> fd2html_td 59 | @test isapproxstr(s, """A
C\n B\n E\nDBlah
67 | ```
68 | End
69 | """ |> fd2html_td
70 | @test isapproxstr(s, """
71 | 72 | Blah
<div class="foo">Blah</div>THE AUTHOR
THE AUTHOR
") 45 | s = raw"\style{font-weight:bold;}{ {{author}} }" |> fd2html 46 | @test isapproxstr(s, """ 47 | THE AUTHOR 48 | """) 49 | s = raw"@@bold {{bar 4}} @@" |> fd2html 50 | @test isapproxstr(s, """ 51 |2.0
52 | """)
53 | end
54 |
55 | @testset "iss#502" begin
56 | s = """
57 | @def upcoming_release_short = "1.5"
58 | @def upcoming_release_date = "May 28, 2020"
59 |
60 | Blah v{{upcoming_release_short}} and {{upcoming_release_date}}.
61 | """ |> fd2html
62 | @test isapproxstr(s, "Blah v1.5 and May 28, 2020.
") 63 | end 64 | -------------------------------------------------------------------------------- /test/utils/html.jl: -------------------------------------------------------------------------------- 1 | @testset "misc-html" begin 2 | fs1() 3 | λ = "blah/blah.ext" 4 | set_curpath("pages/cpB/blah.md") 5 | @test F.html_ahref(λ, 1) == "1" 6 | @test F.html_ahref(λ, "bb") == "bb" 7 | @test F.html_ahref_key("cc", "dd") == "dd" 8 | @test F.html_div("dn","ct") == "ct
"
9 | @test F.html_img("src", "alt") == "codecode// blah //
" 13 | 14 | fs2() 15 | λ = "blah/blah.ext" 16 | set_curpath("cpB/blah.md") 17 | @test F.html_ahref(λ, 1) == "1" 18 | @test F.html_ahref(λ, "bb") == "bb" 19 | @test F.html_ahref_key("cc", "dd") == "dd" 20 | 21 | fs1() 22 | end 23 | 24 | @testset "misc-html 2" begin 25 | h = "blah
"
26 | @test !F.is_html_escaped(h)
27 | @test F.html_code(h, "html") == """<div class="foo">blah</div>using Random
61 | a = randn()
62 | b = a + 5A
1A
"hello"a = 5
71 | b = 7a = 5
80 | b = 7a = 5
99 | b = 7Blah
") 28 | end 29 | 30 | @testset "Franklin" begin 31 | cd(td); mkpath("foo"); cd("foo"); write("config.md","") 32 | @test_throws ArgumentError serve(single=true) 33 | cd(td) 34 | end 35 | 36 | @testset "RSS" begin 37 | F.set_var!(F.GLOBAL_VARS, "website_descr", "") 38 | F.RSS_DICT["hello"] = F.RSSItem("","","","","","","",Date(1)) 39 | @test (@test_logs (:warn, """ 40 | I found RSS items but the RSS feed is not properly described: 41 | at least one of the following variables has not been defined in 42 | your config.md: `website_title`, `website_descr`, `website_url`. 43 | The feed will not be (re)generated.""") F.rss_generator()) === nothing 44 | end 45 | 46 | 47 | @testset "parser-lx" begin 48 | s = raw""" 49 | \newcommand{hello}{hello} 50 | """ 51 | @test_throws F.LxDefError (s |> fd2html) 52 | s = raw""" 53 | \foo 54 | """ 55 | @test_throws F.LxComError (s |> fd2html) 56 | s = raw""" 57 | \newcommand{\foo}[2]{hello #1 #2} 58 | \foo{a} {} 59 | """ 60 | @test_throws F.LxComError (s |> fd2html) 61 | end 62 | 63 | @testset "ocblocks" begin 64 | s = raw""" 65 | @@foo 66 | """ 67 | @test_throws F.OCBlockError (s |> fd2html) 68 | end 69 | 70 | @testset "tofrom" begin 71 | s = "jμΛΙα" 72 | @test F.from(s) == 1 73 | @test F.to(s) == lastindex(s) 74 | end 75 | 76 | 77 | @testset "{{toc}}" begin 78 | s = """ 79 | ~~~ 80 | {{toc 1 2}} 81 | ~~~ 82 | # Hello 83 | ## Goodbye 84 | """ |> fd2html_td 85 | @test isapproxstr(s, raw""" 86 | 87 |Hello
Goodbye
""") 88 | end 89 | 90 | 91 | @testset "franklin" begin 92 | fs1() 93 | gotd() 94 | write(joinpath(td, "config.md"), "foo") 95 | @test_throws ArgumentError serve(single=true) 96 | end 97 | -------------------------------------------------------------------------------- /src/eval/run.jl: -------------------------------------------------------------------------------- 1 | #= 2 | Functionalities to take a string corresponding to Julia code and evaluate 3 | that code in a given module while capturing stdout and redirecting it to 4 | a file. 5 | =# 6 | 7 | """ 8 | $SIGNATURES 9 | 10 | Consumes a string with Julia code, returns a vector of expression(s). 11 | 12 | Note: this function was adapted from the `parse_input` function from Weave.jl. 13 | """ 14 | function parse_code(code::AS) 15 | exs = Any[] # Expr, Symbol or Any Julia core value 16 | n = sizeof(code) 17 | pos = 1 18 | while pos ≤ n 19 | ex, pos = Meta.parse(code, pos) 20 | isnothing(ex) && continue 21 | push!(exs, ex) 22 | end 23 | exs 24 | end 25 | 26 | """ 27 | $SIGNATURES 28 | 29 | Run some code in a given module while redirecting stdout to a given path. 30 | Return the result of the evaluation or `nothing` if the code was empty or 31 | the evaluation failed. 32 | If the evaluation errors, the error is printed to output then a warning is 33 | shown. 34 | 35 | ## Arguments 36 | 37 | 1. `mod`: the module in which to evaluate the code, 38 | 1. `code`: string corresponding to the code, 39 | 1. `out_path`: path where stdout should be redirected 40 | 41 | ## Keywords 42 | 43 | * `warn_err=true`: whether to show a warning in the REPL if there was an error 44 | running the code. 45 | * `strip=false`: whether to strip the code, this may already have been done. 46 | """ 47 | function run_code(mod::Module, code::AS, out_path::AS; 48 | warn_err::Bool=true, strip_code::Bool=true) 49 | isempty(code) && return nothing 50 | strip_code && (code = strip(code)) 51 | exs = parse_code(strip(code)) 52 | ne = length(exs) 53 | res = nothing # to capture final result 54 | err = nothing 55 | ispath(out_path) || mkpath(dirname(out_path)) 56 | open(out_path, "w") do outf 57 | if !FD_ENV[:SILENT_MODE] 58 | rprint("→ evaluating code [...] ($(locvar("fd_rpath")))") 59 | end 60 | redirect_stdout(outf) do 61 | e = 1 62 | while e <= ne 63 | try 64 | res = Core.eval(mod, exs[e]) 65 | catch e 66 | io = IOBuffer() 67 | showerror(io, e) 68 | println(String(take!(io))) 69 | err = typeof(e) 70 | break 71 | end 72 | e += 1 73 | end 74 | end 75 | end 76 | # if there was an error, return nothing and possibly show warning 77 | if !isnothing(err) 78 | # TODO: add more informative message, maybe show type of error 79 | # + parent path 80 | FD_ENV[:SILENT_MODE] || print("\n") 81 | warn_err && @warn "There was an error of type $err running the code." 82 | res = nothing 83 | end 84 | # if last bit ends with `;` return nothing (no display) 85 | code[end] == ';' && return nothing 86 | # if last line is a Julia value return 87 | isa(exs[end], Expr) || return res 88 | # if last line of the code is a `show` 89 | if length(exs[end].args) > 1 && exs[end].args[1] == Symbol("@show") 90 | return nothing 91 | end 92 | # otherwise return the result of the last expression 93 | return res 94 | end 95 | -------------------------------------------------------------------------------- /test/manager/rss.jl: -------------------------------------------------------------------------------- 1 | @testset "RSSItem" begin 2 | rss = F.RSSItem( 3 | "title", "www.link.com", "description", "author@author.com", "category", 4 | "www.comments.com", "enclosure", Date(2012,12,12)) 5 | @test rss.title == "title" 6 | @test rss.link == "www.link.com" 7 | @test rss.description == "description" 8 | @test rss.author == "author@author.com" 9 | @test rss.category == "category" 10 | @test rss.comments == "www.comments.com" 11 | @test rss.enclosure == "enclosure" 12 | @test rss.pubDate == Date(2012,12,12) 13 | end 14 | 15 | @testset "RSSbasics" begin 16 | fs1() 17 | empty!(F.RSS_DICT) 18 | F.def_GLOBAL_VARS!() 19 | F.set_var!(F.GLOBAL_VARS, "website_title", "Website title") 20 | F.set_var!(F.GLOBAL_VARS, "website_descr", "Website descr") 21 | F.set_var!(F.GLOBAL_VARS, "website_url", "https://github.com/tlienart/Franklin.jl/") 22 | F.def_LOCAL_VARS!() 23 | set_curpath("hey/ho.md") 24 | F.set_var!(F.LOCAL_VARS, "rss_title", "title") 25 | F.set_var!(F.LOCAL_VARS, "rss", "A **description** done.") 26 | F.set_var!(F.LOCAL_VARS, "rss_author", "chuck@norris.com") 27 | 28 | item = F.add_rss_item() 29 | @test item.title == "title" 30 | @test item.description == "A description done.\n" 31 | @test item.author == "chuck@norris.com" 32 | # unchanged bc all three fallbacks lead to Data(1) 33 | @test item.pubDate == Date(1) 34 | 35 | F.set_var!(F.LOCAL_VARS, "rss_title", "") 36 | @test @test_logs (:warn, "Found an RSS description but no title for page /hey/ho.html.") F.add_rss_item().title == "" 37 | 38 | @test F.RSS_DICT["/hey/ho.html"].description == item.description 39 | 40 | # Generation 41 | F.PATHS[:folder] = td 42 | F.rss_generator() 43 | feed = joinpath(F.PATHS[:folder], "feed.xml") 44 | @test isfile(feed) 45 | fc = prod(readlines(feed, keep=true)) 46 | @test occursin("A
19 |B
20 | """) 21 | end 22 | 23 | @testset "Ordering-2" begin 24 | st = raw""" 25 | A 26 | \begin{eqnarray} 27 | 1 + 1 &=& 2 28 | \end{eqnarray} 29 | B 30 | """ 31 | steps = st |> explore_md_steps 32 | blocks, = steps[:ocblocks] 33 | @test length(blocks) == 1 34 | @test blocks[1].name == :MATH_EQA 35 | 36 | @test isapproxstr(st |> seval, raw""" 37 |A 38 | \[\begin{array}{c} 39 | 1 + 1 &=& 2 40 | \end{array}\] 41 | B
""") 42 | end 43 | 44 | @testset "Ordering-3" begin 45 | st = raw""" 46 | A 47 | \begin{eqnarray} 48 | 1 + 1 &=& 2 49 | \end{eqnarray} 50 | B 51 | 58 | C 59 | """ 60 | steps = st |> explore_md_steps 61 | blocks, = steps[:ocblocks] 62 | @test length(blocks) == 2 63 | @test blocks[1].name == :MATH_EQA 64 | @test blocks[2].name == :COMMENT 65 | 66 | @test isapproxstr(st |> seval, raw""" 67 |A 68 | \[\begin{array}{c} 69 | 1 + 1 &=& 2 70 | \end{array}\] 71 | B
72 |C
""") 73 | end 74 | 75 | @testset "Ordering-4" begin 76 | st = raw""" 77 | \newcommand{\eqa}[1]{\begin{eqnarray}#1\end{eqnarray}} 78 | A 79 | \eqa{ 80 | B 81 | } 82 | C 83 | """ 84 | steps = st |> explore_md_steps 85 | blocks, = steps[:ocblocks] 86 | 87 | @test length(blocks) == 3 88 | @test all(getproperty.(blocks, :name) .== :LXB) 89 | 90 | @test isapproxstr(st |> seval, raw""" 91 |A 92 | \[\begin{array}{c} 93 | B 94 | \end{array}\] 95 | C
""") 96 | end 97 | 98 | @testset "Ordering-5" begin 99 | st = raw""" 100 | A [❗️_ongoing_ ] C 101 | """ 102 | @test isapproxstr(st |> seval, raw""" 103 |A [❗️ongoing ] C
104 | """) 105 | st = raw""" 106 | 0 107 | * A 108 | * B [❗️_ongoing_ ] 112 | C 113 | """ 114 | @test isapproxstr(st |> seval, raw""" 115 |0
116 |-
117 |
A
118 |-
119 |
B [❗️ongoing ]
120 |
122 |
C
124 | """) 125 | end 126 | -------------------------------------------------------------------------------- /src/utils/paths.jl: -------------------------------------------------------------------------------- 1 | """ 2 | FOLDER_PATH 3 | 4 | Container to keep track of where Franklin is being run. 5 | """ 6 | const FOLDER_PATH = Ref{String}() 7 | 8 | 9 | """ 10 | IGNORE_FILES 11 | 12 | Collection of file names that will be ignored at compile time. 13 | """ 14 | const IGNORE_FILES = [".DS_Store", ".gitignore", "LICENSE.md", "README.md", 15 | "franklin", "franklin.pub", "node_modules/"] 16 | 17 | 18 | """ 19 | INFRA_EXT 20 | 21 | Collection of file extensions considered as potential infrastructure files. 22 | """ 23 | const INFRA_FILES = [".html", ".css"] 24 | 25 | 26 | """ 27 | PATHS 28 | 29 | Dictionary for the paths of the input folders and the output folders. The simpler case only 30 | requires the main input folder to be defined i.e. `PATHS[:src]` and infers the others via the 31 | `set_paths!()` function. 32 | """ 33 | const PATHS = LittleDict{Symbol,String}() 34 | 35 | 36 | """ 37 | $(SIGNATURES) 38 | 39 | This assigns all the paths where files will be read and written with root the `FOLDER_PATH` 40 | which is assigned at runtime. 41 | """ 42 | function set_paths!()::LittleDict{Symbol,String} 43 | @assert isassigned(FOLDER_PATH) "FOLDER_PATH undefined" 44 | @assert isdir(FOLDER_PATH[]) "FOLDER_PATH is not a valid path" 45 | 46 | # NOTE it is recommended not to change the names of those paths. 47 | # Particularly for the output dir. If you do, check for example that 48 | # functions such as Franklin.publish point to the right dirs/files. 49 | 50 | if FD_ENV[:STRUCTURE] < v"0.2" 51 | PATHS[:folder] = normpath(FOLDER_PATH[]) 52 | PATHS[:src] = joinpath(PATHS[:folder], "src") 53 | PATHS[:src_pages] = joinpath(PATHS[:src], "pages") 54 | PATHS[:src_css] = joinpath(PATHS[:src], "_css") 55 | PATHS[:src_html] = joinpath(PATHS[:src], "_html_parts") 56 | PATHS[:pub] = joinpath(PATHS[:folder], "pub") 57 | PATHS[:css] = joinpath(PATHS[:folder], "css") 58 | PATHS[:libs] = joinpath(PATHS[:folder], "libs") 59 | PATHS[:assets] = joinpath(PATHS[:folder], "assets") 60 | PATHS[:literate] = joinpath(PATHS[:folder], "scripts") 61 | PATHS[:tag] = joinpath(PATHS[:pub], "tag") 62 | else 63 | PATHS[:folder] = normpath(FOLDER_PATH[]) 64 | PATHS[:site] = joinpath(PATHS[:folder], "__site") # mandatory 65 | PATHS[:assets] = joinpath(PATHS[:folder], "_assets") # mandatory 66 | PATHS[:css] = joinpath(PATHS[:folder], "_css") # mandatory 67 | PATHS[:layout] = joinpath(PATHS[:folder], "_layout") # mandatory 68 | PATHS[:libs] = joinpath(PATHS[:folder], "_libs") # mandatory 69 | PATHS[:literate] = joinpath(PATHS[:folder], "_literate") # optional 70 | PATHS[:tag] = joinpath(PATHS[:site], "tag") 71 | end 72 | 73 | return PATHS 74 | end 75 | 76 | """ 77 | path(s) 78 | 79 | Return the paths corresponding to `s` e.g. `path(:folder)`. 80 | """ 81 | path(s) = PATHS[Symbol(s)] 82 | 83 | 84 | """ 85 | Pointer to the `/output/` folder associated with an eval block (see also 86 | [`@OUTPUT`](@ref)). 87 | """ 88 | const OUT_PATH = Ref("") 89 | 90 | """ 91 | This macro points to the `/output/` folder associated with an eval block. 92 | So for instance, if an eval block generates a plot, you could save the plot 93 | with something like `savefig(joinpath(@OUTPUT, "ex1.png"))`. 94 | """ 95 | macro OUTPUT() 96 | return OUT_PATH[] 97 | end 98 | -------------------------------------------------------------------------------- /test/utils/folder_structure.jl: -------------------------------------------------------------------------------- 1 | @testset "set_paths!" begin 2 | root = F.FOLDER_PATH[] = mktempdir() 3 | empty!(F.PATHS); F.FD_ENV[:STRUCTURE] = v"0.1"; F.set_paths!() 4 | @test Set(keys(F.PATHS)) == Set([:folder, :src, :src_pages, :src_css, :src_html, :pub, :css, :libs, :assets, :literate, :tag]) 5 | @test F.PATHS[:folder] == root 6 | @test F.PATHS[:src_pages] == joinpath(F.PATHS[:src], "pages") 7 | 8 | # ================================================ 9 | empty!(F.PATHS); F.FD_ENV[:STRUCTURE] = v"0.2"; F.set_paths!() 10 | @test Set(keys(F.PATHS)) == Set([:folder, :assets, :css, :layout, :libs, :literate, :site, :tag]) 11 | @test F.PATHS[:folder] == root 12 | @test F.PATHS[:site] == joinpath(root, "__site") 13 | @test F.PATHS[:assets] == joinpath(root, "_assets") 14 | @test F.PATHS[:css] == joinpath(root, "_css") 15 | @test F.PATHS[:layout] == joinpath(root, "_layout") 16 | @test F.PATHS[:libs] == joinpath(root, "_libs") 17 | @test F.PATHS[:literate] == joinpath(root, "_literate") 18 | @test F.PATHS[:tag] == joinpath(root, "__site", "tag") 19 | 20 | # ================================================ 21 | # reset the structure to legacy for further tests 22 | empty!(F.PATHS); F.FD_ENV[:STRUCTURE] = v"0.1"; F.set_paths!() 23 | end 24 | 25 | @testset "outp_path" begin 26 | empty!(F.PATHS); F.FD_ENV[:STRUCTURE] = v"0.1"; F.set_paths!() 27 | # MD_PAGES 28 | out = F.form_output_path(F.PATHS[:src], "index.md", :md) 29 | @test out == joinpath(F.PATHS[:folder], "index.html") 30 | 31 | out = F.form_output_path(F.PATHS[:src_pages], "foo.md", :md) 32 | @test out == joinpath(F.PATHS[:folder], "pub", "foo.html") 33 | 34 | # CSS 35 | out = F.form_output_path(F.PATHS[:src_css], "foo.css", :infra) 36 | @test out == joinpath(F.PATHS[:css], "foo.css") 37 | 38 | # (note: assets, libs are not tracked and not considered in v1) 39 | 40 | # ================================================ 41 | 42 | empty!(F.PATHS); F.FD_ENV[:STRUCTURE] = v"0.2"; F.set_paths!() 43 | 44 | # MD_PAGES 45 | base = F.PATHS[:folder] 46 | file = "index.md" 47 | out = F.form_output_path(base, file, :md) 48 | @test out == joinpath(F.PATHS[:site], "index.html") 49 | 50 | file = "index.html" 51 | out = F.form_output_path(base, file, :html) 52 | @test out == joinpath(F.PATHS[:site], "index.html") 53 | 54 | file = "page.md" 55 | out = F.form_output_path(base, file, :md) 56 | @test out == joinpath(F.PATHS[:site], "page", "index.html") 57 | 58 | file = "page.html" 59 | out = F.form_output_path(base, file, :html) 60 | @test out == joinpath(F.PATHS[:site], "page", "index.html") 61 | 62 | file = "index.md" 63 | base = joinpath(F.PATHS[:folder], "menu") 64 | out = F.form_output_path(base, file, :md) 65 | @test out == joinpath(F.PATHS[:site], "menu", "index.html") 66 | 67 | file = "index.html" 68 | out = F.form_output_path(base, file, :html) 69 | @test out == joinpath(F.PATHS[:site], "menu", "index.html") 70 | 71 | file = "page.md" 72 | out = F.form_output_path(base, file, :md) 73 | @test out == joinpath(F.PATHS[:site], "menu", "page", "index.html") 74 | 75 | # OTHER STUFF 76 | file = "foo.css" 77 | base = F.PATHS[:css] 78 | out = F.form_output_path(base, file, :infra) 79 | @test out == joinpath(F.PATHS[:site], "css", "foo.css") 80 | file = "lib.js" 81 | base = F.PATHS[:libs] 82 | out = F.form_output_path(base, file, :infra) 83 | @test out == joinpath(F.PATHS[:site], "libs", "lib.js") 84 | 85 | # ================================================ 86 | 87 | empty!(F.PATHS); F.FD_ENV[:STRUCTURE] = v"0.1"; F.set_paths!() 88 | end 89 | -------------------------------------------------------------------------------- /test/integration/literate.jl: -------------------------------------------------------------------------------- 1 | fs2() 2 | 3 | mkpath(F.path(:literate)) 4 | 5 | @testset "Literate-0" begin 6 | @test_throws ErrorException literate_folder("foo/") 7 | litpath = literate_folder("_literate/") 8 | @test litpath == literate_folder(F.path(:literate)) 9 | end 10 | 11 | @testset "Literate-a" begin 12 | # Post processing: numbering of julia blocks 13 | s = raw""" 14 | A 15 | 16 | ```julia 17 | B 18 | ``` 19 | 20 | C 21 | 22 | ```julia 23 | D 24 | ``` 25 | """ 26 | @test F.literate_post_process(s) == """ 27 | 28 | A 29 | 30 | ```julia:ex1 31 | B 32 | ``` 33 | 34 | C 35 | 36 | ```julia:ex2 37 | D 38 | ``` 39 | """ 40 | end 41 | 42 | @testset "Literate-b" begin 43 | # Literate to Franklin 44 | s = raw""" 45 | # # Rational numbers 46 | # 47 | # In julia rational numbers can be constructed with the `//` operator. 48 | # Lets define two rational numbers, `x` and `y`: 49 | 50 | ## Define variable x and y 51 | x = 1//3 52 | y = 2//5 53 | 54 | # When adding `x` and `y` together we obtain a new rational number: 55 | 56 | z = x + y 57 | """ 58 | path = joinpath(F.path(:literate), "tutorial.jl") 59 | write(path, s) 60 | opath, = F.literate_to_franklin("/_literate/tutorial") 61 | @test endswith(opath, joinpath(F.PATHS[:site], "assets", "literate", "tutorial.md")) 62 | out = read(opath, String) 63 | @test out == """ 64 | 65 | # Rational numbers 66 | 67 | In julia rational numbers can be constructed with the `//` operator. 68 | Lets define two rational numbers, `x` and `y`: 69 | 70 | ```julia:ex1 71 | # Define variable x and y 72 | x = 1//3 73 | y = 2//5 74 | ``` 75 | 76 | When adding `x` and `y` together we obtain a new rational number: 77 | 78 | ```julia:ex2 79 | z = x + y 80 | ``` 81 | 82 | """ 83 | 84 | # Use of `\literate` command 85 | h = raw""" 86 | @def hascode = true 87 | @def showall = true 88 | @def reeval = true 89 | 90 | \literate{/_literate/tutorial.jl} 91 | """ |> fd2html_td 92 | @test isapproxstr(h, """ 93 |Rational numbers
94 |In julia rational numbers can be constructed with the // operator. Lets define two rational numbers, x and y:
# Define variable x and y
96 | x = 1//3
97 | y = 2//52//5When adding x and y together we obtain a new rational number:
z = x + y11//15// Literate file matching '/foo' not found. //
\n""" 114 | end 115 | -------------------------------------------------------------------------------- /test/integration/literate_fs2.jl: -------------------------------------------------------------------------------- 1 | fs1() 2 | 3 | scripts = joinpath(F.PATHS[:folder], "literate-scripts") 4 | mkpath(scripts) 5 | 6 | @testset "Literate-0" begin 7 | @test_throws ErrorException literate_folder("foo/") 8 | litpath = literate_folder("literate-scripts/") 9 | @test litpath == joinpath(F.PATHS[:folder], "literate-scripts/") 10 | end 11 | 12 | @testset "Literate-a" begin 13 | # Post processing: numbering of julia blocks 14 | s = raw""" 15 | A 16 | 17 | ```julia 18 | B 19 | ``` 20 | 21 | C 22 | 23 | ```julia 24 | D 25 | ``` 26 | """ 27 | @test F.literate_post_process(s) == """ 28 | 29 | A 30 | 31 | ```julia:ex1 32 | B 33 | ``` 34 | 35 | C 36 | 37 | ```julia:ex2 38 | D 39 | ``` 40 | """ 41 | end 42 | 43 | @testset "Literate-b" begin 44 | # Literate to Franklin 45 | s = raw""" 46 | # # Rational numbers 47 | # 48 | # In julia rational numbers can be constructed with the `//` operator. 49 | # Lets define two rational numbers, `x` and `y`: 50 | 51 | ## Define variable x and y 52 | x = 1//3 53 | y = 2//5 54 | 55 | # When adding `x` and `y` together we obtain a new rational number: 56 | 57 | z = x + y 58 | """ 59 | path = joinpath(scripts, "tutorial.jl") 60 | write(path, s) 61 | opath, = F.literate_to_franklin("/literate-scripts/tutorial") 62 | @test endswith(opath, joinpath(F.PATHS[:assets], "literate", "tutorial.md")) 63 | out = read(opath, String) 64 | @test out == """ 65 | 66 | # Rational numbers 67 | 68 | In julia rational numbers can be constructed with the `//` operator. 69 | Lets define two rational numbers, `x` and `y`: 70 | 71 | ```julia:ex1 72 | # Define variable x and y 73 | x = 1//3 74 | y = 2//5 75 | ``` 76 | 77 | When adding `x` and `y` together we obtain a new rational number: 78 | 79 | ```julia:ex2 80 | z = x + y 81 | ``` 82 | 83 | """ 84 | 85 | # Use of `\literate` command 86 | h = raw""" 87 | @def hascode = true 88 | @def showall = true 89 | @def reeval = true 90 | 91 | \literate{/literate-scripts/tutorial.jl} 92 | """ |> fd2html_td 93 | @test isapproxstr(h, """ 94 |Rational numbers
95 |In julia rational numbers can be constructed with the // operator. Lets define two rational numbers, x and y:
# Define variable x and y
97 | x = 1//3
98 | y = 2//52//5When adding x and y together we obtain a new rational number:
z = x + y11//15// Literate file matching '/foo' not found. //
\n""" 115 | end 116 | -------------------------------------------------------------------------------- /test/converter/md/hyperref.jl: -------------------------------------------------------------------------------- 1 | @testset "Hyperref" begin 2 | st = raw""" 3 | Some string 4 | $$ x = x \label{eq 1}$$ 5 | then as per \citet{amari98b} also this \citep{bardenet17} and 6 | \cite{amari98b, bardenet17} 7 | Reference to equation: \eqref{eq 1}. 8 | 9 | Then maybe some text etc. 10 | 11 | * \biblabel{amari98b}{Amari and Douglas., 1998} **Amari** and **Douglas**: *Why Natural Gradient*, 1998. 12 | * \biblabel{bardenet17}{Bardenet et al., 2017} **Bardenet**, **Doucet** and **Holmes**: *On Markov Chain Monte Carlo Methods for Tall Data*, 2017. 13 | """; 14 | 15 | F.def_GLOBAL_VARS!() 16 | F.def_GLOBAL_LXDEFS!() 17 | 18 | m = F.convert_md(st) 19 | 20 | h1 = F.refstring("eq 1") 21 | h2 = F.refstring("amari98b") 22 | h3 = F.refstring("bardenet17") 23 | 24 | @test haskey(F.PAGE_EQREFS, h1) 25 | @test haskey(F.PAGE_BIBREFS, h2) 26 | @test haskey(F.PAGE_BIBREFS, h3) 27 | 28 | @test F.PAGE_EQREFS[h1] == 1 # first equation 29 | @test F.PAGE_BIBREFS[h2] == "Amari and Douglas., 1998" 30 | @test F.PAGE_BIBREFS[h3] == "Bardenet et al., 2017" 31 | 32 | h = F.convert_html(m) 33 | 34 | @test isapproxstr(h, """ 35 |36 | Some string 37 | \\[ x = x \\] 38 | then as per Amari and Douglas., 1998 also this (Bardenet et al., 2017) and 39 | Amari and Douglas., 1998, Bardenet et al., 2017 40 | Reference to equation: (1) . 41 |
42 |43 | Then maybe some text etc. 44 |
45 |-
46 |
- 47 |
Bardenet, Doucet and Holmes: On Markov Chain Monte Carlo Methods for Tall Data, 2017.
48 |
Then something like \$\$\\begin{array}{c} \\mathbb E\\left[ f(X)\\right] \\in \\mathbb R &\\text{if}& f:\\mathbb R\\maptso\\mathbb R\\end{array}\$\$ and then \$\$\\begin{array}{c} 1+1 &=&2 \\end{array}\$\$ but further \$\$\\begin{array}{c} 1 &=& 1 \\end{array}\$\$ and finally a ({{href EQR $h1}}) and maybe ({{href EQR $h2}}).
\n" 89 | end 90 | -------------------------------------------------------------------------------- /test/converter/md/tags.jl: -------------------------------------------------------------------------------- 1 | @testset "tagpages" begin 2 | fs2() 3 | write(joinpath("_layout", "head.html"), "") 4 | write(joinpath("_layout", "foot.html"), "") 5 | write(joinpath("_layout", "page_foot.html"), "") 6 | write("config.md", "") 7 | write("index.md", """ 8 | Hello 9 | """) 10 | F.def_GLOBAL_VARS!() 11 | F.def_LOCAL_VARS!() 12 | write("pg1.md", "@def title = \"Page1\"") 13 | write("pg2.md", "@def title = \"Page2\"") 14 | F.set_var!(F.GLOBAL_VARS, "fd_page_tags", F.DTAG(("pg1" => Set(["aa", "bb"]),))) 15 | F.globvar("fd_page_tags")["pg2"] = Set(["bb", "cc"]) 16 | 17 | @test Set(keys(F.globvar("fd_page_tags"))) == Set(["pg1", "pg2"]) 18 | @test Set(union(values(F.globvar("fd_page_tags"))...)) == Set(["aa", "bb", "cc"]) 19 | 20 | F.generate_tag_pages() 21 | 22 | @test F.globvar("fd_tag_pages")["aa"] == ["pg1"] 23 | @test F.globvar("fd_tag_pages")["bb"] == ["pg1","pg2"] 24 | @test F.globvar("fd_tag_pages")["cc"] == ["pg2"] 25 | 26 | @test isdir(F.path(:tag)) 27 | @test isfile(joinpath(F.path(:tag), "aa", "index.html")) 28 | @test isfile(joinpath(F.path(:tag), "bb", "index.html")) 29 | @test isfile(joinpath(F.path(:tag), "cc", "index.html")) 30 | 31 | tagbb = read(joinpath(F.path(:tag), "bb", "index.html"), String) 32 | tagcc = read(joinpath(F.path(:tag), "cc", "index.html"), String) 33 | 34 | @test occursin("""""", tagbb) 35 | @test occursin("""""", tagcc) 36 | 37 | F.clear_dicts() 38 | end 39 | 40 | # ======= INTEGRATION ============ 41 | 42 | @testset "tags" begin 43 | fs2() 44 | write(joinpath("_layout", "head.html"), "") 45 | write(joinpath("_layout", "foot.html"), "") 46 | write(joinpath("_layout", "page_foot.html"), "") 47 | write("config.md", "") 48 | write("index.md", """ 49 | Hello 50 | """) 51 | F.def_GLOBAL_VARS!() 52 | F.def_LOCAL_VARS!() 53 | isdir("blog") && rm("blog", recursive=true) 54 | mkdir("blog") 55 | write(joinpath("blog", "pg1.md"), """ 56 | @def tags = ["aa", "bb", "cc"] 57 | @def date = Date(2000, 01, 01) 58 | @def title = "Page 1" 59 | """) 60 | write(joinpath("blog", "pg2.md"), """ 61 | @def tags = ["bb", "cc"] 62 | @def date = Date(2001, 01, 01) 63 | @def title = "Page 2" 64 | """) 65 | write(joinpath("blog", "pg3.md"), """ 66 | @def tags = ["bb", "cc", "ee", "dd"] 67 | @def date = Date(2002, 01, 01) 68 | @def title = "Page 3" 69 | """) 70 | write(joinpath("blog", "pg4.md"), """ 71 | @def tags = ["aa", "dd", "ee"] 72 | @def date = Date(2003, 01, 01) 73 | @def title = "Page 4" 74 | """) 75 | serve(clear=true, single=true, cleanup=false, nomess=true) 76 | @test isdir(joinpath("__site", "tag")) 77 | for tag in ("aa", "bb", "cc", "dd", "ee") 78 | local p 79 | p = joinpath("__site", "tag", tag, "index.html") 80 | @test isfile(p) 81 | end 82 | 83 | p = joinpath("__site", "tag", "aa", "index.html") 84 | c = read(p, String) 85 | @test occursin("""Tag: aa""", c) 86 | @test occursin("""""", c)
87 | @test occursin("""""", c)
89 |
90 | # Now remove some pages; we use bash commands so that they're blocking
91 | success(`rm $(joinpath("blog", "pg4.md"))`)
92 | success(`rm $(joinpath("blog", "pg3.md"))`)
93 |
94 | serve(clear=true, single=true, nomess=true)
95 | c = read(p, String)
96 | @test occursin("""
""", c)
97 | @test occursin("""""", c)
98 |
99 | F.clear_dicts()
100 | end
101 |
--------------------------------------------------------------------------------
/test/runtests.jl:
--------------------------------------------------------------------------------
1 | using Franklin, Test, Markdown, Dates, Random, Literate
2 | const F = Franklin
3 | const R = @__DIR__
4 | const D = joinpath(dirname(dirname(pathof(Franklin))), "test", "_dummies")
5 |
6 | F.FD_ENV[:SILENT_MODE] = true
7 | # F.FD_ENV[:DEBUG_MODE] = true
8 | F.FD_ENV[:STRUCTURE] = v"0.1" # legacy, it's switched up in the tests.
9 |
10 | # UTILS
11 | println("UTILS-1")
12 | include("utils/folder_structure.jl")
13 | include("utils/paths_vars.jl"); include("test_utils.jl")
14 | # ---
15 | println("UTILS-2")
16 | include("utils/misc.jl")
17 | include("utils/errors.jl")
18 | include("utils/html.jl")
19 | include("regexes.jl")
20 | println("🍺")
21 |
22 | # MANAGER folder
23 | println("MANAGER")
24 | include("manager/utils.jl")
25 | include("manager/utils_fs2.jl")
26 | include("manager/rss.jl")
27 | include("manager/config.jl")
28 | include("manager/config_fs2.jl")
29 | include("manager/dir_utils.jl")
30 | include("manager/page_vars_html.jl")
31 | println("🍺")
32 |
33 | # PARSER folder
34 | println("PARSER/MD+LX")
35 | include("parser/1-tokenize.jl")
36 | include("parser/2-blocks.jl")
37 | include("parser/markdown+latex.jl")
38 | include("parser/markdown-extra.jl")
39 | include("parser/footnotes+links.jl")
40 | include("parser/latex++.jl")
41 | include("parser/indentation++.jl")
42 | include("parser/md-dbb.jl")
43 | println("🍺")
44 |
45 | # EVAL
46 | println("EVAL")
47 | include("eval/module.jl")
48 | include("eval/run.jl")
49 | include("eval/io.jl")
50 | include("eval/io_fs2.jl")
51 | include("eval/codeblock.jl")
52 | include("eval/eval.jl")
53 | include("eval/eval_fs2.jl")
54 | include("eval/integration.jl")
55 | include("eval/extras.jl")
56 |
57 | # CONVERTER folder
58 | println("CONVERTER/MD")
59 | include("converter/md/markdown.jl")
60 | include("converter/md/markdown2.jl")
61 | include("converter/md/markdown3.jl")
62 | include("converter/md/markdown4.jl")
63 | include("converter/md/hyperref.jl")
64 | include("converter/md/md_defs.jl")
65 | include("converter/md/tags.jl")
66 | println("🍺")
67 | println("CONVERTER/HTML")
68 | include("converter/html/html.jl")
69 | include("converter/html/html2.jl")
70 | include("converter/html/html_for.jl")
71 | println("🍺")
72 | println("CONVERTER/LX")
73 | include("converter/lx/input.jl")
74 | include("converter/lx/simple.jl")
75 | include("converter/lx/simple_fs2.jl")
76 | println("🍺")
77 |
78 | fs2()
79 |
80 | println("GLOBAL")
81 | include("global/cases1.jl")
82 | include("global/cases2.jl")
83 | include("global/ordering.jl")
84 | include("global/html_esc.jl")
85 |
86 | begin
87 | # create temp dir to do complete integration testing (has to be here in
88 | # order to locally play nice with node variables etc, otherwise it's a big
89 | # headache)
90 | p = joinpath(D, "..", "__tmp");
91 | # after errors, this may not have been deleted properly
92 | isdir(p) && rm(p; recursive=true, force=true)
93 | # make dir, go in it, do the tests, then get completely out (otherwise
94 | # windows can't delete the folder)
95 | mkdir(p); cd(p);
96 | include("global/postprocess.jl");
97 | include("global/rss.jl")
98 | cd(p)
99 | include("global/eval.jl")
100 | cd(joinpath(D, ".."))
101 | # clean up
102 | rm(p; recursive=true, force=true)
103 | end
104 | cd(dirname(dirname(pathof(Franklin))))
105 |
106 | println("TEMPLATING")
107 | include("templating/for.jl")
108 | include("templating/fill.jl")
109 |
110 | println("UTILS FILE")
111 | include("utils_file/basic.jl")
112 |
113 | println("INTEGRATION")
114 | include("integration/literate.jl")
115 | include("integration/literate_fs2.jl")
116 | include("integration/literate_extras.jl")
117 |
118 | flush_td()
119 | cd(joinpath(dirname(dirname(pathof(Franklin)))))
120 |
121 | println("COVERAGE")
122 | include("coverage/extras1.jl")
123 | include("coverage/paths.jl")
124 |
125 | println("😅 😅 😅 😅")
126 |
127 | # check quickly if the IPs in IP_CHECK are still ok
128 | println("Verifying ip addresses, if online these should succeed.")
129 | for (addr, name) in F.IP_CHECK
130 | println(rpad("Ping $name:", 13), ifelse(F.check_ping(addr), "✓", "✗"), ".")
131 | end
132 |
--------------------------------------------------------------------------------
/test/global/postprocess.jl:
--------------------------------------------------------------------------------
1 | @testset "Gen&Opt" begin
2 | isdir("basic") && rm("basic", recursive=true, force=true)
3 | newsite("basic")
4 |
5 | global silly_call = 0
6 | function foo_on_write(pg, vars)
7 | global silly_call
8 | silly_call += length(pg)
9 | vars["fd_rpath"] # should not error
10 | return nothing
11 | end
12 |
13 | serve(single=true, on_write=foo_on_write)
14 |
15 | @test silly_call > 0
16 |
17 | # ---------------
18 | @test all(isdir, ("_assets", "_css", "_libs", "_layout", "__site"))
19 | @test isfile(joinpath("__site", "index.html"))
20 | @test isfile(joinpath("__site", "menu1", "index.html"))
21 | @test isfile(joinpath("__site", "menu2", "index.html"))
22 | @test isfile(joinpath("__site", "menu3", "index.html"))
23 | @test isfile(joinpath("__site", "css", "basic.css"))
24 | @test isfile(joinpath("__site", "css", "franklin.css"))
25 |
26 | # ---------------
27 | if Franklin.FD_CAN_MINIFY
28 | presize1 = stat(joinpath("__site", "css", "basic.css")).size
29 | presize2 = stat(joinpath("__site", "index.html")).size
30 | optimize(prerender=false)
31 | @test stat(joinpath("__site", "css", "basic.css")).size < presize1
32 | @test stat(joinpath("__site", "index.html")).size < presize2
33 | end
34 | # ---------------
35 | # verify all links
36 | Franklin.verify_links()
37 |
38 | # ---------------
39 | # change the prepath
40 | index = read(joinpath("__site","index.html"), String)
41 | @test occursin("=\"/css/basic.css", index)
42 | @test occursin("=\"/css/franklin.css", index)
43 | @test occursin("=\"/libs/highlight/github.min.css", index)
44 | @test occursin("=\"/libs/katex/katex.min.css", index)
45 |
46 | optimize(minify=false, prerender=false, prepath="prependme")
47 | index = read(joinpath("__site","index.html"), String)
48 | @test occursin("=\"/prependme/css/basic.css", index)
49 | @test occursin("=\"/prependme/css/franklin.css", index)
50 | @test occursin("=\"/prependme/libs/highlight/github.min.css", index)
51 | @test occursin("=\"/prependme/libs/katex/katex.min.css", index)
52 | end
53 |
54 | if F.FD_CAN_PRERENDER; @testset "prerender" begin
55 | @testset "katex" begin
56 | hs = raw"""
57 |
58 |
59 |
60 |
61 |
65 | """
66 |
67 | jskx = F.js_prerender_katex(hs)
68 | # conversion of the non-ascii endash (inline)
69 | @test occursin("""–""", jskx)
70 | # conversion of `\(M\)` (inline)
71 | @test occursin("""range is \(10\sqrt{3}\)–\(20\sqrt{2}\)
62 |Consider an invertible matrix \(M\) made of blocks \(A\), \(B\), \(C\) and \(D\) with
63 | \[ M \quad\!\! =\quad\!\! \begin{pmatrix} A & B \\ C & D \end{pmatrix} \] 64 |