tag.
- Display string
- Kind LinkType
- DestinationUnknown bool
-
- // #...
- Anchor string
- Protocol string
- // How the link address looked originally in source text.
- SrcAddress string
- // How the link display text looked originally in source text. May be empty.
- SrcDisplay string
- // RelativeTo is hypha name to which the link is relative to.
- RelativeTo string
-}
-
-// DoubtExistence sets DestinationUnknown to true if the link is local hypha link.
-func (l *Link) DoubtExistence() {
- if l.Kind == LinkLocalHypha {
- l.DestinationUnknown = true
- }
-}
-
-// Classes returns CSS class string for given link.
-func (l *Link) Classes() string {
- if l.Kind == LinkExternal {
- return fmt.Sprintf("wikilink wikilink_external wikilink_%s", l.Protocol)
- }
- classes := "wikilink wikilink_internal"
- if l.DestinationUnknown {
- classes += " wikilink_new"
- }
- return classes
-}
-
-// Href returns content for the href attrubite for hyperlink. You should always use it.
-func (l *Link) Href() string {
- switch l.Kind {
- case LinkExternal, LinkLocalRoot:
- return l.Address + l.Anchor
- default:
- return "/hypha/" + l.Address + l.Anchor
- }
-}
-
-// ImgSrc returns content for src attribute of img tag. Used with `img{}`.
-func (l *Link) ImgSrc() string {
- switch l.Kind {
- case LinkExternal, LinkLocalRoot:
- return l.Address
- default:
- return "/binary/" + l.Address
- }
-}
-
-// From returns a Link object given these `address` and `display` on relative to given `hyphaName`.
-func From(address, display, hyphaName string) *Link {
- address = strings.TrimSpace(address)
- link := Link{
- SrcAddress: address,
- SrcDisplay: display,
- RelativeTo: hyphaName,
- }
-
- if display == "" {
- link.Display = address
- } else {
- link.Display = strings.TrimSpace(display)
- }
-
- if pos := strings.IndexRune(address, '#'); pos != -1 && pos != 0 {
- link.Anchor = address[pos:]
- address = address[:pos]
- }
-
- switch {
- case strings.ContainsRune(address, ':'):
- pos := strings.IndexRune(address, ':')
- link.Protocol = address[:pos]
- link.Kind = LinkExternal
-
- if display == "" {
- link.Display = address[pos+1:]
- if strings.HasPrefix(link.Display, "//") && len(link.Display) > 2 {
- link.Display = link.Display[2:]
- }
- link.Display += link.Anchor
- }
- link.Address = address
- case strings.HasPrefix(address, "#"):
- link.Kind = LinkLocalHypha
- link.Address = util.CanonicalName(hyphaName)
- link.Anchor = address
- case strings.HasPrefix(address, "/"):
- link.Address = address
- link.Kind = LinkLocalRoot
- case strings.HasPrefix(address, "./"):
- link.Kind = LinkLocalHypha
- link.Address = util.CanonicalName(path.Join(hyphaName, address[2:]))
- case strings.HasPrefix(address, "../"):
- link.Kind = LinkLocalHypha
- link.Address = util.CanonicalName(path.Join(path.Dir(hyphaName), address[3:]))
- default:
- link.Kind = LinkLocalHypha
- link.Address = util.CanonicalName(address)
- }
-
- return &link
-}
diff --git a/main.go b/main.go
index 295c974..33e17f9 100644
--- a/main.go
+++ b/main.go
@@ -2,229 +2,46 @@
//go:generate qtc -dir=assets
//go:generate qtc -dir=views
//go:generate qtc -dir=tree
+// Command mycorrhiza is a program that runs a mycorrhiza wiki.
package main
import (
- "fmt"
- "io/ioutil"
- "log"
- "math/rand"
- "net/http"
- "os"
- "strings"
-
- "github.com/bouncepaw/mycorrhiza/assets"
+ "github.com/bouncepaw/mycorrhiza/cfg"
"github.com/bouncepaw/mycorrhiza/files"
"github.com/bouncepaw/mycorrhiza/history"
"github.com/bouncepaw/mycorrhiza/hyphae"
"github.com/bouncepaw/mycorrhiza/shroom"
"github.com/bouncepaw/mycorrhiza/user"
- "github.com/bouncepaw/mycorrhiza/util"
- "github.com/bouncepaw/mycorrhiza/views"
+ "github.com/bouncepaw/mycorrhiza/web"
+ "log"
+ "net/http"
+ "os"
)
-// WikiDir is a rooted path to the wiki storage directory.
-var WikiDir string
-
-// HttpErr is used by many handlers to signal errors in a compact way.
-func HttpErr(w http.ResponseWriter, status int, name, title, errMsg string) {
- log.Println(errMsg, "for", name)
- w.Header().Set("Content-Type", "text/html;charset=utf-8")
- w.WriteHeader(status)
- fmt.Fprint(
- w,
- base(
- title,
- fmt.Sprintf(
- `%s. Go back to the hypha.
).
-func MatchesHorizontalLine(line string) bool {
- counter := 0
-
- // Check initially that the symbol is "-". If it is not a "-", it is most likely a space or another character.
- // With unicode.IsLetter() we can separate spaces and characters.
- for _, ch := range line {
- if ch == '-' {
- counter++
- continue
- }
- // If we bump into any other character (letter) in the line, it is immediately an incorrect horizontal line.
- // There is no point in counting further, we end the loop.
- if unicode.IsLetter(ch) {
- counter = 0
- break
- }
- }
-
- if counter >= 4 {
- return true
- }
-
- return false
-}
diff --git a/markup/img.go b/markup/img.go
deleted file mode 100644
index b1a59c1..0000000
--- a/markup/img.go
+++ /dev/null
@@ -1,203 +0,0 @@
-package markup
-
-import (
- "fmt"
- "regexp"
- "strings"
-
- "github.com/bouncepaw/mycorrhiza/link"
-)
-
-var imgRe = regexp.MustCompile(`^img\s+{`)
-
-func MatchesImg(line string) bool {
- return imgRe.MatchString(line)
-}
-
-type imgState int
-
-const (
- inRoot imgState = iota
- inName
- inDimensionsW
- inDimensionsH
- inDescription
-)
-
-type Img struct {
- entries []imgEntry
- currEntry imgEntry
- hyphaName string
- state imgState
-}
-
-func (img *Img) pushEntry() {
- if strings.TrimSpace(img.currEntry.path.String()) != "" {
- img.currEntry.srclink = link.From(img.currEntry.path.String(), "", img.hyphaName)
- img.currEntry.srclink.DoubtExistence()
- img.entries = append(img.entries, img.currEntry)
- img.currEntry = imgEntry{}
- img.currEntry.path.Reset()
- }
-}
-
-func (img *Img) Process(line string) (shouldGoBackToNormal bool) {
- stateToProcessor := map[imgState]func(rune) bool{
- inRoot: img.processInRoot,
- inName: img.processInName,
- inDimensionsW: img.processInDimensionsW,
- inDimensionsH: img.processInDimensionsH,
- inDescription: img.processInDescription,
- }
- for _, r := range line {
- if shouldReturnTrue := stateToProcessor[img.state](r); shouldReturnTrue {
- return true
- }
- }
- return false
-}
-
-func (img *Img) processInDescription(r rune) (shouldReturnTrue bool) {
- switch r {
- case '}':
- img.state = inName
- default:
- img.currEntry.desc.WriteRune(r)
- }
- return false
-}
-
-func (img *Img) processInRoot(r rune) (shouldReturnTrue bool) {
- switch r {
- case '}':
- img.pushEntry()
- return true
- case '\n', '\r':
- img.pushEntry()
- case ' ', '\t':
- default:
- img.state = inName
- img.currEntry = imgEntry{}
- img.currEntry.path.Reset()
- img.currEntry.path.WriteRune(r)
- }
- return false
-}
-
-func (img *Img) processInName(r rune) (shouldReturnTrue bool) {
- switch r {
- case '}':
- img.pushEntry()
- return true
- case '|':
- img.state = inDimensionsW
- case '{':
- img.state = inDescription
- case '\n', '\r':
- img.pushEntry()
- img.state = inRoot
- default:
- img.currEntry.path.WriteRune(r)
- }
- return false
-}
-
-func (img *Img) processInDimensionsW(r rune) (shouldReturnTrue bool) {
- switch r {
- case '}':
- img.pushEntry()
- return true
- case '*':
- img.state = inDimensionsH
- case ' ', '\t', '\n':
- case '{':
- img.state = inDescription
- default:
- img.currEntry.sizeW.WriteRune(r)
- }
- return false
-}
-
-func (img *Img) processInDimensionsH(r rune) (shouldGoBackToNormal bool) {
- switch r {
- case '}':
- img.pushEntry()
- return true
- case ' ', '\t', '\n':
- case '{':
- img.state = inDescription
- default:
- img.currEntry.sizeH.WriteRune(r)
- }
- return false
-}
-
-func ImgFromFirstLine(line, hyphaName string) (img *Img, shouldGoBackToNormal bool) {
- img = &Img{
- hyphaName: hyphaName,
- entries: make([]imgEntry, 0),
- }
- line = line[strings.IndexRune(line, '{')+1:]
- return img, img.Process(line)
-}
-
-func (img *Img) pagePathFor(path string) string {
- path = strings.TrimSpace(path)
- if strings.IndexRune(path, ':') != -1 || strings.IndexRune(path, '/') == 0 {
- return path
- } else {
- return "/page/" + xclCanonicalName(img.hyphaName, path)
- }
-}
-
-func parseDimensions(dimensions string) (sizeW, sizeH string) {
- xIndex := strings.IndexRune(dimensions, '*')
- if xIndex == -1 { // If no x in dimensions
- sizeW = strings.TrimSpace(dimensions)
- } else {
- sizeW = strings.TrimSpace(dimensions[:xIndex])
- sizeH = strings.TrimSpace(strings.TrimPrefix(dimensions, dimensions[:xIndex+1]))
- }
- return
-}
-
-func (img *Img) markExistenceOfSrcLinks() {
- HyphaIterate(func(hn string) {
- for _, entry := range img.entries {
- if hn == entry.srclink.Address {
- entry.srclink.DestinationUnknown = false
- }
- }
- })
-}
-
-func (img *Img) ToHtml() (html string) {
- img.markExistenceOfSrcLinks()
- isOneImageOnly := len(img.entries) == 1 && img.entries[0].desc.Len() == 0
- if isOneImageOnly {
- html += ``
- } else {
- html += ``
- }
-
- for _, entry := range img.entries {
- html += ``
- if entry.srclink.DestinationUnknown {
- html += fmt.Sprintf(
- `Hypha %s does not exist `,
- entry.srclink.Classes(),
- entry.srclink.Href(),
- entry.srclink.Address)
- } else {
- html += fmt.Sprintf(
- ` `
- }
- return html + ` `
-}
diff --git a/markup/img_entry.go b/markup/img_entry.go
deleted file mode 100644
index acba2fd..0000000
--- a/markup/img_entry.go
+++ /dev/null
@@ -1,45 +0,0 @@
-package markup
-
-import (
- "strings"
-
- "github.com/bouncepaw/mycorrhiza/link"
-)
-
-type imgEntry struct {
- srclink *link.Link
- path strings.Builder
- sizeW strings.Builder
- sizeH strings.Builder
- desc strings.Builder
-}
-
-func (entry *imgEntry) descriptionAsHtml(hyphaName string) (html string) {
- if entry.desc.Len() == 0 {
- return ""
- }
- lines := strings.Split(entry.desc.String(), "\n")
- for _, line := range lines {
- if line = strings.TrimSpace(line); line != "" {
- if html != "" {
- html += `` + html + ` `
-}
-
-func (entry *imgEntry) sizeWAsAttr() string {
- if entry.sizeW.Len() == 0 {
- return ""
- }
- return ` width="` + entry.sizeW.String() + `"`
-}
-
-func (entry *imgEntry) sizeHAsAttr() string {
- if entry.sizeH.Len() == 0 {
- return ""
- }
- return ` height="` + entry.sizeH.String() + `"`
-}
diff --git a/markup/lexer.go b/markup/lexer.go
deleted file mode 100644
index 4a73007..0000000
--- a/markup/lexer.go
+++ /dev/null
@@ -1,229 +0,0 @@
-package markup
-
-import (
- "fmt"
- "html"
- "strings"
-
- "github.com/bouncepaw/mycorrhiza/util"
-)
-
-// HyphaExists holds function that checks that a hypha is present.
-var HyphaExists func(string) bool
-
-//
-var HyphaImageForOG func(string) string
-
-// HyphaAccess holds function that accesses a hypha by its name.
-var HyphaAccess func(string) (rawText, binaryHtml string, err error)
-
-// HyphaIterate is a function that iterates all hypha names existing.
-var HyphaIterate func(func(string))
-
-// GemLexerState is used by markup parser to remember what is going on.
-type GemLexerState struct {
- // Name of hypha being parsed
- name string
- where string // "", "list", "pre"
- // Line id
- id int
- buf string
- // Temporaries
- img *Img
- table *Table
- list *List
-}
-
-type Line struct {
- id int
- // interface{} may be bad. TODO: a proper type
- contents interface{}
-}
-
-func (md *MycoDoc) lex() (ast []Line) {
- var state = GemLexerState{name: md.hyphaName}
-
- for _, line := range append(strings.Split(md.contents, "\n"), "") {
- lineToAST(line, &state, &ast)
- }
- return ast
-}
-
-// Lex `line` in markup and save it to `ast` using `state`.
-func lineToAST(line string, state *GemLexerState, ast *[]Line) {
- addLine := func(text interface{}) {
- *ast = append(*ast, Line{id: state.id, contents: text})
- }
- addParagraphIfNeeded := func() {
- if state.where == "p" {
- state.where = ""
- addLine(fmt.Sprintf("%s
", state.id, strings.ReplaceAll(ParagraphToHtml(state.name, state.buf), "\n", "%s `, i, state.id, ParagraphToHtml(state.name, line[i+1:]), id, id, i))
- }
-
- // Beware! Usage of goto. Some may say it is considered evil but in this case it helped to make a better-structured code.
- switch state.where {
- case "img":
- goto imgState
- case "table":
- goto tableState
- case "list":
- goto listState
- case "pre":
- goto preformattedState
- case "launchpad":
- goto launchpadState
- default: // "p" or ""
- goto normalState
- }
-
-imgState:
- if shouldGoBackToNormal := state.img.Process(line); shouldGoBackToNormal {
- state.where = ""
- addLine(*state.img)
- }
- return
-
-tableState:
- if shouldGoBackToNormal := state.table.Process(line); shouldGoBackToNormal {
- state.where = ""
- addLine(*state.table)
- }
- return
-
-listState:
- if done := state.list.Parse(line); done {
- state.list.Finalize()
- state.where = ""
- goto normalState
- }
- return
-
-preformattedState:
- switch {
- case startsWith("```"):
- state.where = ""
- state.buf = strings.TrimSuffix(state.buf, "\n")
- addLine(state.buf + "")
- state.buf = ""
- default:
- state.buf += html.EscapeString(line) + "\n"
- }
- return
-
-launchpadState:
- switch {
- case startsWith("=>"):
- href, text, class := Rocketlink(line, state.name)
- state.buf += fmt.Sprintf(` %s ", state.id, strings.TrimPrefix(line, "```"))
- default:
- state.where = ""
- addLine(state.buf + "")
- goto normalState
- }
- return
-
-normalState:
- state.id++
- switch {
-
- case startsWith("```"):
- addParagraphIfNeeded()
- state.where = "pre"
- state.buf = fmt.Sprintf("", state.id, strings.TrimPrefix(line, "```"))
-
- case startsWith("###### "):
- addParagraphIfNeeded()
- addHeading(6)
- case startsWith("##### "):
- addParagraphIfNeeded()
- addHeading(5)
- case startsWith("#### "):
- addParagraphIfNeeded()
- addHeading(4)
- case startsWith("### "):
- addParagraphIfNeeded()
- addHeading(3)
- case startsWith("## "):
- addParagraphIfNeeded()
- addHeading(2)
- case startsWith("# "):
- addParagraphIfNeeded()
- addHeading(1)
-
- case startsWith(">"):
- addParagraphIfNeeded()
- addLine(
- fmt.Sprintf(
- "%s ",
- state.id,
- ParagraphToHtml(state.name, remover(">")(line)),
- ),
- )
- case startsWith("=>"):
- addParagraphIfNeeded()
- state.where = "launchpad"
- state.buf = fmt.Sprintf("\n", state.id)
- goto launchpadState
-
- case startsWith("<="):
- addParagraphIfNeeded()
- addLine(parseTransclusion(line, state.name))
- case MatchesHorizontalLine(line):
- addParagraphIfNeeded()
- *ast = append(*ast, Line{id: -1, contents: " have based on mycomarkup's addr, display and hypha name.
-//
-// => addr display
-// [[addr|display]]
-// TODO: deprecate
-func LinkParts(addr, display, hyphaName string) (href, text, class string) {
- l := link.From(addr, display, hyphaName)
- if l.Kind == link.LinkLocalHypha && !HyphaExists(l.Address) {
- l.DestinationUnknown = true
- }
- return l.Href(), l.Display, l.Classes()
-}
-
-// Parse markup line starting with "=>" according to wikilink rules.
-// See http://localhost:1737/page/wikilink
-func Rocketlink(src, hyphaName string) (href, text, class string) {
- src = strings.TrimSpace(src[2:]) // Drop =>
- if src == "" {
- return
- }
- // Href is text after => till first whitespace
- addr := strings.Fields(src)[0]
- display := strings.TrimPrefix(src, addr)
- return LinkParts(addr, display, hyphaName)
-}
diff --git a/markup/list.go b/markup/list.go
deleted file mode 100644
index 81b1d1c..0000000
--- a/markup/list.go
+++ /dev/null
@@ -1,171 +0,0 @@
-package markup
-
-import (
- "errors"
- "strings"
-)
-
-func parseListItem(line string) (level int, offset int, ordered bool, err error) {
- for line[level] == '*' {
- level++
- }
-
- if line[level] == '.' {
- ordered = true
- offset = level + 2
- } else {
- ordered = false
- offset = level + 1
- }
-
- if line[offset-1] != ' ' || len(line) < offset+2 || level < 1 || level > 6 {
- err = errors.New("ill-formatted list item")
- }
- return
-}
-
-func MatchesList(line string) bool {
- level, _, _, err := parseListItem(line)
- return err == nil && level == 1
-}
-
-type listItem struct {
- content string
- parent *listItem
- children []*listItem
- depth int
-}
-
-func newListItem(parent *listItem) *listItem {
- depth := 0
- if parent != nil {
- depth = parent.depth + 1
- }
- return &listItem{
- parent: parent,
- children: make([]*listItem, 0),
- depth: depth,
- }
-}
-
-func (item *listItem) renderAsHtmlTo(b *strings.Builder, hyphaName string, ordered bool) {
- if len(item.content) > 0 {
- b.WriteString("")
- b.WriteString(ParagraphToHtml(hyphaName, item.content))
- }
-
- if len(item.children) > 0 {
- if ordered {
- b.WriteString("")
- } else {
- b.WriteString("")
- }
-
- for _, child := range item.children {
- child.renderAsHtmlTo(b, hyphaName, ordered)
- }
-
- if ordered {
- b.WriteString(" ")
- } else {
- b.WriteString(" ")
- }
- }
-
- if len(item.content) > 0 {
- b.WriteString("