'hastysite import

{} :ARCHIVES
() :ARTICLES
{} :HOME
() :PROJECTS
() :SPELLS

"contents/articles" sys.ls size :articles-count
17 :projects-count
"contents/grimoire" sys.ls size :grimoire-count

(
  symbol to-date
  (int :timestamp ==> str :result)
  (
    timestamp integer "dddd, d MMMM yyyy" time.format @result
  )
) ::
;; Utility operator to format a timestamp into a date


(
  symbol create-articles-page
  (==>)
  (
    {}
    "articles/index"    "id" dict.set
    "articles.html"     "path" dict.set
    ".html"             "ext" dict.set
    "ARTICLES"          "title" dict.set
    "page"              "content-type" dict.set
    ARCHIVES dict.values ("code" dict.get :a "code" dict.get :b a b >) sort 
    ;; sort articles within each archive
    (
      stack.dup "articles" dict.get 
        ("timestamp" dict.get :a "timestamp" dict.get :b
        a b >) sort "articles" dict.set
    ) map
    "archives" dict.set
    projects-count "projects-count" dict.set
    articles-count "articles-count" dict.set
    grimoire-count "grimoire-count" dict.set
    ;; TODO: why processing twice??
    stack.dup "_archives" stack.swap mustache "contents" dict.set
    stack.dup "page" stack.swap mustache :page
    "articles" page process-icons
    "contents" dict.set
    output-fwrite
  )
) ::
;; Create articles page

