OrgWiki/go-org-orgwiki
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Introduce blorg: MVP static site generator

Browse source 
hugo is nice - but it's huge. I've never built a static site generator before
and thought the world could use one more - it's not like there's already enough
choice out there!

No, but seriously. I love hugo and it has all the bells and whistles and you
should definitely use that and not this. I just like reinventing the wheel to
learn about stuff - and I like the 80/20 rule. This gives like 60% of what I
want already and is tiny fraction of hugo in terms of LOC (hugo without it's
bazillion dependencies is like 80k+ - this is like 500 and very likely won't
ever grow above let's say 5k).

Also org mode is awesome and why not use it as a configuration format as
well. Let's see where this goes. YOLO.
This commit is contained in:
Niklas Fasching 2020-06-26 16:40:32 +02:00
parent 5e50794af0
commit 30dd2794cf
16 changed files with 760 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

83
main.go
View file

@ -12,38 +12,91 @@ import (
"github.com/alecthomas/chroma/formatters/html"
"github.com/alecthomas/chroma/lexers"
"github.com/alecthomas/chroma/styles"
"github.com/niklasfasching/go-org/blorg"
"github.com/niklasfasching/go-org/org"
)
func main() {
log := log.New(os.Stderr, "", 0)
if len(os.Args) < 3 {
log.Println("USAGE: org FILE OUTPUT_FORMAT")
log.Fatal("Supported output formats: org, html, html-chroma")
if len(os.Args) < 2 {
log.Println("USAGE: org COMMAND [ARGS]")
log.Println("- org render FILE OUTPUT_FORMAT")
log.Println(" OUTPUT_FORMAT: org, html, html-chroma")
log.Println("- org blorg init")
log.Println("- org blorg build")
log.Println("- org blorg serve")
os.Exit(1)
}
path := os.Args[1]
switch cmd := strings.ToLower(os.Args[1]); cmd {
case "render":
if len(os.Args) < 4 {
log.Fatal("USAGE: org render FILE OUTPUT_FORMAT")
}
out, err := render(os.Args[2], os.Args[3])
if err != nil {
log.Fatalf("Error: %v", err)
}
fmt.Fprint(os.Stdout, out)
case "blorg":
if err := runBlorg(os.Args[2]); err != nil {
log.Fatalf("Error: %v", err)
}
default:
log.Fatalf("Unsupported command: %s", cmd)
}
}
func runBlorg(cmd string) error {
switch strings.ToLower(cmd) {
case "init":
if _, err := os.Stat(blorg.DefaultConfigFile); !os.IsNotExist(err) {
return err
}
if err := ioutil.WriteFile(blorg.DefaultConfigFile, []byte(blorg.DefaultConfig), os.ModePerm); err != nil {
return err
}
log.Printf("blorg init finished: Wrote ./%s", blorg.DefaultConfigFile)
return nil
case "build":
config, err := blorg.ReadConfig(blorg.DefaultConfigFile)
if err != nil {
return err
}
if err := config.Render(); err != nil {
return err
}
log.Println("blorg build finished")
return nil
case "serve":
config, err := blorg.ReadConfig(blorg.DefaultConfigFile)
if err != nil {
return err
}
return config.Serve()
default:
return fmt.Errorf("Supported commands: init build serve")
}
}
func render(path, format string) (string, error) {
bs, err := ioutil.ReadFile(path)
if err != nil {
log.Fatal(err)
return "", err
}
out, err := "", nil
d := org.New().Parse(bytes.NewReader(bs), path)
switch strings.ToLower(os.Args[2]) {
switch strings.ToLower(format) {
case "org":
out, err = d.Write(org.NewOrgWriter())
return d.Write(org.NewOrgWriter())
case "html":
out, err = d.Write(org.NewHTMLWriter())
return d.Write(org.NewHTMLWriter())
case "html-chroma":
writer := org.NewHTMLWriter()
writer.HighlightCodeBlock = highlightCodeBlock
out, err = d.Write(writer)
return d.Write(writer)
default:
log.Fatal("Unsupported output format")
return "", fmt.Errorf("unsupported output format: %s", format)
}
if err != nil {
log.Fatal(err)
}
fmt.Fprint(os.Stdout, out)
}
func highlightCodeBlock(source, lang string, inline bool) string {