anatomy 0.1.1

data/lib/anatomy/data.ay

@@ -0,0 +1,147 @@
+use(require("atomy"))
+
+require("set")
+
+data(Block(@content, @style = nil)):
+  Table(@rows)
+  Itemization(@elements)
+  NestedFlow(@blocks)
+  Paragraph(@content, @closed? = false)
+  MetaBlock(@action)
+  TraverseBlock(@action)
+  ResolveBlock(@action)
+  List(@elements):
+    OrderedList(@elements)
+
+data(Element(@content, @style = nil)):
+  Target(@name)
+  TOC(@content)
+  Reference(@tag, @content = nil)
+  Index(@keys, @description)
+  TraverseElement(@action)
+  ResolveElement(@action)
+  CollectElement(@action)
+  RenderElement(@action)
+
+data(Style(@type = nil, @properties = []))
+
+data(Tag(@part, @name, @target = .self, @display = nil))
+
+data(
+  Part(
+    -- nil or title content
+    @title = nil
+
+    -- the part style
+    @style = Style new
+
+    -- initial content before sub-parts
+    @body = []
+
+    -- sub-parts
+    @parts = []
+
+    -- parent part
+    @parent = nil
+
+    -- tags
+    -- tag -> reference
+    @tags = #{}
+    @tag-prefix = nil
+
+    -- tags that cannot be found by parents
+    @local-tags = #{}
+
+    -- the primary tag used for this Part
+    -- used for URIs
+    @tag = nil
+
+    -- content that is inspected during the collect pass,
+    -- but doesn't produce output
+    @to-collect = []
+
+    -- dependent assets
+    @assets = []
+
+    -- css files to add
+    @css-additions = Set new
+
+    -- omit children from table of contents
+    @omit-children-from-table-of-contents? = false))
+
+def(Part set-tag(name, target = .self, display = nil)):
+  @tags[name] = Tag new(self, name, target, display)
+
+def(Part set-local-tag(name, target = nil, display = nil)):
+  @local-tags[name] = Tag new(self, name, target, display)
+
+def(Part toc?): style properties include?(.toc)
+
+def(Part inspect): i"#<Part: '#{@tag name}'>"
+
+-- search in order:
+-- 1. local hidden tags
+-- 2. local tags
+-- 3. children
+--   1. local tags
+--   2. children
+-- 4. parent
+--   1. local hidden tags
+--   2. tags
+--   3. siblings, searching in order
+--   4. parent ...
+def(Part find-tag(tag, excluding = nil)):
+  catch(.found):
+    search-tag-excluding(tag, nil)
+    nil
+
+def(Part search-tag-excluding(name, excluding)): do:
+  when(found = (@local-tags[name] || @tags[name])):
+    throw(.found, found)
+
+  when(name == @title):
+    throw(.found, @tag)
+
+  @parts each [p]:
+    unless(p == excluding):
+      p search-tag(name)
+
+  when(@parent):
+    @parent search-tag-excluding(name, self)
+
+  nil
+
+-- called from find-tag; only search exposed tags and children
+def(Part search-tag(name)): do:
+  when(name == @title):
+    throw(.found, @tag)
+
+  when(found = @tags[name]):
+    throw(.found, found)
+
+  @parts each [p]:
+    p search-tag(name)
+
+
+def(Part top):
+  if(@parent)
+    then: @parent top
+    else: self
+
+def(content?(String)): true
+def(content?(Element)): true
+def(content?(nil)): true
+def(content?(x & Array)): x all? &.content?
+def(content?(_)): false
+
+def(sanitize(x)):
+  contents-of(x) gsub(r" & ", " and ")
+    gsub(r"\s+", "-")
+    gsub(r"[^[:alnum:]_\-:.]", "")
+    downcase
+
+def(contents-of(s & String)): s
+def(contents-of(e & Element)): contents-of(e content)
+def(contents-of(b & Block)): contents-of(b content)
+def(contents-of(a & Array)): a collect [x] { contents-of(x) } join
+def(contents-of(nil)): ""

data/lib/anatomy/html.ay

