alex/goldsmith
1
Fork 0
Code Releases Activity

Squashed commit of the following:

Browse Source 
commit 106991bfd59bb95977045399f7b4e5f4e7addc56
Author: Alex Yatskov <alex@foosoft.net>
Date:   Sat Jan 8 11:19:21 2022 -0800

    Rename property functions

commit 07f6033d4e86df257806af16de002ce8fad3d67f
Author: Alex Yatskov <alex@foosoft.net>
Date:   Sat Jan 8 11:16:46 2022 -0800

    Update rewrite

commit ea2dc0b4d223d54832752f0efd3eb46d81d17b50
Author: Alex Yatskov <alex@foosoft.net>
Date:   Fri Jan 7 22:47:17 2022 -0800

    Add more property methods

commit e2f7f8dc7ebc5b668539e8233e323a7c256eced2
Author: Alex Yatskov <alex@foosoft.net>
Date:   Fri Jan 7 22:39:23 2022 -0800

    Add step indexing

commit a7ed2a0b1c95ed9fbb0bbd87c779cf51a92f0b5f
Author: Alex Yatskov <alex@foosoft.net>
Date:   Fri Jan 7 20:50:19 2022 -0800

    Use self

commit 7ecc01e508c06680dcb6b6ecd4265a7f72e2c933
Author: Alex Yatskov <alex@foosoft.net>
Date:   Sun Aug 22 12:33:09 2021 -0700

    Cleanup

commit 87dd28a4c14b88bea061ca913f68e272cca787f9
Author: Alex Yatskov <alex@foosoft.net>
Date:   Sun Aug 22 12:09:41 2021 -0700

    Cleanup

commit 129130128d2a50f119c46f70e7cb70ef421892ff
Merge: 629fce0 e751d70
Author: Alex Yatskov <alex@foosoft.net>
Date:   Sat Aug 21 12:18:09 2021 -0700

    Merge branch 'master' into dev

commit 629fce06a8fca6810ec772f558d9ffabda016d01
Author: Alex Yatskov <alex@foosoft.net>
Date:   Sun Jun 27 19:34:53 2021 -0700

    Abstract metadata
This commit is contained in:
Alex Yatskov 2022-01-08 18:08:36 -08:00
parent e751d70f27
commit e408fa9335
8 changed files with 296 additions and 279 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
cache.go
View File

