anatomy 0.1.1

data/lib/anatomy/ruby.ay

@@ -0,0 +1,178 @@
+use("atomy")
+
+require("stringio")
+
+hl = require("hl")
+token = require("hl/token")
+ruby = hl load("ruby")
+
+use("anatomy/html")
+base = require("anatomy/base")
+data = require("anatomy/data")
+
+def = require("define")
+
+
+fn(format-inline(tokens, link-only = nil)):
+  tokens collect [t]:
+    data Element new(
+      -- constants, identifiers, and operators
+      if((link-only && link-only include?(t contents)) ||
+          (!link-only && ["no", "nf", "n", "o"] include?(t type tag)))
+        then:
+          data ResolveElement new(
+            [part]:
+              tag = part find-tag(t contents)
+              if(tag)
+                then: data Reference new(tag, t contents)
+                else: t contents)
+        else: t contents
+      .class(t type tag))
+
+
+fn(format-block(tokens, link-only = nil)):
+  data Block new(
+    base verbatim(format-inline(tokens, link-only))
+    .class("highlight"))
+
+
+fn(with-all-output-to(out, err) &action):
+  before-out = $stdout
+  before-err = $stderr
+
+  { $stdout = out
+    $stderr = err
+
+    action call
+  } ensuring:
+    $stdout = before-out
+    $stderr = before-err
+
+
+fn(interactive-line(bnd, input, line, context)):
+  out = StringIO new
+  err = StringIO new
+
+  output-tokens =
+    with-restarts(use-tokens(ts): ts) {
+      res =
+        with-all-output-to(out, err):
+          bnd eval(input)
+
+      -- shorten the long-form inspections that show the ivars
+      ruby lex(res inspect sub(r"#<([^\s]+)\s+@.*$", "#<\\1>"))
+    } bind:
+      (e & Error):
+        restart(
+          .use-tokens
+          [ token Token new(
+              token Tagged new(.gr)
+              i"#{e name}: #{e message}")
+          ])
+
+  [ format-inline(
+      token Token new(token Tagged new(.caret), "> ") .
+        ruby lex(input))
+    "\n"
+    out string
+    unless(err string empty?):
+      data Element new(err string, .class("gr"))
+    format-inline(output-tokens)
+    "\n"
+  ]
+
+
+environments = #{}
+fn(new-interaction-env): binding
+fn(take-environment(name)):
+  if(name)
+    then:
+      environments[name] ||= new-interaction-env
+    else:
+      new-interaction-env
+
+
+def(hl(x)): base code(format-inline(ruby new(x) run))
+
+def(ruby(x)): format-block(ruby new(x) run)
+
+
+def(evaluate(code, where = nil)):
+  with-restarts(err(msg): data Element new(msg, .class("gr"))) {
+    take-environment(where) eval(code)
+    nil
+  } bind:
+    (e & Error):
+      /restart(.err, i"#{e name}: #{e message}")
+
+
+def(interaction(x, where = nil)):
+  bnd = take-environment(where)
+
+  data Block new(
+    data Block new(
+      x split("\n") collect with-index [input, line]:
+        interactive-line(bnd, input, line + 1, where)
+      .tt)
+    .class("interaction"))
+
+
+def(example(x, where = nil)):
+  data Block new(
+    [ data Paragraph new([data Element new("Example:", .italic)])
+      interaction(x, where)
+    ]
+    .class("example"))
+
+
+def(example-segment(x)):
+  data Block new(
+    [ data Paragraph new([data Element new("Example:", .italic)])
+      format-block(ruby new(x) run)
+    ]
+    .class("example"))
+
+
+def(define(what, *rules, returns, body)):
+  thumb = what to-ast
+
+  message-name = thumb name to-s
+
+  display = format-inline(ruby lex(what), [message-name])
+  data Block new(
+    [ base target-element(message-name)
+      data Block new(
+        [ data Block new(
+            [ display
+              data Element new(
+                " => "
+                .class("definition_result_arrow"))
+              format-inline(ruby lex(returns))
+              rules collect [rule]:
+                ["\n  | ", format-inline(ruby lex(rule))]
+            ]
+            .tt)
+        ]
+        .class("thumb"))
+      body
+    ]
+    .class("definition"))
+
+def(assign(name, to, body)):
+  display = format-inline(ruby lex(name), [name])
+  data Block new(
+    [ base target-element(name)
+      data Block new(
+        [ data Block new(
+            [ display
+              data Element new(
+                " = "
+                .class("definition_result_arrow"))
+              format-inline(ruby lex(to))
+            ]
+            .tt)
+        ]
+        .class("thumb"))
+      body
+    ]
+    .class("definition", "assign"))

data/lib/anatomy/server.ay

