firefly-compiler 0.5.35 → 0.5.37

package/fireflysite/DocumentParser.ff

@@ -1,332 +1,326 @@
-import WebServer from ff:webserver // This is required to run the file.
-import Guide
-
-nodeMain(system: NodeSystem) {
-
-    function logDuration[T](label: String, body: () => T): T {
-        let started = system.mainTask().elapsed()
-        let result = body()
-        Log.debug(label + ": " + Show.show(Duration(system.mainTask().elapsed().seconds - started.seconds)))
-        result
-    }
-    
-    let file = system.path("assets/markdown/reference/FunctionsAndMethods.md")
-    
-    /*
-    logDuration("parse " + file.base()) {
-        mutable i = 0
-        while {i < 10000} {
-            parse(file)
-            i += 1
-        }
-    } 
-    */   
-    let document = parse(file)
-    printSections(system, document)
-}
-
-
-
-parse(file: Path): List[Section] {
-    let content = file.readText()
-    let lines = content.split('\n')
-    let parser = DocumentParser(file.absolute(), lines, 0)
-    parser.parseDocument()
-}
-
-class DocumentParser(
-    fileName: String
-    lines: List[String]
-    mutable i: Int
-)
-
-extend self: DocumentParser {
-    
-    parseDocument(): List[Section] {
-        iterate {self.parseSection()}
-    }
-    
-    parseSection(): Option[Section] {
-        self.skipWhile {_.trim() == ""}
-        self.first().{
-            | Some(line) {line.trim().removeFirst("#") | Some(heading)} => 
-                self.skip(1)
-                let blocks = iterate {self.parseBlock()}
-                Some(Section(heading.trim(), blocks))
-            | _ => None
-        }
-    }
-    
-    parseBlock(): Option[Block] {
-        self.skipWhile {_.trim() == ""}
-        let first = self.first().map {_.trimStart()}
-        first.{
-            | Some(line) {line.removeFirst("```") | Some(l)} => 
-                self.skip(1)
-                let isFirefly = l.startsWith("firefly")
-                let block = self.parseRemainingCodeBlock(isFirefly)
-                Some(block)
-            | Some(line) {line.removeFirst("* ") | Some(l)} => 
-                self.skip(1)
-                Some(Bullets(self.parseBullets(l)))
-            | Some(line) {line.first().any {_ != '#'}} => 
-                Some(self.parseParagraph())
-            | _ => None
-        }
-    }
-    
-    parseParagraph(): Block {
-        let lines = self.consumeWhile {_.trim() != ""}
-        Paragraph(self.parseInlines(lines))
-    }
-    
-    parseInlines(lines: List[String]): List[Inline] {
-        let parser = InlineParser(self.fileName, lines.join("\n"), 0)
-        let inlines = parser.parseInlines()
-        inlines
-    }
-
-    parseBullets(firstLine: String): List[List[Inline]] {
-        let pair = self.consumeToSome {line =>
-            let trimmed = line.trim()
-            let endWithNextLine = trimmed.{
-                | "" => Some(None)
-                | t {t.removeFirst("* ") | Some(nextLine)} => Some(Some(nextLine))
-                | _ => None
-            }
-            endWithNextLine
-        }
-        let bulletLines = [firstLine, ...pair.first]
-        let bullet = self.parseInlines(bulletLines)
-        pair.second.{
-            | None => [bullet]
-            | Some(None) => [bullet]
-            | Some(Some(nextLine)) => [bullet, ...self.parseBullets(nextLine)]
-        }
-    }
-
-    parseRemainingCodeBlock(isFirefly: Bool): Block {
-        let code = self.consumeWhile {!_.trimStart().startsWith("```")}
-        self.skip(1)
-        CodeBlock(code.join("\n"), isFirefly)
-    } 
-    
-    first(): Option[String] {
-        if(self.i < self.lines.size()) {
-            self.lines.grab(self.i)
-        }
-    }
-    
-    skip(count: Int): Unit {
-        self.i += count
-    }
-    
-    skipWhile(body: String => Bool): Unit {
-        while {self.i < self.lines.size() && body(self.lines.grab(self.i))} {
-            self.i += 1
-        }
-    }
-    
-    consumeWhile(body: String => Bool): List[String] {
-        let oldI = self.i
-        self.skipWhile(body)
-        self.lines.slice(oldI, self.i)
-    }
-
-    consumeToSome[T](body: String => Option[T]): Pair[List[String], Option[T]] {
-        let oldI = self.i
-        mutable end = None
-        while {self.i < self.lines.size() && end.isEmpty()} {
-            end = body(self.lines.grab(self.i))
-            self.i += 1
-        }
-        let endI = if(end.isEmpty()) {self.i} else {self.i - 1}
-        Pair(self.lines.slice(oldI, endI), end)
-    }
-}
-
-class InlineParser(
-    fileName: String
-    line: String
-    mutable i: Int
-)
-
-extend self: InlineParser {
-    
-    parseInlines(): List[Inline] {
-        iterateLists {self.parseInline()}
-    }
-       
-    parseInline(): List[Inline] {
-        mutable inline = []
-        mutable j = 0
-        
-        doWhile {
-            let remaining = self.size() - j
-            if(remaining >= 3) {
-                self.grab(j).{
-                    | '_' => inline = self.parseNextInline(j, {self.parseItalic()})
-                    | '`' => inline = self.parseNextInline(j, {self.parseCode()})
-                    | '[' => inline = self.parseNextInline(j, {self.parseLink()})
-                    | '*' {self.grab(j + 1) == '*'} => inline = self.parseNextInline(j, {self.parseBold()})
-                    | _ =>
-                }
-            }
-            j += 1
-            remaining > 0 && inline.isEmpty()
-        }
-
-        inline.{
-            | [] {j == 1} => []
-            | []  => [Text(self.consume(j - 1))]
-            | inlines => inlines
-        }
-    }     
-    
-    parseNextInline(offset: Int, parseNext: () => Option[Inline]): List[Inline] {
-        if(offset == 0) {parseNext().toList()} else:
-
-        let oldI = self.i
-        self.i += offset
-        parseNext().{
-            | None => 
-                self.i = oldI
-                []
-            | Some(nextInline) => 
-                let text = self.line.slice(oldI, oldI + offset)
-                let textInline = Text(text)
-                [textInline, nextInline]
-        }
-    }
-    
-    parseLink(): Option[Inline] {
-        let oldI = self.i
-        self.parseEnclosed("[", "]").flatMap {text => 
-            self.parseEnclosed("(", ")").{
-                | None => 
-                    self.i = oldI
-                    None
-                | Some(url) => Some(Link(text, url))
-            }
-        }
-    }
-
-    parseBold(): Option[Inline] {
-        self.parseEnclosed("**", "**").map {Bold(_)}
-    }
-
-    parseItalic(): Option[Inline] {
-        self.parseEnclosed("_", "_").map {Italic(_)}
-    }
-    
-    parseCode(): Option[Inline] {
-        self.parseEnclosed("`", "`").map {Code(_)}
-    }
-    
-    parseEnclosed(left: String, right: String): Option[String] {
-        if(self.startsWith(left)) {
-            indexOf(self.line, right, self.i + left.size()).map {end =>
-                let text = self.line.slice(self.i + left.size(), end)
-                self.i = end + right.size()
-                text
-            }
-        }.flatten()
-    }    
-       
-    grab(index: Int): Char {
-        self.line.grab(self.i + index)
-    }
-    
-    size(): Int {
-        self.line.size() - self.i
-    }
-    
-    startsWith(text: String): Bool {
-        self.size() >= text.size() && self.line.slice(self.i, self.i + text.size()) == text
-    }
-    
-    consume(count: Int): String {
-        let text = self.line.slice(self.i, self.i + count)
-        self.i += count
-        text
-    }    
-}
-
-iterate[T](body: () => Option[T]): List[T] {
-    let array = Array.new()
-    doWhile {
-        body().{
-            | None => False
-            | Some(s) =>
-                array.push(s)
-                True
-        }
-    }
-    array.drain()  
-}   
-
-iterateLists[T](body: () => List[T]): List[T] {
-    let array = Array.new()
-    doWhile {
-        body().{
-            | [] => False
-            | list =>
-                array.pushList(list)
-                True
-        }
-    }
-    array.drain()  
-}   
-
-indexOf(string: String, searchString: String, position: Int = 0): Option[Int]
-    target js sync """
-        const i = string_.indexOf(searchString_, position_);
-        return i == -1 ? ff_core_Option.None() : ff_core_Option.Some(i);
-    """
-    
-printSections(system: NodeSystem, sections: List[Section]) {
-    sections.each {
-        | Section(heading, blocks) => 
-            system.writeLine("# " + heading)
-            blocks.each {
-                | Bullets(items) => 
-                    system.writeLine("  Bullets:")
-                    system.writeLine("    " + Show.show(items))
-                | CodeBlock(code, True) => 
-                    system.writeLine("  Code (Firefly):")
-                    system.writeLine("    " + Show.show(code))
-                | CodeBlock(code, False) => 
-                    system.writeLine("  Code:")
-                    system.writeLine("    " + Show.show(code))
-                | Image(url) => 
-                    system.writeLine("  Image:")
-                    system.writeLine("    " + Show.show(url))
-                | LuxDemo(demo) => 
-                    system.writeLine("  Lux:")
-                    system.writeLine("    " + Show.show(demo))
-                | Paragraph(inlines) => 
-                    system.writeLine("  Paragraph:")
-                    inlines.each {
-                        | Anchor(heading, title) => 
-                            system.writeLine("    Anchor: " + Show.show(heading) + ", " + Show.show(title))
-                        | Bold(text) => 
-                            system.writeLine("    Bold: " + Show.show(text))
-                        | Code(code, True) => 
-                            system.writeLine("    Code (firefly): " + Show.show(code))
-                        | Code(code, False) => 
-                            system.writeLine("    Code: " + Show.show(code))
-                        | Italic(text) => 
-                            system.writeLine("    Italic: " + Show.show(text))
-                        | Link(text, url) => 
-                            system.writeLine("    Link: " + Show.show(text) + ", " + Show.show(url))
-                        | Text(text) => 
-                            system.writeLine("    Text: " + Show.show(text))
-                    }
-                | Video(url) => 
-                    system.writeLine("  Video:")
-                    system.writeLine("    " + Show.show(url))
-            }
-        | SplitSection(heading, first, second) => 
-            system.writeLine("SPLIT")
-    }    
+import WebServer from ff:webserver // This is required to run the file.
+import Guide
+
+nodeMain(system: NodeSystem) {
+
+    function logDuration[T](label: String, body: () => T): T {
+        let started = system.mainTask().elapsed()
+        let result = body()
+        Log.debug(label + ": " + Show.show(Duration(system.mainTask().elapsed().seconds - started.seconds)))
+        result
+    }
+    
+    let file = system.path("assets/markdown/reference/FunctionsAndMethods.md")
+    
+    /*
+    logDuration("parse " + file.base()) {
+        mutable i = 0
+        while {i < 10000} {
+            parse(file)
+            i += 1
+        }
+    } 
+    */   
+    let document = parse(file)
+    printSections(system, document)
+}
+
+
+
+parse(file: Path): List[Section] {
+    let content = file.readText()
+    let lines = content.split('\n')
+    let parser = DocumentParser(file.absolute(), lines, 0)
+    parser.parseDocument()
+}
+
+class DocumentParser(
+    fileName: String
+    lines: List[String]
+    mutable i: Int
+)
+
+extend self: DocumentParser {
+    
+    parseDocument(): List[Section] {
+        iterate {self.parseSection()}
+    }
+    
+    parseSection(): Option[Section] {
+        self.skipWhile {_.trim() == ""}
+        self.first().{
+            | Some(line) {line.trim().removeFirst("#") | Some(heading)} => 
+                self.skip(1)
+                let blocks = iterate {self.parseBlock()}
+                Some(Section(heading.trim(), blocks))
+            | _ => None
+        }
+    }
+    
+    parseBlock(): Option[Block] {
+        self.skipWhile {_.trim() == ""}
+        let first = self.first().map {_.trimStart()}
+        first.{
+            | Some(line) {line.removeFirst("```") | Some(l)} => 
+                self.skip(1)
+                let isFirefly = l.startsWith("firefly")
+                let block = self.parseRemainingCodeBlock(isFirefly)
+                Some(block)
+            | Some(line) {line.removeFirst("* ") | Some(l)} => 
+                self.skip(1)
+                Some(Bullets(self.parseBullets(l)))
+            | Some(line) {line.first().any {_ != '#'}} => 
+                Some(self.parseParagraph())
+            | _ => None
+        }
+    }
+    
+    parseParagraph(): Block {
+        let lines = self.consumeWhile {_.trim() != ""}
+        Paragraph(self.parseInlines(lines))
+    }
+    
+    parseInlines(lines: List[String]): List[Inline] {
+        let parser = InlineParser(self.fileName, lines.join("\n"), 0)
+        let inlines = parser.parseInlines()
+        inlines
+    }
+
+    parseBullets(firstLine: String): List[List[Inline]] {
+        let pair = self.consumeToSome {line =>
+            let trimmed = line.trim()
+            let endWithNextLine = trimmed.{
+                | "" => Some(None)
+                | t {t.removeFirst("* ") | Some(nextLine)} => Some(Some(nextLine))
+                | _ => None
+            }
+            endWithNextLine
+        }
+        let bulletLines = [firstLine, ...pair.first]
+        let bullet = self.parseInlines(bulletLines)
+        pair.second.{
+            | None => [bullet]
+            | Some(None) => [bullet]
+            | Some(Some(nextLine)) => [bullet, ...self.parseBullets(nextLine)]
+        }
+    }
+
+    parseRemainingCodeBlock(isFirefly: Bool): Block {
+        let code = self.consumeWhile {!_.trimStart().startsWith("```")}
+        self.skip(1)
+        CodeBlock(code.join("\n"), isFirefly)
+    } 
+    
+    first(): Option[String] {
+        if(self.i < self.lines.size()) {
+            self.lines.grab(self.i)
+        }
+    }
+    
+    skip(count: Int): Unit {
+        self.i += count
+    }
+    
+    skipWhile(body: String => Bool): Unit {
+        while {self.i < self.lines.size() && body(self.lines.grab(self.i))} {
+            self.i += 1
+        }
+    }
+    
+    consumeWhile(body: String => Bool): List[String] {
+        let oldI = self.i
+        self.skipWhile(body)
+        self.lines.slice(oldI, self.i)
+    }
+
+    consumeToSome[T](body: String => Option[T]): Pair[List[String], Option[T]] {
+        let oldI = self.i
+        mutable end = None
+        while {self.i < self.lines.size() && end.isEmpty()} {
+            end = body(self.lines.grab(self.i))
+            self.i += 1
+        }
+        let endI = if(end.isEmpty()) {self.i} else {self.i - 1}
+        Pair(self.lines.slice(oldI, endI), end)
+    }
+}
+
+class InlineParser(
+    fileName: String
+    line: String
+    mutable i: Int
+)
+
+extend self: InlineParser {
+    
+    parseInlines(): List[Inline] {
+        iterateLists {self.parseInline()}
+    }
+       
+    parseInline(): List[Inline] {
+        mutable inline = []
+        mutable j = 0
+        
+        doWhile {
+            let remaining = self.size() - j
+            if(remaining >= 3) {
+                self.grab(j).{
+                    | '_' => inline = self.parseNextInline(j, {self.parseItalic()})
+                    | '`' => inline = self.parseNextInline(j, {self.parseCode()})
+                    | '[' => inline = self.parseNextInline(j, {self.parseLink()})
+                    | '*' {self.grab(j + 1) == '*'} => inline = self.parseNextInline(j, {self.parseBold()})
+                    | _ =>
+                }
+            }
+            j += 1
+            remaining > 0 && inline.isEmpty()
+        }
+
+        inline.{
+            | [] {j == 1} => []
+            | []  => [Text(self.consume(j - 1))]
+            | inlines => inlines
+        }
+    }     
+    
+    parseNextInline(offset: Int, parseNext: () => Option[Inline]): List[Inline] {
+        if(offset == 0) {parseNext().toList()} else:
+
+        let oldI = self.i
+        self.i += offset
+        parseNext().{
+            | None => 
+                self.i = oldI
+                []
+            | Some(nextInline) => 
+                let text = self.line.slice(oldI, oldI + offset)
+                let textInline = Text(text)
+                [textInline, nextInline]
+        }
+    }
+    
+    parseLink(): Option[Inline] {
+        let oldI = self.i
+        self.parseEnclosed("[", "]").flatMap {text => 
+            self.parseEnclosed("(", ")").{
+                | None => 
+                    self.i = oldI
+                    None
+                | Some(url) => Some(Link(text, url))
+            }
+        }
+    }
+
+    parseBold(): Option[Inline] {
+        self.parseEnclosed("**", "**").map {Bold(_)}
+    }
+
+    parseItalic(): Option[Inline] {
+        self.parseEnclosed("_", "_").map {Italic(_)}
+    }
+    
+    parseCode(): Option[Inline] {
+        self.parseEnclosed("`", "`").map {Code(_)}
+    }
+    
+    parseEnclosed(left: String, right: String): Option[String] {
+        if(self.startsWith(left)) {
+            self.line.indexOf(right, self.i + left.size()).map {end =>
+                let text = self.line.slice(self.i + left.size(), end)
+                self.i = end + right.size()
+                text
+            }
+        }.flatten()
+    }    
+       
+    grab(index: Int): Char {
+        self.line.grab(self.i + index)
+    }
+    
+    size(): Int {
+        self.line.size() - self.i
+    }
+    
+    startsWith(text: String): Bool {
+        self.size() >= text.size() && self.line.slice(self.i, self.i + text.size()) == text
+    }
+    
+    consume(count: Int): String {
+        let text = self.line.slice(self.i, self.i + count)
+        self.i += count
+        text
+    }    
+}
+
+iterate[T](body: () => Option[T]): List[T] {
+    let array = Array.new()
+    doWhile {
+        body().{
+            | None => False
+            | Some(s) =>
+                array.push(s)
+                True
+        }
+    }
+    array.drain()  
+}   
+
+iterateLists[T](body: () => List[T]): List[T] {
+    let array = Array.new()
+    doWhile {
+        body().{
+            | [] => False
+            | list =>
+                array.pushList(list)
+                True
+        }
+    }
+    array.drain()  
+}   
+    
+printSections(system: NodeSystem, sections: List[Section]) {
+    sections.each {
+        | Section(heading, blocks) => 
+            system.writeLine("# " + heading)
+            blocks.each {
+                | Bullets(items) => 
+                    system.writeLine("  Bullets:")
+                    system.writeLine("    " + Show.show(items))
+                | CodeBlock(code, True) => 
+                    system.writeLine("  Code (Firefly):")
+                    system.writeLine("    " + Show.show(code))
+                | CodeBlock(code, False) => 
+                    system.writeLine("  Code:")
+                    system.writeLine("    " + Show.show(code))
+                | Image(url) => 
+                    system.writeLine("  Image:")
+                    system.writeLine("    " + Show.show(url))
+                | LuxDemo(demo) => 
+                    system.writeLine("  Lux:")
+                    system.writeLine("    " + Show.show(demo))
+                | Paragraph(inlines) => 
+                    system.writeLine("  Paragraph:")
+                    inlines.each {
+                        | Anchor(heading, title) => 
+                            system.writeLine("    Anchor: " + Show.show(heading) + ", " + Show.show(title))
+                        | Bold(text) => 
+                            system.writeLine("    Bold: " + Show.show(text))
+                        | Code(code, True) => 
+                            system.writeLine("    Code (firefly): " + Show.show(code))
+                        | Code(code, False) => 
+                            system.writeLine("    Code: " + Show.show(code))
+                        | Italic(text) => 
+                            system.writeLine("    Italic: " + Show.show(text))
+                        | Link(text, url) => 
+                            system.writeLine("    Link: " + Show.show(text) + ", " + Show.show(url))
+                        | Text(text) => 
+                            system.writeLine("    Text: " + Show.show(text))
+                    }
+                | Video(url) => 
+                    system.writeLine("  Video:")
+                    system.writeLine("    " + Show.show(url))
+            }
+        | SplitSection(heading, first, second) => 
+            system.writeLine("SPLIT")
+    }    
 }