# Super Saiyan God
> __"This isn't even my final form."__
SSG is a Static Site Generator that is only a Static Site Generator. No resumes here! I'll never work at Amazon, Google, or Microsoft so SSG doesn't include every single thing they've ever made. Just a piece of code that generates static files from templates for websites, and can do it live while you develop said templates.
## Current Features
* Simply converts dirs to other dir.
* Default Go templates, and markdown.
* Watches the dir and reruns the build when there's a change.
* Can also watch a `static/` directory and sync that too.
## Possible Future Features
* Running other generators, like Pandoc for PDFs.
* Linting your templates.
* https://github.com/sourcegraph/go-template-lint
* https://www.djlint.com/docs/languages/golang/
* Code highlighting -- should that prism or something else?
## Installation
You can install it with the latest tool system:
```shell
go get -tool git.learnjsthehardway.com/learn-code-the-hard-way/ssgod
```
After that you have the ability to run the tool inside your project:
```shell
go tool ssgod
````
## Usage
These instructions assume you're running the tool using `go tool` . If not then, I mean, you're a
smart person right? Create a default `ssgod.toml` config:
```shell
go tool ssgod init
```
You can change the config file name with the `--config` option:
```shell
go tool ssgod --config mysite.toml init
```
This option is available for all commands, so if you want to init a different config file then do as
shown above.
The config assumes you have a `public/` as a target, and a `pages/` as source full of templates to
render. You can change this in the config. Once you're ready run:
```shell
go tool ssgod
```
It will render all `pages/**/*.md` and `pages/**/*.html` into the `public/` directory using the
`pages/layout/main.html` as the layout. You can then have it watch your `pages/` templates for
changes and do a sync:
```shell
go tool ssgod watch
```
This will watch the directory and whenever you change something it'll rebuild. It has a 500ms delay
to prevent running the render too often.
## Syncing a `static/` Dir
> __WARNING__: This deletes your target `public/` directory. It's assumed that you _want_ to keep a
> clean public that is only built from other sources. Anything precious in `public/` should be moved
> into `static/` so `ssgod` can faithfully recreate your `public/`.
If you want to have `ssgod` sync a `static` directory then you have to uncomment a line in the
`ssgod.toml` file to enable `sync_dir` as an option:
```toml
views = "pages"
layout = "pages/layouts/main.html"
target = "public"
watch_delay = "500ms"
# comment this out to sync static
sync_dir = "static"
```
In this example I've removed the comment. Once you do that `ssgod` will then __remove your
public/__ directory on each run, but recreate it from the `static/` and `pages/` directory. This
ensures your `public/` is "clean" and doesn't contain any random junk that might mess up your build.
> __NOTE__: This is a valid reason to do this, but the technical reason is that Go's `os.CopyFS`
> will error out when the target file exists. Not sure what kind of Nanny-State bullshit is going
> on over at Google but the only viable solution is to just remove the directory that's the target,
> _or_ make my own `os.CopyFS`...but with Blackjack...and...and Hookers.
After that when you work on the templates it'll sync them over and rebuild your public for you.