@@ -0,0 +1,80 @@
+use(require("atomy"))
+
+require("webrick")
+
+-- shim in svg content-type support
+WEBrick HTTPUtils DefaultMimeTypes["svg"] = "image/svg+xml"
+
+class(Server):
+  def(initialize(@source, @destination, @processor, @renderer)):
+    @mutex = Mutex new
+
+def(Server serve(port)):
+  server = WEBrick HTTPServer new(#{.Port -> port})
+
+  server mount-proc("/") [req, res]:
+    relative-path = req path sub(r"^\/", "")
+    local-abs-path = File absolute-path(relative-path, @destination)
+
+    if(relative-path == "favicon.ico")
+      then: respond-to-favicon(res)
+      else: respond-to-path(res, relative-path, local-abs-path)
+
+  trap("INT"): server shutdown
+
+  server start
+
+def(Server respond-to-favicon(res)):
+  res status = 404
+
+def(Server respond-to-path(res, relative-path, local-abs-path)):
+  do {
+    rebuild-if-needed 
+
+    if(File directory?(local-abs-path))
+      then: respond-to-file(res, File join(local-abs-path, "index.html"))
+      else: respond-to-file(res, local-abs-path)
+  } rescue:
+    e:
+      message = i"#{e to-s}\n#{Rubinius Backtrace backtrace(e locations) show}"
+      puts(message)
+      respond-with-error(res, message)
+
+def(Server respond-with-error(res, message)):
+  res content-type = "text/html"
+  res body = i"<pre>#{message}</pre>"
+
+def(Server respond-to-file(res, local-abs-path)):
+  res body = File read(local-abs-path)
+  res content-type = guess-content-type(local-abs-path)
+
+def(Server guess-content-type(path)):
+  extension = File extname(path) sub(r"^\.", "")
+  WEBrick HTTPUtils DefaultMimeTypes fetch(extension):
+    "application/octet-stream"
+
+def(Server rebuild-if-needed):
+  -- Webrick is multi-threaded; guard against concurrent builds
+  @mutex synchronize:
+    when(@last-disk-state == disk-state):
+      return
+
+    puts(i"---------------- rebuilding #{@source}")
+
+    -- clear out already-loaded document modules
+    $LOADED_FEATURES reject! &.end-with?(".any")
+
+    @processor process(@source, @renderer, @destination)
+
+    -- Save disk state after rebuilding, to ignore the built artifacts
+    -- themselves
+    @last-disk-state = disk-state
+
+-- TODO: if this is defined in the class: we get an unknown constant 'Particle'
+def(Server disk-state):
+  -- collect disk state of files surrounding input file
+  Dir glob(File expand-path("../**/*", @source)) collect &.(
+    File absolute-path(_)
+  ) collect [path] {
+    [path, File stat(path) mtime to-s]
+  } sort

data/lib/anatomy/slides.ay

@@ -0,0 +1,48 @@
+use(require("atomy"))
+
+data = require("anatomy/data")
+
+
+def(slides):
+  data MetaBlock new(
+    [part]:
+      part style properties << .slides)
+
+
+def(title-slide(title)):
+  data Block new(
+    data Block new(title, .header(1))
+    .class("slide title_only"))
+
+def(title-slide(title, subtitle)):
+  data Block new(
+    data Block new(
+      [ data Block new(title, .header(1))
+        subtitle
+      ]
+      .class("body"))
+    .class("slide title"))
+
+
+def(slide(title, body)):
+  data Block new(
+    data Block new(
+      [ data Block new(title, .header(2))
+        body
+      ]
+      .class("body"))
+    .class("slide"))
+
+def(detail(title, body)):
+  data Block new(
+    data Block new(
+      [ data Block new(
+          [ title
+            " "
+            data Element new("(cont'd)", .class("continue"))
+          ]
+          .header(2))
+        body
+      ]
+      .class("body"))
+    .class("slide continue"))

data/lib/anatomy/stages/collect.ay

@@ -0,0 +1,35 @@
+-- scan the Part for any tags it defines, attaching them to a copied Part
+-- go into sub-parts and do the same
+
+use(require("atomy"))
+
+data = require("anatomy/data")
+
+
+def(pass(a & Array, part)):
+  a collect [x]: pass(x, part)
+
+def(pass(c & data CollectElement, part)):
+  c action[part]
+
+def(pass(p & data Paragraph, part)):
+  p dup tap [x]:
+    x content = pass(p content, part)
+
+def(pass(nil, _)): nil
+
+def(pass(s & String, _)): s
+
+def(pass(e & data Element, part)):
+  e dup tap [x]:
+    x content = pass(e content, part)
+
+def(pass(b & data Block, part)):
+  b dup tap [x]:
+    x content = pass(b content, part)
+
+
+def(over(part)):
+  part body = pass(part body, part)
+  part parts each [sub]: over(sub)
+  part

data/lib/anatomy/stages/meta.ay

@@ -0,0 +1,100 @@
+-- build paragraphs, set title info, add sub-parts
+
+use(require("atomy"))
+
+data = require("anatomy/data")
+
+
+fn(close-paragraph(body)):
+  when(body last is-a?(data Paragraph)):
+    body last closed? = true
+
+fn(ensure-paragraph(body)):
+  unless(body last is-a?(data Paragraph) && !(body last closed?)):
+    body << data Paragraph new([])
+
+fn(add-content-to(str & String, body)):
+  str split("\n\n", 2) match:
+    [{ chomp empty? }, rest]:
+      close-paragraph(body)
+      add-content-to(rest, body)
+
+    [content, rest]:
+      ensure-paragraph(body)
+      body last content << content
+      close-paragraph(body)
+      add-content-to(rest, body)
+
+    [content]:
+      ensure-paragraph(body)
+      body last content << content
+
+    []:
+      close-paragraph(body)
+
+fn(add-content-to(x, body)):
+  ensure-paragraph(body)
+  body last content << x
+
+
+def(pass(m & data MetaBlock, part, body = part body)):
+  m action[part]
+  nil
+
+def(pass(a & Array, part, body = part body)):
+  a each [x]:
+    pass(x, part, body)
+
+  nil
+
+def(pass(p & data Part, part, body = part body)):
+  part parts << p
+  p parent = part
+  part body freeze
+  nil
+
+def(pass(i & data Itemization, part, body = part body)):
+  unless(body frozen?):
+    body <<
+      i dup tap [x]:
+        x elements collect! [n, b]:
+          body = []
+          pass(b, part, body)
+          [n, body]
+
+def(pass(l & data List, part, body = part body)):
+  unless(body frozen?):
+    body <<
+      l dup tap [x]:
+        x elements collect! [b]:
+          body = []
+          pass(b, part, body)
+          body
+
+def(pass(b & data Block, part, body = part body)):
+  unless(body frozen?):
+    body <<
+      b style match:
+        .tt: b
+
+        .verbatim: b
+
+        .header(_): b
+
+        _:
+          b dup tap [x]:
+            x content = []
+            pass(b content, part, x content)
+
+def(pass(x, part, body = part body)):
+  condition:
+    body frozen?: nil
+
+    data content?(x):
+      add-content-to(x, body)
+
+    otherwise:
+      body << x
+
+def(over(x, part)):
+  pass(x, part, part body)

data/lib/anatomy/stages/resolve.ay

@@ -0,0 +1,55 @@
+use(require("atomy"))
+
+data = require("anatomy/data")
+
+def(pass(a & Array, part)):
+  a collect [x]: pass(x, part)
+
+def(pass(c & data ResolveElement, part)):
+  pass(c action[part], part)
+
+def(pass(x & (data Reference | data Target), part)):
+  x
+
+def(pass(e & data Element, part)):
+  unless(e class == data Element):
+    warning(.did-not-traverse(e class))
+
+  e dup tap [x]:
+    x content = pass(e content, part)
+
+def(pass(i & data Itemization, part)):
+  i dup tap [x]:
+    x elements = i elements collect [name, body]:
+      [ pass(name, part)
+        pass(body, part)
+      ]
+
+def(pass(l & data List, part)):
+  l dup tap [x]:
+    x elements = l elements collect [body]:
+      pass(body, part)
+
+def(pass(p & data Paragraph, part)):
+  p dup tap [x]:
+    x content = pass(p content, part)
+
+def(pass(c & data ResolveBlock, part)):
+  pass(c action[part], part)
+
+def(pass(b & data Block, part)):
+  unless(b class == data Block):
+    warning(.did-not-traverse(b class))
+
+  b dup tap [x]:
+    x content = pass(b content, part)
+
+def(pass(s & String, _)): s
+
+def(pass(nil, _)): nil
+
+
+def(over(part)):
+  part body = pass(part body, part)
+  part parts each [sub]: over(sub)
+  part

data/lib/anatomy/stages/traverse.ay

@@ -0,0 +1,34 @@
+use(require("atomy"))
+
+data = require("anatomy/data")
+
+
+def(pass(a & Array, info)):
+  a collect [x]: pass(x, info)
+
+def(pass(x & (data TraverseBlock | data TraverseElement), info)):
+  new = x action[info]
+
+  when(new != x):
+    signal(.changed)
+
+  new
+
+def(pass(x, _)): x
+
+
+def(over(part)):
+  info = #{}
+
+  changed? = true
+  while(changed?):
+    &changed? = false
+
+    (part body = pass(part body, info)) bind:
+      .changed:
+        &changed? = true
+
+  part parts each [p]:
+    over(p)
+
+  part

data/lib/anatomy.ay

@@ -0,0 +1,4 @@
+use("atomy")
+
+traverse = require("anatomy/stages/traverse")
+collect = require("anatomy/stages/collect")