imbroglio

# imbroglio/compiler This will be the core thing that takes a source file or string and turns it into a browser-side Javascript function-expression. When run, each such function returns a DOM tree. Some functions might act as templates that take arguments. I'm calling this submodule `compiler`, but it's also the runtime environment. Because the runtime environment includes the compiler, obviously. Because it also needs to be able to act as an interpreter. Probably. So what's the language we're compiling? Basically it looks like plain text. With a few things borrowed from or inspired by Markdown. So, for example, `*this*` is emphasized (italicized, or whatever else the stylesheet wants to do with it). Unlike Markdown, `#{this}` is interpolated CoffeeScript code, with the result evaluated at the time the text is displayed and inserted at that point in the document. A paragraph starting with `%do` runs CoffeeScript when the text is displayed and ignores any result. `%say` is like `%do` but treats the result as one or more paragraphs or other block-level elements to insert. I'll add more later, but let me see if I can even get that much working. exports.quote = quote = (s) -> s = s .replace /([\\'])/g, '\\$1' .replace /\n/g, '\\n' .replace /\r/g, '\\r' return "'#{s}'" exports.stdlib = (imbroglio = {}) -> imbroglio.elem or= (tag, attrs = {}, children...) -> result = window.document.createElement tag result.setAttribute k, v for k, v of attrs addChild = (child) => if not child? or child is '' then return if child instanceof Array addChild c for c in child return if not child.cloneNode child = "#{child}" if @state?.smartQuotes child = child .replace /(\s)"/g, '$1\u201c' # ldquo .replace /^"(\w)/g, '\u201c$1' # ldquo .replace '"', '\u201d' # rdquo .replace /(\s)'/g, '$1\u2018' # lsquo .replace /^'(\w)/g, '\u2018$1' # lsquo .replace "'", '\u2019' # rsquo if @state?.smartPunct child = child .replace /\s+--\s+/g, '\u2009\u2014\u2009' # thinsp mdash thinsp .replace /--\s+/g, '\u2014\u2009' # mdash thinsp .replace /\s+--/g, '\u2009\u2014' # thinsp mdash .replace /--/g, '\u2014' # mdash .replace /\.{3}/g, '\u2026' # hellip child = window.document.createTextNode child result.appendChild child return addChild child for child in children result imbroglio assert = require 'assert' CoffeeScript = require 'coffee-script' {Scope} = require 'coffee-script/lib/coffee-script/scope' nodes = require 'coffee-script/lib/coffee-script/nodes' class Compiler constructor: (@opts) -> @referencedVars = [] @scope = new Scope null, null, null, @referencedVars # XXX remove refTokens: (tokens) -> for token in tokens if token.variable @referencedVars.push token[1] return lit: (x) -> new nodes.Literal x val: (x, props...) -> new nodes.Value x, props litval: (x) -> @val @lit x assign: (k, v) -> new nodes.Assign @val(k), v field: (lit, field) -> @val lit, new nodes.Access @lit field string: (s) -> @litval quote s call: (fn, args...) -> for arg in args assert arg.compileToFragments new nodes.Call fn, args callname: (name, args...) -> @call @litval(name), args... block: (children) -> new nodes.Block children ret: (result) -> new nodes.Return result blockret: (result) -> @block [@ret result] wrap: (ast) -> if not @opts.thisVar then return ast @blockret @call(@field(new nodes.Parens(@block [new nodes.Code([], ast)]), 'call'), @litval @opts.thisVar) text: (s) -> @string s obj: (obj) -> attrs = for k, v of obj assert 'string' is typeof v, v new nodes.Assign @string(k), @string(v), 'object' @val new nodes.Obj attrs elem: (tag, attrs = {}, children...) -> @callname 'imbroglio.elem', @string(tag), @obj(attrs), children... main: (result) -> @scope.expressions = @wrap @blockret result return scope: @scope, ast: @scope.expressions, level: 1, indent: '' exports.parse = parse = (src, opts = {}) -> compiler = new Compiler opts codeBegin = '#{' codeEnd = '}' pp = for p in src.split /\n\s*\n/ if not /\S/.test p then continue pieces = [] idx = 0 loop found = p.indexOf codeBegin, idx if found < 0 then found = p.length pieces.push compiler.text p.substring idx, found if found == p.length then break start = found + codeBegin.length end = start - 1 error = true loop end = p.indexOf codeEnd, end + 1 if end < 0 idx = p.length break code = p.substring start, end try tokens = CoffeeScript.tokens code ast = CoffeeScript.nodes tokens catch e error = e continue error = null compiler.refTokens tokens pieces.push ast idx = end + codeEnd.length break if error if opts.handleError then opts.handleError {error} pieces.push compiler.elem 'span', {class: 'error', title: error.toString()}, compiler.text codeBegin idx = start compiler.elem 'p', {}, pieces... return compiler.main compiler.elem 'div', {class: 'passage'}, pp... exports.compile = compile = (src, opts) -> o = parse src, opts # To get a source map, I'll need to use ast.compileToFragments(). # Look at what CoffeeScript.compile() is doing.... fragments = o.ast.compileWithDeclarations o (fragment.code for fragment in fragments).join '' exports.prepare = prepare = (src, opts) -> code = compile src, opts varNames = if not opts.vars then [] else (k for k of opts.vars) argNames = varNames.concat opts.argNames or [] f = new Function argNames..., code if varNames.length f = f.bind null, (opts.vars[k] for k in varNames)... return f exports.render = render = (src, opts) -> prepare(src, opts)()