110 lines
2.5 KiB
Go
110 lines
2.5 KiB
Go
// Package goldsmith generates static websites.
|
|
package goldsmith
|
|
|
|
import (
|
|
"fmt"
|
|
"sync"
|
|
)
|
|
|
|
type chainState struct {
|
|
contexts []*Context
|
|
|
|
cache *cache
|
|
filters filterStack
|
|
clean bool
|
|
index int
|
|
|
|
errors []error
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// Goldsmith chainable context.
|
|
type Goldsmith struct {
|
|
state *chainState
|
|
}
|
|
|
|
// Begin starts a chain, reading the files located in the source directory as input.
|
|
func (self *Goldsmith) Begin(sourceDir string) *Goldsmith {
|
|
self.state = new(chainState)
|
|
self.Chain(&fileImporter{sourceDir: sourceDir})
|
|
return self
|
|
}
|
|
|
|
// Cache enables caching in cacheDir for the remainder of the chain.
|
|
func (self *Goldsmith) Cache(cacheDir string) *Goldsmith {
|
|
self.state.cache = &cache{cacheDir}
|
|
return self
|
|
}
|
|
|
|
// Clean enables or disables removal of leftover files in the target directory.
|
|
func (self *Goldsmith) Clean(clean bool) *Goldsmith {
|
|
self.state.clean = clean
|
|
return self
|
|
}
|
|
|
|
// Chain links a plugin instance into the chain.
|
|
func (self *Goldsmith) Chain(plugin Plugin) *Goldsmith {
|
|
context := &Context{
|
|
goldsmith: self,
|
|
plugin: plugin,
|
|
filtersExt: append(filterStack(nil), self.state.filters...),
|
|
index: self.state.index,
|
|
filesOut: make(chan *File),
|
|
}
|
|
|
|
if len(self.state.contexts) > 0 {
|
|
context.filesIn = self.state.contexts[len(self.state.contexts)-1].filesOut
|
|
}
|
|
|
|
self.state.contexts = append(self.state.contexts, context)
|
|
self.state.index++
|
|
|
|
return self
|
|
}
|
|
|
|
// FilterPush pushes a filter instance on the chain's filter stack.
|
|
func (self *Goldsmith) FilterPush(filter Filter) *Goldsmith {
|
|
self.state.filters.push(filter, self.state.index)
|
|
self.state.index++
|
|
return self
|
|
}
|
|
|
|
// FilterPop pops a filter instance from the chain's filter stack.
|
|
func (self *Goldsmith) FilterPop() *Goldsmith {
|
|
self.state.filters.pop()
|
|
self.state.index++
|
|
return self
|
|
}
|
|
|
|
// End stops a chain, writing all recieved files to targetDir as output.
|
|
func (self *Goldsmith) End(targetDir string) []error {
|
|
self.Chain(&fileExporter{targetDir: targetDir, clean: self.state.clean})
|
|
for _, context := range self.state.contexts {
|
|
go context.step()
|
|
}
|
|
|
|
context := self.state.contexts[len(self.state.contexts)-1]
|
|
for range context.filesOut {
|
|
|
|
}
|
|
|
|
errors := self.state.errors
|
|
self.state = nil
|
|
|
|
return errors
|
|
}
|
|
|
|
func (self *Goldsmith) fault(name string, file *File, err error) {
|
|
self.state.mutex.Lock()
|
|
defer self.state.mutex.Unlock()
|
|
|
|
var faultError error
|
|
if file == nil {
|
|
faultError = fmt.Errorf("[%s]: %w", name, err)
|
|
} else {
|
|
faultError = fmt.Errorf("[%s@%v]: %w", name, file, err)
|
|
}
|
|
|
|
self.state.errors = append(self.state.errors, faultError)
|
|
}
|