machinelistening
/
curriculum
1
0
Fork 0
Code Issues 1 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
189 Commits
2 Branches
118 MiB
 
Tree: 2f99b71465
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '2f99b71465'
${ noResults }
curriculum/_vendor/git.sandpoints.org/Drawwell/SandpointsTheme/layouts/partials/scratch.html

203 lines
8.8 KiB
Raw Blame History 

  1. {{ $currentNode := . }}

  2. 

  3. {{ $_ := newScratch }}

  4. {{ $debug := (slice) }}

  5. 

  6. {{ $sandnameSingular := (slice)   }}

  7. {{ $sandnamePlural := (slice)  }}

  8. 

  9. {{ range $k, $v := $.Site.Data.sandpointsnamegraph }}

  10.   {{ $sandnameSingular = $sandnameSingular | append $k }}

  11.   {{ $sandnamePlural = $sandnamePlural | append $v }}

  12. {{ end  }}

  13. 

  14. {{ $pPath := "" }}

  15. {{ range $p := .Site.RegularPages }}

  16.   {{ $pPath = printf "/%s" $p.File }}

  17.   {{ $pageDir := "" }}

  18.   {{ with $p.File }}

  19.     {{ $pageDir = (substr .Dir 0 -1)}}

  20.   {{ end }}

  21. 

  22.   {{ $content := $p.Content }}

  23.   {{ with $links := $p.Scratch.Get "links" }}

  24.     {{ range $link := $links }}

  25.       {{ $linkPath := printf "/%s" $link.File}}

  26.       {{ with ($_.Get $linkPath) }}

  27.         {{ $_.SetInMap $linkPath "backlinks" (uniq ((index ($_.Get $linkPath) "backlinks") | append $p)) }}

  28.       {{ else }}

  29.         {{ $_.SetInMap $linkPath "backlinks" (slice $p) }}

  30.       {{ end }}

  31.     {{ end }}

  32.   {{ end }}

  33. 

  34.   {{ $paramsKeys := (slice) }}

  35.   {{ range $k, $v := $p.Params  }}

  36.     {{ $paramsKeys = $paramsKeys | append $k  }}

  37.   {{ end  }}

  38.   

  39.   {{ $mentions := intersect $paramsKeys $sandnamePlural }}

  40.   {{ range $mention := $mentions  }}

  41.     {{ range $m := index $p.Params $mention }}

  42.       {{ $mentionLink := printf "/%s/%s" (substr $mention 0 -1) $m }}

  43.       {{ with ($_.Get $mentionLink)  }}

  44.         {{ $p.Scratch.Add "links" (uniq (($p.Scratch.Get "links")| append ($.GetPage $mentionLink))) }}

  45.         {{ $_.SetInMap $mentionLink "backlinks" (uniq ((index ($_.Get $mentionLink) "backlinks") | append $p)) }}

  46.       {{ else }}

  47.         {{ $p.Scratch.Add "links" (uniq (($p.Scratch.Get "links")| append ($.GetPage $mentionLink))) }}

  48.         {{ $_.SetInMap $mentionLink "backlinks" (slice $p) }} 

  49.       {{ end  }}

  50.     {{ end  }}

  51.   {{ end  }}

  52. 

  53.   {{ $gp := $.GetPage $pPath }}

  54.   {{ $gpPath := printf "/%s" $gp.File }}

  55.   {{ range $k, $v := $gp.Params }}

  56.     {{ with in $k "has_" }}

  57.       {{ $s := index (split $k "has_") 1 }}

  58.       {{ range $sin,$plur := $currentNode.Site.Data.sandpointsnamegraph }}

  59.         {{ if eq $s $plur }}

  60.           {{ range index $gp.Params $k }}

  61.             {{ $cp := $.GetPage (printf "/%s/%s" $sin .) }}

  62.             {{ $cpPath := printf "/%s" $cp.File }}

  63.             {{ range $kcp, $vcp := $cp.Params }}

  64.               {{ with in $kcp "has_" }}

  65.                 {{ $scp := index (split $kcp "has_") 1 }}

  66.                 {{ range $sincp,$plurcp := $currentNode.Site.Data.sandpointsnamegraph }}

  67.                   {{ if eq $scp $plurcp }}

  68. 

  69.                     {{ $_.SetInMap $gpPath "depth" "core" }}

  70.                     {{ $_.SetInMap $gpPath "child_depth" "mantle" }}

  71.                     {{ $_.SetInMap $gpPath "has" $s }}

  72. 

  73.                     {{ with $gp.File }}

  74.                       {{ $core := substr .Dir 0 -1 }}

  75.                       {{ with index ($_.Get $gpPath) "core" }}

  76.                         {{ $_.SetInMap $gpPath "core" (uniq ((index ($_.Get $gpPath) "core") | append $core)) }}

  77.                       {{ else }}

  78.                         {{ $_.SetInMap $gpPath "core" (slice $core) }}

  79.                       {{ end }}

  80.                       {{ $cor := $_.Get $cpPath }}

  81.                       {{ with $cor.core }}

  82.                         {{ $_.SetInMap $cpPath "core" (uniq ((index ($_.Get $cpPath) "core") | append $core)) }}

  83.                       {{ else }}

  84.                         {{ $_.SetInMap $cpPath "core" (slice $core) }}

  85.                       {{ end }}

  86.                     {{ end }}

  87. 

  88.                     {{ with $cp.File }}

  89.                       {{ $mantle := substr .Dir 0 -1 }}

  90.                       {{ with index ($_.Get $gpPath) "mantle" }}

  91.                         {{ $_.SetInMap $gpPath "mantle" (uniq ((index ($_.Get $gpPath) "mantle") | append $mantle)) }}

  92.                       {{ else }}

  93.                         {{ $_.SetInMap $gpPath "mantle" (slice $mantle) }}

  94.                       {{ end }}

  95.                       {{ with index ($_.Get $cpPath) "mantle" }}

  96.                         {{ $_.SetInMap $cpPath "mantle" (uniq ((index ($_.Get $cpPath) "mantle") | append $mantle)) }}

  97.                       {{ else }}

  98.                         {{ $_.SetInMap $cpPath "mantle" (slice $mantle) }}

  99.                       {{ end }}

  100.                     {{ end }}

  101. 

  102.                     {{ with $_.Get $gpPath }}

  103.                       {{ if .has_children }}

  104.                         {{ $hasChildren := index . "has_children" | append $cp }}

  105.                         {{ $_.SetInMap $gpPath "has_children" (uniq $hasChildren) }}

  106.                       {{ else }}

  107.                         {{ $_.SetInMap $gpPath "has_children" (slice $cp) }}

  108.                       {{ end }}

  109.                     {{ end }}

  110. 

  111.                     {{ $_.SetInMap $cpPath "depth" "mantle" }}

  112.                     {{ $_.SetInMap $cpPath "child_depth" "crust" }}

  113.                     {{ $_.SetInMap $cpPath "plural" $plur }}

  114.                     {{ $_.SetInMap $cpPath "has" $scp }}

  115. 

  116.                     {{ if isset $cp.Params $kcp }}

  117.                       {{ $_.SetInMap $cpPath "has_children" (slice) }}

  118.                       {{ with index ($_.Get $cpPath) "is_in" }}

  119.                         {{ $isincore := index ($_.Get $cpPath) "is_in" | append $gp}}

  120.                         {{ $_.SetInMap $cpPath "is_in" (uniq $isincore) }}

  121.                       {{ else }}

  122.                         {{ $_.SetInMap $cpPath "is_in" (slice $gp) }}

  123.                       {{ end }}

  124.                     {{ end }}

  125. 

  126.                     {{ range index $cp.Params $kcp }}

  127.                       {{ $gcp := $.GetPage (printf "/%s/%s" $sincp .) }}

  128.                       {{ $gcpPath := printf "/%s" $gcp.File }}

  129. 

  130.                       {{ with $_.Get $cpPath }}

  131.                         {{ if .has_children }}

  132.                           {{ $hasGChildren := index . "has_children" | append $gcp }}

  133.                           {{ $_.SetInMap $cpPath "has_children" (uniq $hasGChildren) }}

  134.                         {{ else }}

  135.                           {{ $_.SetInMap $cpPath "has_children" (slice $gcp) }}

  136.                         {{ end }}

  137.                       {{ end }}

  138. 

  139.                       {{ $_.SetInMap $gcpPath "depth" "crust" }}

  140.                       {{ $_.SetInMap $gcpPath "plural" $plurcp }}

  141.                       {{ $_.SetInMap $gcpPath "in" (slice $sin $plur) }}

  142. 

  143.                       {{ with $gp.File }}

  144.                         {{ $core := substr .Dir 0 -1 }}

  145.                         {{ with index ($_.Get $gcpPath) "core" }}

  146.                           {{ $_.SetInMap $gcpPath "core" (uniq ((index ($_.Get $gcpPath) "core") | append $core)) }}

  147.                         {{ else }}

  148.                           {{ $_.SetInMap $gcpPath "core" (slice $core) }}

  149.                         {{ end }}

  150.                       {{ end }}

  151. 

  152.                       {{ with $cp.File }}

  153.                         {{ $mantle := substr .Dir 0 -1 }}

  154.                         {{ with index ($_.Get $gcpPath) "mantle" }}

  155.                           {{ $_.SetInMap $gcpPath "mantle" (uniq ((index ($_.Get $gcpPath) "mantle") | append $mantle)) }}

  156.                         {{ else }}

  157.                           {{ $_.SetInMap $gcpPath "mantle" (slice $mantle) }}

  158.                         {{ end }}

  159.                       {{ end }}

  160. 

  161.                       {{ with $gcp.File }}

  162.                         {{ $crust := substr .Dir 0 -1 }}

  163.                         {{ with index ($_.Get $gpPath) "crust" }}

  164.                           {{ $_.SetInMap $gpPath "crust" (uniq ((index ($_.Get $gpPath) "crust") | append $crust)) }}

  165.                         {{ else }}

  166.                           {{ $_.SetInMap $gpPath "crust" (slice $crust) }}

  167.                         {{ end }}

  168.                         {{ with index ($_.Get $cpPath) "crust" }}

  169.                           {{ $_.SetInMap $cpPath "crust" (uniq ((index ($_.Get $cpPath) "crust") | append $crust)) }}

  170.                         {{ else }}

  171.                           {{ $_.SetInMap $cpPath "crust" (slice $crust) }}

  172.                         {{ end }}

  173.                         {{ with index ($_.Get $gcpPath) "crust" }}

  174.                           {{ $_.SetInMap $gcpPath "crust" (uniq ((index ($_.Get $gcpPath) "crust") | append $crust)) }}

  175.                         {{ else }}

  176.                           {{ $_.SetInMap $gcpPath "crust" (slice $crust) }}

  177.                         {{ end }}

  178.                       {{ end }}

  179. 

  180.                       {{ with $_.Get $gcpPath }}

  181.                         {{ if .is_in }}

  182.                           {{ $isinmantle := index . "is_in" | append $cp}}

  183.                           {{ $_.SetInMap $gcpPath "is_in" (uniq $isinmantle) }}

  184.                         {{ else }}

  185.                           {{ $_.SetInMap $gcpPath "is_in" (slice $cp) }}

  186.                         {{ end }}

  187.                       {{ end }}

  188.                     {{ end }}

  189.                   {{ end }}

  190.                 {{ end }}

  191.               {{ end }}

  192.             {{ end }}

  193.           {{ end }}

  194.         {{ end }}

  195.       {{ end }}

  196.     {{ end }}

  197.   {{ end }}

  198. 

  199.   {{ $_.SetInMap $pPath "debug" (printf "%#v" $debug) }}

  200. {{ end }}

  201. 

  202. {{ return $_ }}