@@ -0,0 +1,73 @@
+use(require("atomy"))
+
+require("cgi")
+
+
+data(HTMLElement(@name, @attributes = #{}, @body = nil))
+
+fn(attr-to-pair(`.~name)): `(.class -> ~(Atomy Code StringLiteral new(name text to-s)))
+fn(attr-to-pair(`#~name)): `(.id -> ~(Atomy Code StringLiteral new(name text to-s)))
+fn(attr-to-pair(`(~x = ~y))): `(.~x -> ~y)
+
+macro(<(~name)(~*attrs): ~*body):
+  `(HTMLElement new(
+      .~name
+      #{ ~*(attrs collect [a]: attr-to-pair(a)) }
+      [~*body]))
+
+macro(<(~name): ~*body):
+  `(HTMLElement new(.~name, #{}, [~*body]))
+
+macro(<(~name)(~*attrs)):
+  `(HTMLElement new(
+      .~name
+      #{ ~*(attrs collect [a]: attr-to-pair(a)) }
+      nil))
+
+macro(<~name):
+  `(HTMLElement new(.~name))
+
+data(UnescapedString(@raw))
+
+def(UnescapedString to-s): @raw
+
+fn(render(out, x & Array)):
+  x collect [y]: render(out, y)
+fn(render(out, x & String)):
+  out << CGI escapeHTML(x)
+fn(render(out, x)):
+  out << x to-s
+
+stripped? = dynamic(false)
+
+def(HTMLElement to-s):
+  out = ""
+
+  when(^stripped?):
+    render(out, @body)
+    return(out)
+
+  out << i"<#{@name}"
+
+  @attributes each [k, v]:
+    out << i" #{k}=\"#{v}\""
+
+  unless(@body):
+    out << " />"
+    return(out)
+
+  out << ">"
+
+  render(out, @body)
+
+  out << i"</#{@name}>"
+
+  out
+
+data(StrippedTags(@body))
+
+def(StrippedTags to-s):
+  with(stripped? = true):
+    out = ""
+    render(out, @body)
+    out

data/lib/anatomy/language/parser.ay

@@ -0,0 +1,130 @@
+use(require("atomy"))
+use(require("grammar"))
+
+parser(Parser):
+  %%:
+    def(trim-leading(str, n)):
+      unless(n > 0):
+        return(str)
+
+      str gsub!(r"\n {0,#{n}}", "\n")
+
+    def(word(l, x)):
+      w = Atomy Grammar AST Word new(x)
+      w line = l
+      w
+
+  %atomy = Atomy Grammar
+
+  rule(line): { current-line }
+  rule(column): { current-column }
+
+  rule(comment): "{-" in-multi
+
+  rule(in-multi): [
+    /"[^\-\{\}]*"/ "-}"
+    /"[^\-\{\}]*"/ "{-" in-multi /"[^\-\{\}]*"/ "-}"
+    /"[^\-\{\}]*"/ /"[-{}]"/ in-multi
+  ]
+
+  rule(content(s)): comment? c=(chunk(s) | escaped) comment? { c }
+
+  rule(insignificant): (<(/"[^\\\{\}]+"/)> | "\\" <(/"[\\\{\}]"/)>) {
+    text
+  }
+
+  rule(chunk(s)): [
+    l=(line) chunk=(insignificant+) c=((&"}" | comment)?) {
+      text = chunk join
+
+      when(c):
+        text rstrip!
+
+      trim-leading(text, s)
+
+      Atomy Grammar AST StringLiteral new(text)
+    }
+
+    nested
+  ]
+
+  rule(escaped): [
+    l=(line) "\\" n=(%atomy(identifier)) as=(argument+) {
+      `((~word(l, n))(~*as))
+    }
+
+    l=(line) "\\" n=(%atomy(identifier)) { word(l, n) }
+
+    l=(line) "\\" "(" e=(%atomy(expression)) ")" { e }
+  ]
+
+  rule(leading): [
+    &(/"\n+"/ b=(column) /"\s+"/ a=(column)) { a - b }
+    { 0 }
+  ]
+
+  rule(nested):
+    l=(line) "{" s=(leading) cs=(content(s)*) "}" {
+      when(cs[0] is-a?(Atomy Grammar AST StringLiteral)):
+        cs[0] value sub!(r"^\n", "")
+
+      cs match:
+        []: Atomy Grammar AST StringLiteral new("")
+        [x]: x
+        _: `[~*cs]
+    }
+
+  rule(atomy): "[" e=(%atomy(expression)) "]" { e }
+
+  rule(argument): nested | atomy
+
+  rule(root):
+    l=(line) cs=(content(0)*) !_ {
+      setup = Array[]
+      definitions = Array[]
+
+      filter = [c]:
+        c match:
+          (`use(~_) | `require(~_)):
+            setup << c
+            'nil
+
+          `(def(~x): ~*y):
+            definitions << c
+            'nil
+
+          `let(~x, ~y):
+            definitions << `(~x = ~y)
+            'nil
+
+          `[~*cs]:
+            `[~*(cs map &filter)]
+
+          _:
+            c
+
+      body = cs map &filter
+
+      Atomy Grammar AST Sequence new([
+        'use(require("atomy"))
+        'use(require("anatomy/base"))
+
+        `(do:
+            ~*setup
+            ~*definitions
+            def(doc): decode(~*body))
+      ])
+    }
+
+
+Parser singleton:
+  def(parse-string(str)):
+    p = new(str)
+    unless(p parse):
+      p raise-error
+
+    p result
+
+  def(parse-file(path)):
+    File open(path, "r") [f]:
+      parse-string(f read)

data/lib/anatomy/processor.ay

@@ -0,0 +1,35 @@
+use(require("atomy"))
+
+require("atomy/codeloader")
+
+pretty = require("pretty")
+
+require("fileutils")
+
+traverse = require("anatomy/stages/traverse")
+collect = require("anatomy/stages/collect")
+resolve = require("anatomy/stages/resolve")
+html = require("anatomy/renderers/html")
+
+def(process(input, renderer, output = ".")):
+  input = File expand-path(input)
+  output = File expand-path(output)
+
+  mod = Atomy CodeLoader require(input)
+
+  part = mod doc
+  traversed = traverse over(part)
+  collected = collect over(traversed)
+  resolved = resolve over(collected)
+
+  unless(Dir exists?(output)):
+    Dir mkdir(output)
+
+  unless(Dir exists?(output + "/public")):
+    Dir mkdir(output + "/public")
+
+  FileUtils cp-r(
+    File expand-path("../../../public", __FILE__) + "/."
+    output + "/public")
+
+  renderer render(resolved, output)

data/lib/anatomy/renderers/html.ay

@@ -0,0 +1,306 @@
+use(require("atomy"))
+use(require("io"))
+use(require("dynamic"))
+
+require("json")
+require("fileutils")
+
+use(require("anatomy/html"))
+data = require("anatomy/data")
+
+
+fn(tag-url(t)):
+  t target match:
+    .anchor(x):
+      url(t part, x)
+
+    .self:
+      url(t part)
+
+    .url(x):
+      x
+
+def(over(i & data Itemization)):
+  i elements collect [name, body]:
+    <dl:
+      [ <dt: over(name)
+        <dd: over(body)
+      ]
+def(over(l & data List)):
+  <ul:
+    l elements collect [body]:
+      <li: over(body)
+def(over(l & data OrderedList)):
+  <ol:
+    l elements collect [body]:
+      <li: over(body)
+def(over(p & data Paragraph)):
+  <p: over(p content)
+def(over(b & data Block)):
+  b style match:
+    .tt:
+      <pre: over(b content)
+
+    .verbatim:
+      <pre(.verbatim): over(b content)
+
+    .class(*classes):
+      <div(class = classes join(" ")): over(b content)
+
+    .header(depth):
+      <"h#{depth}": over(b content)
+
+    .inset:
+      <div(style = "margin: 0 2em 1em"): over(b content)
+
+    .centered:
+      <div(style = "text-align: center"): over(b content)
+
+    .margin-note:
+      <blockquote: over(b content)
+
+    nil:
+      <div: over(b content)
+
+in-reference? = dynamic(false)
+
+def(over(t & data Target)):
+  <a(name = t name): nil
+def(over(p & data Reference)):
+  if(p tag)
+    then:
+      <a(href = tag-url(p tag)):
+        with(in-reference? = true):
+          over(p content)
+    else:
+      <a(.undefined): over(p content)
+def(over(r & data ResolveElement)):
+  error(.did-not-resolve(r))
+def(over(e & data Element)):
+  e style match:
+    .italic:
+      <em: over(e content)
+
+    .bold:
+      <strong: over(e content)
+
+    .tt:
+      <code: over(e content)
+
+    .superscript:
+      <sup: over(e content)
+
+    .subscript:
+      <sub: over(e content)
+
+    .smaller:
+      <span(style = "font-size: 80%"): over(e content)
+
+    .larger:
+      <span(style = "font-size: 120%"): over(e content)
+
+    .strike:
+      <span(style = "text-decoration: line-through"): over(e content)
+
+    .class(*classes):
+      <span(class = classes join(" ")): over(e content)
+
+    .hyperlink(url):
+      <a(href = url): over(e content)
+
+    .image(file):
+      <img(src = file, alt = over(e content))
+
+    .svg(file):
+      <object(data = file, type = "image/svg+xml", width = "100%", height = "100%"):
+        <param(name = "src", value = file)
+
+    .aux:
+      unless(^(in-reference?)):
+        over(e content)
+
+def(over(nil)): nil
+def(over(s & String)): s
+def(over(a & Array)):
+  a collect [x]: over(x)
+
+
+def(filename(p)): p tag name + ".html"
+
+
+def(top(p)):
+  condition:
+    (p parent && p parent toc?):
+      p
+
+    p parent:
+      top(p parent)
+
+    otherwise:
+      p
+
+def(url(p, anchor = nil)):
+  condition:
+    (top(p) != p):
+      (url(top(p)) + "#") + (anchor || p tag name)
+
+    anchor:
+      (filename(p) + "#") + anchor
+
+    otherwise:
+      filename(p)
+
+
+def(toc-leaf(part)):
+  <li:
+    <a(href = url(part)):
+      over(part title)
+
+    unless(part omit-children-from-table-of-contents? || part parts empty?):
+      <ol:
+        part parts collect [p]: toc-leaf(p) --&.(Self toc-leaf(_))
+
+
+def(render(part, out = ".")):
+  unless(part parent):
+    tags = search-tags(part) collect [t, d, u]:
+      [t, d to-s, u]
+
+    File open(i"#{out}/public/tags.js", "w") [f]:
+      f write(i"var SEARCH_TAGS = #{tags to-json};")
+
+  class =
+    if(part style properties empty?)
+      then: "normal"
+      else: part style properties collect &.to-s join(" ")
+
+  File open(i"#{out}/#{filename(part)}", "w") [f]:
+    f write("<!DOCTYPE html>")
+    f write(
+      <html {
+        <head:
+          <meta("http-equiv" = "Content-Type", content = "text/html; charset=UTF-8")
+          <title: StrippedTags new(over(part title))
+          <link(type = "text/css", rel = "stylesheet", href = "public/anatomy.css")
+          <link(type = "text/css", rel = "stylesheet", href = "public/highlight.css")
+          <script(type = "text/javascript", src = "public/jquery.js") {}
+          <script(type = "text/javascript", src = "public/jquery.hotkeys.js") {}
+          <script(type = "text/javascript", src = "public/tags.js") {}
+          <script(type = "text/javascript", src = "public/main.js") {}
+
+          all-css-additions(part) collect [addition]:
+            <link(type = "text/css", rel = "stylesheet", href = File basename(addition))
+
+        <body(class = class):
+          <div(#main):
+            <div(#content):
+              render-part(part, out)
+
+          <div(.search):
+            <form(action = "javascript:void(0)"):
+              <input(
+                  type = "text"
+                  placeholder = "Search&hellip;"
+                  autocomplete = "off"
+                  #search)
+
+            <ul(.search-results) {}
+
+          <div(#sidebar):
+            unless(part parts empty?):
+              [ <h4: "On this page:"
+
+                <ol(.toc):
+                  part parts collect [s]: toc-leaf(s)
+              ]
+
+            when(part parent):
+              [ <h4: "Up one level:"
+                <ol(.toc):
+                  toc-leaf(part parent)
+              ]
+
+          when(analytics-id = ENV["ANALYTICS_ID"]):
+            <script: UnescapedString new(i"
+              (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
+              (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
+              m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
+              })(window,document,'script','//www.google-analytics.com/analytics.js','ga');
+
+              ga('create', '#{analytics-id}', 'auto');
+              ga('send', 'pageview');
+            ")
+      })
+
+def(render-part(part, out = ".", depth = 1)):
+  part assets each [a]:
+    FileUtils cp(a, out)
+
+  part css-additions each [a]:
+    FileUtils cp(a, out)
+
+  <div(.section, id = i"section_#{part tag name}"):
+    <"h#{depth}"(.section_header):
+      <a(name = part tag name) {}
+      over(part title)
+
+    over(part body)
+
+    if(part toc?)
+      then:
+        <ol(.toc, #table-of-contents):
+          part parts collect [sub]:
+            render(sub, out)
+            toc-leaf(sub)
+      else:
+        part parts collect [sub]:
+          render-part(sub, out, depth + 1)
+
+
+def(search-tags(p)):
+  tags = [
+    [ data contents-of(p title)
+      <span(.title):
+        <a(href = url(p)):
+          over(p title)
+      url(p)
+    ]
+  ]
+
+  p tags each-key [tag-name]:
+    tag = p find-tag(tag-name)
+    url = tag-url(tag)
+    tags <<
+      [ tag name
+        (tag display && over(tag display)) ||
+          <span(.tag):
+            <code:
+              <a(href = url):
+                tag name
+        url
+      ]
+
+  p parts each [sub]:
+    tags += search-tags(sub) collect [t, d, u]:
+      [ t
+        if(d is-a?(HTMLElement) && (d attributes[.class] == "with_parent"))
+          then: d
+          else:
+            <span(.with-parent):
+              d
+              <span(.parent):
+                " in "
+                <a(href = url(p)):
+                  over(p title)
+        u
+      ]
+
+  tags
+
+def(all-css-additions(p)):
+  assets = p css-additions to-a
+
+  p parts each [sub]:
+    assets += all-css-additions(sub)
+
+  assets