@ -13,8 +13,8 @@ type cache struct {
baseDir string
}
func (cache *cache) retrieveFile(context *Context, outputPath string, inputFiles []*File) (*File, error) {
cachePath, err := cache.buildCachePath(context, outputPath, inputFiles)
func (self *cache) retrieveFile(context *Context, outputPath string, inputFiles []*File) (*File, error) {
cachePath, err := self.buildCachePath(context, outputPath, inputFiles)
if err != nil {
return nil, err
}
@ -31,13 +31,13 @@ func (cache *cache) retrieveFile(context *Context, outputPath string, inputFiles
return outputFile, nil
}
func (cache *cache) storeFile(context *Context, outputFile *File, inputFiles []*File) error {
cachePath, err := cache.buildCachePath(context, outputFile.Path(), inputFiles)
func (self *cache) storeFile(context *Context, outputFile *File, inputFiles []*File) error {
cachePath, err := self.buildCachePath(context, outputFile.Path(), inputFiles)
if err != nil {
return err
}
if err := os.MkdirAll(cache.baseDir, 0755); err != nil {
if err := os.MkdirAll(self.baseDir, 0755); err != nil {
return err
}
@ -67,28 +67,20 @@ func (cache *cache) storeFile(context *Context, outputFile *File, inputFiles []*
return nil
}
func (cache *cache) buildCachePath(context *Context, outputPath string, inputFiles []*File) (string, error) {
uintBuff := make([]byte, 4)
binary.LittleEndian.PutUint32(uintBuff, context.chainHash)
func (self *cache) buildCachePath(context *Context, outputPath string, inputFiles []*File) (string, error) {
hasher := crc32.NewIEEE()
hasher.Write(uintBuff)
hasher.Write([]byte(outputPath))
sort.Sort(filesByPath(inputFiles))
for _, inputFile := range inputFiles {
fileHash, err := inputFile.hash()
if err != nil {
return "", err
}
binary.LittleEndian.PutUint32(uintBuff, fileHash)
hasher.Write(uintBuff)
modTimeBuff := make([]byte, 8)
binary.LittleEndian.PutUint64(modTimeBuff, uint64(inputFile.ModTime().UnixNano()))
hasher.Write([]byte(inputFile.Path()))
hasher.Write(modTimeBuff)
}
cachePath := filepath.Join(cache.baseDir, fmt.Sprintf(
cachePath := filepath.Join(self.baseDir, fmt.Sprintf(
"gs_%.8x%s",
hasher.Sum32(),
filepath.Ext(outputPath),

105
context.go
View File

@ -3,6 +3,8 @@ package goldsmith
import (
"bytes"
"errors"
"io"
"io/ioutil"
"os"
"runtime"
"sync"
@ -15,30 +17,38 @@ type Context struct {
goldsmith *Goldsmith
plugin Plugin
chainHash uint32
filtersExt filterStack
filtersInt filterStack
threads int
index int
filesIn chan *File
filesOut chan *File
}
// CreateFileFrom data creates a new file instance from the provided data buffer.
func (*Context) CreateFileFromData(sourcePath string, data []byte) *File {
return &File{
sourcePath: sourcePath,
Meta: make(map[string]interface{}),
reader: bytes.NewReader(data),
size: int64(len(data)),
modTime: time.Now(),
func (self *Context) CreateFileFromReader(sourcePath string, reader io.Reader) (*File, error) {
data, err := ioutil.ReadAll(reader)
if err != nil {
return nil, err
}
file := &File{
relPath: sourcePath,
props: make(map[string]Prop),
modTime: time.Now(),
size: int64(len(data)),
reader: bytes.NewReader(data),
index: self.index,
}
return file, nil
}
// CreateFileFromAsset creates a new file instance from the provided file path.
func (*Context) CreateFileFromAsset(sourcePath, dataPath string) (*File, error) {
func (self *Context) CreateFileFromAsset(sourcePath, dataPath string) (*File, error) {
info, err := os.Stat(dataPath)
if err != nil {
return nil, err
@ -48,70 +58,74 @@ func (*Context) CreateFileFromAsset(sourcePath, dataPath string) (*File, error)
}
file := &File{
sourcePath: sourcePath,
dataPath: dataPath,
Meta: make(map[string]interface{}),
size: info.Size(),
relPath: sourcePath,
props: make(map[string]Prop),
modTime: info.ModTime(),
size: info.Size(),
dataPath: dataPath,
index: self.index,
}
return file, nil
}
// DispatchFile causes the file to get passed to the next link in the chain.
func (context *Context) DispatchFile(file *File) {
context.filesOut <- file
func (self *Context) DispatchFile(file *File) {
self.filesOut <- file
}
// DispatchAndCacheFile caches the file data (excluding the metadata), taking
// dependencies on any input files that are needed to generate it, and then
// passes it to the next link in the chain.
func (context *Context) DispatchAndCacheFile(outputFile *File, inputFiles ...*File) {
if context.goldsmith.cache != nil {
context.goldsmith.cache.storeFile(context, outputFile, inputFiles)
func (self *Context) DispatchAndCacheFile(outputFile *File, inputFiles ...*File) {
if self.goldsmith.cache != nil {
self.goldsmith.cache.storeFile(self, outputFile, inputFiles)
}
context.filesOut <- outputFile
self.filesOut <- outputFile
}
// RetrieveCachedFile looks up file data (excluding the metadata), given an
// output path and any input files that are needed to generate it. The function
// will return nil if the desired file is not found in the cache.
func (context *Context) RetrieveCachedFile(outputPath string, inputFiles ...*File) *File {
func (self *Context) RetrieveCachedFile(outputPath string, inputFiles ...*File) *File {
var outputFile *File
if context.goldsmith.cache != nil {
outputFile, _ = context.goldsmith.cache.retrieveFile(context, outputPath, inputFiles)
if self.goldsmith.cache != nil {
outputFile, _ = self.goldsmith.cache.retrieveFile(self, outputPath, inputFiles)
}
return outputFile
}
// Specify internal filter(s) that exclude files from being processed.
func (context *Context) Filter(filters ...Filter) *Context {
context.filtersInt = filters
return context
func (self *Context) Filter(filters ...Filter) *Context {
for _, filter := range filters {
self.filtersInt.push(filter, self.index)
}
return self
}
// Specify the maximum number of threads used for processing.
func (context *Context) Threads(threads int) *Context {
context.threads = threads
return context
func (self *Context) Threads(threads int) *Context {
self.threads = threads
return self
}
func (context *Context) step() {
defer close(context.filesOut)
func (self *Context) step() {
defer close(self.filesOut)
if initializer, ok := context.plugin.(Initializer); ok {
if err := initializer.Initialize(context); err != nil {
context.goldsmith.fault(context.plugin.Name(), nil, err)
if initializer, ok := self.plugin.(Initializer); ok {
if err := initializer.Initialize(self); err != nil {
self.goldsmith.fault(self.plugin.Name(), nil, err)
return
}
}
if context.filesIn != nil {
processor, _ := context.plugin.(Processor)
if self.filesIn != nil {
processor, _ := self.plugin.(Processor)
threads := context.threads
threads := self.threads
if threads < 1 {
threads = runtime.NumCPU()
}
@ -121,26 +135,27 @@ func (context *Context) step() {
wg.Add(1)
go func() {
defer wg.Done()
for inputFile := range context.filesIn {
if processor != nil && context.filtersInt.accept(inputFile) && context.filtersExt.accept(inputFile) {
for inputFile := range self.filesIn {
if processor != nil && self.filtersInt.accept(inputFile) && self.filtersExt.accept(inputFile) {
if _, err := inputFile.Seek(0, os.SEEK_SET); err != nil {
context.goldsmith.fault("core", inputFile, err)
self.goldsmith.fault("core", inputFile, err)
}
if err := processor.Process(context, inputFile); err != nil {
context.goldsmith.fault(context.plugin.Name(), inputFile, err)
if err := processor.Process(self, inputFile); err != nil {
self.goldsmith.fault(self.plugin.Name(), inputFile, err)
}
} else {
context.filesOut <- inputFile
self.filesOut <- inputFile
}
}
}()
}
wg.Wait()
}
if finalizer, ok := context.plugin.(Finalizer); ok {
if err := finalizer.Finalize(context); err != nil {
context.goldsmith.fault(context.plugin.Name(), nil, err)
if finalizer, ok := self.plugin.(Finalizer); ok {
if err := finalizer.Finalize(self); err != nil {
self.goldsmith.fault(self.plugin.Name(), nil, err)
}
}
}

235
file.go
View File

@ -2,106 +2,144 @@ package goldsmith
import (
"bytes"
"hash/crc32"
"io"
"io/ioutil"
"os"
"path"
"path/filepath"
"strings"
"time"
)
type Prop interface{}
type PropMap map[string]Prop
// File represents in-memory or on-disk files in a chain.
type File struct {
sourcePath string
dataPath string
Meta map[string]interface{}
hashValue uint32
hashValid bool
reader *bytes.Reader
size int64
relPath string
props map[string]Prop
modTime time.Time
size int64
dataPath string
reader *bytes.Reader
index int
}
// Rename modifies the file path relative to the source directory.
func (file *File) Rename(path string) {
file.sourcePath = path
func (self *File) Rename(path string) {
self.relPath = path
}
func (self *File) Rewrite(reader io.Reader) error {
data, err := ioutil.ReadAll(reader)
if err != nil {
return err
}
self.reader = bytes.NewReader(data)
self.modTime = time.Now()
self.size = int64(len(data))
return nil
}
// Path returns the file path relative to the source directory.
func (file *File) Path() string {
return file.sourcePath
func (self *File) Path() string {
return self.relPath
}
// Name returns the base name of the file.
func (file *File) Name() string {
return path.Base(file.sourcePath)
func (self *File) Name() string {
return path.Base(self.relPath)
}
// Dir returns the containing directory of the file.
func (file *File) Dir() string {
return path.Dir(file.sourcePath)
func (self *File) Dir() string {
return path.Dir(self.relPath)
}
// Ext returns the extension of the file.
func (file *File) Ext() string {
return path.Ext(file.sourcePath)
func (self *File) Ext() string {
return path.Ext(self.relPath)
}
// Size returns the file length in bytes.
func (file *File) Size() int64 {
return file.size
func (self *File) Size() int64 {
return self.size
}
// ModTime returns the time of the file's last modification.
func (file *File) ModTime() time.Time {
return file.modTime
func (self *File) ModTime() time.Time {
return self.modTime
}
// Read reads file data into the provided buffer.
func (file *File) Read(data []byte) (int, error) {
if err := file.load(); err != nil {
func (self *File) Read(data []byte) (int, error) {
if err := self.load(); err != nil {
return 0, err
}
return file.reader.Read(data)
return self.reader.Read(data)
}
// Write writes file data into the provided writer.
func (file *File) WriteTo(writer io.Writer) (int64, error) {
if err := file.load(); err != nil {
func (self *File) WriteTo(writer io.Writer) (int64, error) {
if err := self.load(); err != nil {
return 0, err
}
return file.reader.WriteTo(writer)
return self.reader.WriteTo(writer)
}
// Seek updates the file pointer to the desired position.
func (file *File) Seek(offset int64, whence int) (int64, error) {
if file.reader == nil && offset == 0 && (whence == os.SEEK_SET || whence == os.SEEK_CUR) {
func (self *File) Seek(offset int64, whence int) (int64, error) {
if self.reader == nil && offset == 0 && (whence == os.SEEK_SET || whence == os.SEEK_CUR) {
return 0, nil
}
if err := file.load(); err != nil {
if err := self.load(); err != nil {
return 0, err
}
return file.reader.Seek(offset, whence)
return self.reader.Seek(offset, whence)
}
// Returns value for string formatting.
func (file *File) GoString() string {
return file.sourcePath
func (self *File) GoString() string {
return self.relPath
}
func (file *File) export(targetDir string) error {
targetPath := filepath.Join(targetDir, file.sourcePath)
func (self *File) SetProp(name string, value Prop) {
self.props[name] = value
}
if targetInfo, err := os.Stat(targetPath); err == nil && !targetInfo.ModTime().Before(file.ModTime()) {
func (self *File) CopyProps(file *File) {
for key, value := range file.props {
self.props[key] = value
}
}
func (self *File) Prop(name string) (Prop, bool) {
value, ok := self.props[name]
return value, ok
}
func (self *File) Props() PropMap {
return self.props
}
func (self *File) PropOrDefault(name string, valueDef Prop) Prop {
if value, ok := self.Prop(name); ok {
return value
}
return valueDef
}
func (self *File) export(targetDir string) error {
targetPath := filepath.Join(targetDir, self.relPath)
if targetInfo, err := os.Stat(targetPath); err == nil && !targetInfo.ModTime().Before(self.ModTime()) {
return nil
}
@ -115,8 +153,8 @@ func (file *File) export(targetDir string) error {
}
defer fw.Close()
if file.reader == nil {
fr, err := os.Open(file.dataPath)
if self.reader == nil {
fr, err := os.Open(self.dataPath)
if err != nil {
return err
}
@ -126,11 +164,11 @@ func (file *File) export(targetDir string) error {
return err
}
} else {
if _, err := file.Seek(0, os.SEEK_SET); err != nil {
if _, err := self.Seek(0, os.SEEK_SET); err != nil {
return err
}
if _, err := file.WriteTo(fw); err != nil {
if _, err := self.WriteTo(fw); err != nil {
return err
}
}
@ -138,115 +176,16 @@ func (file *File) export(targetDir string) error {
return nil
}
func (file *File) load() error {
if file.reader != nil {
func (self *File) load() error {
if self.reader != nil {
return nil
}
data, err := ioutil.ReadFile(file.dataPath)
data, err := ioutil.ReadFile(self.dataPath)
if err != nil {
return err
}
file.reader = bytes.NewReader(data)
self.reader = bytes.NewReader(data)
return nil
}
func (file *File) hash() (uint32, error) {
if file.hashValid {
return file.hashValue, nil
}
if err := file.load(); err != nil {
return 0, err
}
offset, err := file.Seek(0, os.SEEK_CUR)
if err != nil {
return 0, err
}
if _, err := file.Seek(0, os.SEEK_SET); err != nil {
return 0, err
}
hasher := crc32.NewIEEE()
if _, err := io.Copy(hasher, file.reader); err != nil {
return 0, err
}
if _, err := file.Seek(offset, os.SEEK_SET); err != nil {
return 0, err
}
file.hashValue = hasher.Sum32()
file.hashValid = true
return file.hashValue, nil
}
type filesByPath []*File
func (file filesByPath) Len() int {
return len(file)
}
func (file filesByPath) Swap(i, j int) {
file[i], file[j] = file[j], file[i]
}
func (file filesByPath) Less(i, j int) bool {
return strings.Compare(file[i].Path(), file[j].Path()) < 0
}
type fileInfo struct {
os.FileInfo
path string
}
func cleanPath(path string) string {
if filepath.IsAbs(path) {
var err error
if path, err = filepath.Rel("/", path); err != nil {
panic(err)
}
}
return filepath.Clean(path)
}
func scanDir(rootDir string, infos chan fileInfo) {
defer close(infos)
filepath.Walk(rootDir, func(path string, info os.FileInfo, err error) error {
if err == nil {
infos <- fileInfo{FileInfo: info, path: path}
}
return err
})
}
type filterStack []Filter
func (filters *filterStack) accept(file *File) bool {
for _, filter := range *filters {
if !filter.Accept(file) {
return false
}
}
return true
}
func (filters *filterStack) push(filter Filter) {
*filters = append(*filters, filter)
}
func (filters *filterStack) pop() {
count := len(*filters)
if count == 0 {
panic("attempted to pop empty filter stack")
}
*filters = (*filters)[:count-1]
}

49
file_util.go Normal file
View File

@ -0,0 +1,49 @@
package goldsmith
import (
"os"
"path/filepath"
"strings"
)
type filesByPath []*File
func (self filesByPath) Len() int {
return len(self)
}
func (self filesByPath) Swap(i, j int) {
self[i], self[j] = self[j], self[i]
}
func (self filesByPath) Less(i, j int) bool {
return strings.Compare(self[i].Path(), self[j].Path()) < 0
}
type fileInfo struct {
os.FileInfo
path string
}
func cleanPath(path string) string {
if filepath.IsAbs(path) {
var err error
if path, err = filepath.Rel("/", path); err != nil {
panic(err)
}
}
return filepath.Clean(path)
}
func scanDir(rootDir string, infos chan fileInfo) {
defer close(infos)
filepath.Walk(rootDir, func(path string, info os.FileInfo, err error) error {
if err == nil {
infos <- fileInfo{FileInfo: info, path: path}
}
return err
})
}

31
filter_util.go Normal file
View File

@ -0,0 +1,31 @@
package goldsmith
type filterEntry struct {
filter Filter
index int
}
type filterStack []filterEntry
func (self *filterStack) accept(file *File) bool {
for _, entry := range *self {
if entry.index >= file.index && !entry.filter.Accept(file) {
return false
}
}
return true
}
func (self *filterStack) push(filter Filter, index int) {
*self = append(*self, filterEntry{filter, index})
}
func (self *filterStack) pop() {
count := len(*self)
if count == 0 {
panic("attempted to pop empty filter stack")
}
*self = (*self)[:count-1]
}

77
goldsmith.go
View File

@ -3,8 +3,6 @@ package goldsmith
import (
"fmt"
"hash"
"hash/crc32"
"sync"
)
@ -14,11 +12,11 @@ type Goldsmith struct {
targetDir string
contexts []*Context
contextHasher hash.Hash32
cache *cache
filters filterStack
clean bool
index int
errors []error
mutex sync.Mutex
@ -26,80 +24,77 @@ type Goldsmith struct {
// Begin starts a chain, reading the files located in the source directory as input.
func Begin(sourceDir string) *Goldsmith {
goldsmith := &Goldsmith{
sourceDir: sourceDir,
contextHasher: crc32.NewIEEE(),
}
goldsmith := &Goldsmith{sourceDir: sourceDir}
goldsmith.Chain(&loader{})
return goldsmith
}
// Cache enables caching in cacheDir for the remainder of the chain.
func (goldsmith *Goldsmith) Cache(cacheDir string) *Goldsmith {
goldsmith.cache = &cache{cacheDir}
return goldsmith
func (self *Goldsmith) Cache(cacheDir string) *Goldsmith {
self.cache = &cache{cacheDir}
return self
}
// Clean enables or disables removal of leftover files in the target directory.
func (goldsmith *Goldsmith) Clean(clean bool) *Goldsmith {
goldsmith.clean = clean
return goldsmith
func (self *Goldsmith) Clean(clean bool) *Goldsmith {
self.clean = clean
return self
}
// Chain links a plugin instance into the chain.
func (goldsmith *Goldsmith) Chain(plugin Plugin) *Goldsmith {
goldsmith.contextHasher.Write([]byte(plugin.Name()))
func (self *Goldsmith) Chain(plugin Plugin) *Goldsmith {
context := &Context{
goldsmith: goldsmith,
goldsmith: self,
plugin: plugin,
chainHash: goldsmith.contextHasher.Sum32(),
filtersExt: append(filterStack(nil), self.filters...),
index: self.index,
filesOut: make(chan *File),
}
context.filtersExt = append(context.filtersExt, goldsmith.filters...)
if len(goldsmith.contexts) > 0 {
context.filesIn = goldsmith.contexts[len(goldsmith.contexts)-1].filesOut
if len(self.contexts) > 0 {
context.filesIn = self.contexts[len(self.contexts)-1].filesOut
}
goldsmith.contexts = append(goldsmith.contexts, context)
return goldsmith
self.contexts = append(self.contexts, context)
self.index++
return self
}
// FilterPush pushes a filter instance on the chain's filter stack.
func (goldsmith *Goldsmith) FilterPush(filter Filter) *Goldsmith {
goldsmith.filters.push(filter)
return goldsmith
func (self *Goldsmith) FilterPush(filter Filter) *Goldsmith {
self.filters.push(filter, self.index)
self.index++
return self
}
// FilterPop pops a filter instance from the chain's filter stack.
func (goldsmith *Goldsmith) FilterPop() *Goldsmith {
goldsmith.filters.pop()
return goldsmith
func (self *Goldsmith) FilterPop() *Goldsmith {
self.filters.pop()
self.index++
return self
}
// End stops a chain, writing all recieved files to targetDir as output.
func (goldsmith *Goldsmith) End(targetDir string) []error {
goldsmith.targetDir = targetDir
func (self *Goldsmith) End(targetDir string) []error {
self.targetDir = targetDir
goldsmith.Chain(&saver{clean: goldsmith.clean})
for _, context := range goldsmith.contexts {
self.Chain(&saver{clean: self.clean})
for _, context := range self.contexts {
go context.step()
}
context := goldsmith.contexts[len(goldsmith.contexts)-1]
context := self.contexts[len(self.contexts)-1]
for range context.filesOut {
}
return goldsmith.errors
return self.errors
}
func (goldsmith *Goldsmith) fault(name string, file *File, err error) {
goldsmith.mutex.Lock()
defer goldsmith.mutex.Unlock()
func (self *Goldsmith) fault(name string, file *File, err error) {
self.mutex.Lock()
defer self.mutex.Unlock()
var faultError error
if file == nil {
@ -108,5 +103,5 @@ func (goldsmith *Goldsmith) fault(name string, file *File, err error) {
faultError = fmt.Errorf("[%s@%v]: %w", name, file, err)
}
goldsmith.errors = append(goldsmith.errors, faultError)
self.errors = append(self.errors, faultError)
}

16
loader.go
View File

@ -9,22 +9,18 @@ func (*loader) Name() string {
}
func (*loader) Initialize(context *Context) error {
infos := make(chan fileInfo)
go scanDir(context.goldsmith.sourceDir, infos)
scannedInfo := make(chan fileInfo)
go scanDir(context.goldsmith.sourceDir, scannedInfo)
for info := range infos {
for info := range scannedInfo {
if info.IsDir() {
continue
}
relPath, _ := filepath.Rel(context.goldsmith.sourceDir, info.path)
file := &File{
sourcePath: relPath,
Meta: make(map[string]interface{}),
modTime: info.ModTime(),
size: info.Size(),
dataPath: info.path,
file, err := context.CreateFileFromAsset(relPath, info.path)
if err != nil {
return err
}
context.DispatchFile(file)

22
saver.go
View File

@ -14,32 +14,32 @@ func (*saver) Name() string {
return "saver"
}
func (saver *saver) Initialize(context *Context) error {
saver.tokens = make(map[string]bool)
func (self *saver) Initialize(context *Context) error {
self.tokens = make(map[string]bool)
context.Threads(1)
return nil
}
func (saver *saver) Process(context *Context, file *File) error {
for token := cleanPath(file.sourcePath); token != "."; token = filepath.Dir(token) {
saver.tokens[token] = true
func (self *saver) Process(context *Context, file *File) error {
for token := cleanPath(file.relPath); token != "."; token = filepath.Dir(token) {
self.tokens[token] = true
}
return file.export(context.goldsmith.targetDir)
}
func (saver *saver) Finalize(context *Context) error {
if !saver.clean {
func (self *saver) Finalize(context *Context) error {
if !self.clean {
return nil
}
infos := make(chan fileInfo)
go scanDir(context.goldsmith.targetDir, infos)
scannedInfo := make(chan fileInfo)
go scanDir(context.goldsmith.targetDir, scannedInfo)
for info := range infos {
for info := range scannedInfo {
if info.path != context.goldsmith.targetDir {
relPath, _ := filepath.Rel(context.goldsmith.targetDir, info.path)
if contained, _ := saver.tokens[relPath]; !contained {
if contained, _ := self.tokens[relPath]; !contained {
os.RemoveAll(info.path)
}
}