(
  symbol create-projects-page
  (==>)
  (
    {}
    "projects/index"                                    "id" dict.set
    "projects.html"                                     "path" dict.set
    ".html"                                             "ext" dict.set
    "PROJECTS"                                          "title" dict.set
    "page"                                              "content-type" dict.set
    PROJECTS ('active dict.has?) filter ("id" dict.get stack.swap "id" dict.get <) sort     "active-projects" dict.set
    PROJECTS ('active dict.has? not) filter ("id" dict.get stack.swap "id" dict.get <) sort "inactive-projects" dict.set
    projects-count "projects-count" dict.set
    articles-count "articles-count" dict.set
    grimoire-count "grimoire-count" dict.set
    stack.dup "projects" stack.swap mustache :page
    "projects" page process-icons
    "contents" dict.set
    output-fwrite
  )
) ::
;; Create the Projects page

(
  symbol create-grimoire-page
  (==>)
  (
    {}
    "grimoire/index"                                    "id" dict.set
    "grimoire.html"                                     "path" dict.set
    ".html"                                             "ext" dict.set
    "GRIMOIRE"                                          "title" dict.set
    "page"                                              "content-type" dict.set
    SPELLS ("id" dict.get stack.swap "id" dict.get <) sort                        "spells" dict.set
    projects-count "projects-count" dict.set
    articles-count "articles-count" dict.set
    grimoire-count "grimoire-count" dict.set
    stack.dup "grimoire" stack.swap mustache :page
    "grimoire" page process-icons
    "contents" dict.set
    output-fwrite
  )
) ::
;; Create the Grimoire page

(
  symbol process-timestamp
  (dict :content ==> dict :result)
  (
    (content 'timestamp dict.has?)
    (
      content "timestamp" dict.get :ts
      ts to-date :date 
      ts integer "yyyyMM" time.format :code
      ts integer "MMMM yyyy" time.format :month
      ts integer "MMMM-yyyy" time.format lowercase :id
      ;; Add to articles
      content date "date" dict.set @content
      content ARTICLES append @ARTICLES
      (ARCHIVES code dict.has?)
      (
        ;; Add article to existing archive
        content ("id" "title" "timestamp" "date") dict.pick :article
        ARCHIVES code dict.get :archivedata
        archivedata "articles" dict.get :articles
        article articles append @articles
        archivedata articles "articles" dict.set :archivedata
        ARCHIVES archivedata code dict.set @ARCHIVES
      )
      (
        ;; Create new monthly archive
        content ("id" "title" "timestamp" "date") dict.pick :article
        {}
        month         "month" dict.set
        code          "code" dict.set
        article quote "articles" dict.set
        id            "id" dict.set
        :archive
        ARCHIVES archive code dict.set @ARCHIVES
      ) if
    ) when
    content @result
  )
) ::
;; Group articles by month

(
  symbol copy-pdf-article-asset
  (dict :asset ==>)
  (
    asset "id" dict.get :id
    id "^pdf/(.+)$" search 1 get :name
    asset "output/articles/$1/$1" (name) => % "id" dict.set @asset
    asset output-cp
  )
) ::
;; Copy PDF files saved in asset folder
;; to the corresponding article output folder.

;; Syntax highlighting
(
  symbol process-code
  (str :text ==> str :result)
  (
    "temp/highlight" :tmpfile
    "chroma $# $#--html --html-only --html-prevent-surrounding-pre" :cmd
    text "<pre>\\s*<code[^>]*?(?:class=\"([a-z0-1]+)\")?>([\\s\\S]+?)</code></pre>" (
      :match
      match 2 get :code
      match 1 get :lang
      "" :lexer
      (lang "" !=) 
        ("--lexer $# " (lang) =% @lexer)
      when
      ;; Unescape HTML entities
      code "(&gt;|&lt;|&quot;|&amp;)" (
        :match
        match 1 get :ntt
        (ntt "&gt;" ==)
          (">")
        when
        (ntt "&lt;" ==)
          ("<")
        when
        (ntt "&quot;" ==)
          ("\"")
        when
        (ntt "&amp;" ==)
          ("&")
        when
      ) replace-apply @code
      code tmpfile fs.write
      cmd (tmpfile lexer) =% sys.run "output" dict.get :out
      "<pre class=\"chroma\"><code>$#</code></pre>" (out) =%
    ) replace-apply @result
  )
) ::

(
  symbol prepend-toc
  (str :text ==> str :result)
  (
    () :headings
    text "<h3[^>]*>([^<]+)</h3>" (
      :matches
      matches 1 get :title
      title "[^a-zA-Z0-9_-]" "_" replace :id
      "heading__$#" (id) =% @id
      {}
        title "title" dict.set
        id "id" dict.set 
      headings append @headings
      "<a class='heading-anchor' id='$1'></a><h3>$2 <a class='go2top' href='#top' title='Go to the top'>⇈</a></h3>" (id title) =%
    ) replace-apply @result
    (headings size 3 >=)
      (
        headings (
          :heading
          heading "id" dict.get :id
          heading "title" dict.get :text
          "<li><a href='#$1'>$2</a></li>" (id text) =%
        ) map "\n" join :links
        "<ul id='toc' class='panel'>$1</ul>" (links) =% :toc
        "$1\n$2" (toc result) =% @result
      )
    when
  )
) ::

;; Process :icon: markup
(
  symbol process-icons
  (str :id str :text ==> str :result)
  ( 
    ;; whitelist of common false positives for icon markup
    ("borrow", "http", "cakephp") :whitelist
    text ":([a-z]+[a-z0-9-]+)(?:\\|([a-zA-Z0-9 ]+))?:" (
      :match
      match 0 get :content
      match 1 get :icon
      match 2 get :explicit-title
      "assets/images/icons/$#.svg" (icon) =% :path
      (path fs.file?)
        (
          path fs.read xml.from-xml "svg" xml.query :svgx
          icon :title
          (explicit-title "" !=)
            (explicit-title @title)
          when
          ;; Add title tag
          "<title>$#</title>" (title) =% xml.from-xml :svg-title
          svgx stack.dup "children" dict.get svg-title stack.swap prepend "children" dict.set @svgx
          ;; Add role="img"
          svgx "attributes" dict.get :svg-attrs
          svgx svg-attrs "img" "role" dict.set "attributes" dict.set @svgx
          svgx xml.to-xml :svg
          "<span class=\"icon\">$#</span>" (svg) =% @content
        )
        (
          (whitelist icon in? not)
            ("$# - Icon not found: $#" (id icon) =% io.warn)
          when
        )
      if
      content
    ) replace-apply @result
  ) 
) ::

(
  symbol process-content
  (dict :content ==> dict :result)
  (
    content "id" dict.get :id
    content "content-type" dict.get :ct
    "page" :tpl
    (ct "article" ==) ("article" @tpl) when
    (ct "project" ==) ("project" @tpl) when
    (id "index" ==) (content @HOME "home" @tpl) when
    "" :page
    "" :contents
    content input-fread @contents
    (content "ext" dict.get ".md" ==) (contents content markdown @contents) when
    content contents prepend-toc "contents" dict.set @content
    tpl content mustache @page
    id page process-icons @page
    id page process-code @page
    content page "contents" dict.set @content
    (
        ((id "^(glyph|ruby-compendium)(/|\\\\)book" match?) ()) ;;Do not add index.html due to the way book internal links work.
        ((id "index" !=)(
          content 
            "$1/index" (id) =% "id" dict.set 
            ".html" "ext" dict.set 
            ;; ID must be preserved for links on home page.
            id "rawid" dict.set
          @content
        ))
    ) case
    content @result
  )
) ::
;; Process a content file applying the appropriate template
;; and compiling markdown to HTML if necessary.


(
  symbol generate-home
  (==>)
  (
    ;; Sort articles by timestamp
    ARTICLES ("timestamp" dict.get stack.swap "timestamp" dict.get >) sort @ARTICLES
    ARTICLES first        :latest
    ARTICLES 1 5 slice    :recents
    ;; Process summary
    latest input-fread "(?ms)(.+)?<hr" search 1 get latest markdown :summary
    latest summary "summary" dict.set @latest
    latest stack.dup "timestamp" dict.get to-date "date" dict.set @latest
    HOME
    latest "latest" dict.set
    recents "recents" dict.set
    projects-count "projects-count" dict.set
    articles-count "articles-count" dict.set
    grimoire-count "grimoire-count" dict.set
    ;;tags %tags
    stack.dup "home" stack.swap mustache :page
    "home" page process-icons
    "contents" dict.set
    output-fwrite
  )
) ::
;; Process and generate home page


(
  symbol process-css-asset
  (dict :meta ==>)
  (
    "" :contents
    meta (
      (input-fread @contents meta)
      (:temp contents @contents temp)
      (contents "contents" dict.set)
    ) tap
    output-fwrite
  )
) ::
;; Process CSS assets

;;;;; MAIN ;;;;;

true :enable-content-processing

(opts 'no-contents dict.has?)
  (false @enable-content-processing)
when 

(enable-content-processing)
(
  ;; Process all contents
  contents (
    :content
    (((content 'draft dict.has? not) (content 'content-type dict.has?)) &&)
    (
      content "id" dict.get :id
      (content "content-type" dict.get "project" ==) (content PROJECTS append @PROJECTS) when
      (content "content-type" dict.get "spell" ==) (content SPELLS append @SPELLS) when
      content
      projects-count "projects-count" dict.set
      articles-count "articles-count" dict.set
      grimoire-count "grimoire-count" dict.set
      process-timestamp 
      process-content 
      @content 
      (id "index" !=) (content output-fwrite) when
    ) when
  ) foreach

  ;; Create aggregator pages
  create-projects-page
  create-grimoire-page
  create-articles-page

  ;; Generate home page
  generate-home
)
when

;; Process all assets.
assets (
  stack.dup
  (
    (("id" dict.get "^pdf/" match?) (copy-pdf-article-asset))
    (("ext" dict.get ".css" match?) (process-css-asset))
    ((true) (output-cp))
  ) case
) foreach