~foosoft/goldsmith

2c2bda50b2795efa6e7eb18e8ce39b9388778f6f — Alex Yatskov 9 years ago 679f234
Changing file API
3 files changed, 34 insertions(+), 143 deletions(-)

D file.go
M goldsmith.go
M types.go
D file.go => file.go +0 -96
@@ 1,96 0,0 @@
/*
 * Copyright (c) 2015 Alex Yatskov <alex@foosoft.net>
 * Author: Alex Yatskov <alex@foosoft.net>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

package goldsmith

import (
	"bytes"
	"os"
)

type file struct {
	relPath, srcPath string
	meta             map[string]interface{}
	buff             *bytes.Buffer
	err              error
}

func (f *file) Path() string {
	return f.relPath
}

func (f *file) SetPath(path string) {
	f.relPath = path
}

func (f *file) Property(key, def string) interface{} {
	value, ok := f.meta[key]
	if ok {
		return value
	}

	return def
}

func (f *file) SetProperty(key string, value interface{}) {
	if f.meta == nil {
		f.meta = make(map[string]interface{})
	}

	f.meta[key] = value
}

func (f *file) Error() error {
	return f.err
}

func (f *file) SetError(err error) {
	f.err = err
}

func (f *file) Data() []byte {
	if f.buff != nil {
		return f.buff.Bytes()
	}

	var buff bytes.Buffer
	if len(f.srcPath) > 0 {
		file, err := os.Open(f.srcPath)
		if err != nil {
			f.SetError(err)
			return nil
		}
		defer file.Close()

		if _, err := buff.ReadFrom(file); err != nil {
			f.SetError(err)
			return nil
		}
	}

	f.buff = &buff
	return f.buff.Bytes()
}

func (f *file) SetData(data []byte) {
	f.buff = bytes.NewBuffer(data)
}

M goldsmith.go => goldsmith.go +25 -29
@@ 55,17 55,28 @@ func (gs *goldsmith) scan(srcDir string) {
	}

	s := stage{nil, make(chan File, len(matches))}
	defer close(s.output)

	for _, match := range matches {
		relPath, err := filepath.Rel(srcDir, match)
		if err != nil {
			gs.err = err
			return
			panic(err)
		}

		file := File{
			Path: relPath,
			Meta: make(map[string]interface{}),
		}

		var f *os.File
		if f, file.Err = os.Open(match); file.Err == nil {
			defer f.Close()
			_, file.Err = file.Buff.ReadFrom(f)
		}

		s.output <- &file{relPath: relPath, srcPath: match}
		s.output <- file
	}

	close(s.output)
	gs.stages = append(gs.stages, s)
}



@@ 82,7 93,7 @@ func (gs *goldsmith) chainSingle(ts ChainerSingle) {
	for file := range s.input {
		wg.Add(1)
		go func(f File) {
			s.output <- ts.ChainSingle(gs, f)
			s.output <- ts.ChainSingle(f)
			wg.Done()
		}(file)
	}


@@ 95,11 106,7 @@ func (gs *goldsmith) chainSingle(ts ChainerSingle) {

func (gs *goldsmith) chainMultiple(tm ChainerMultiple) {
	s := gs.makeStage()
	tm.ChainMultiple(gs, s.input, s.output)
}

func (gs *goldsmith) NewFile(relPath string) File {
	return &file{relPath: relPath}
	tm.ChainMultiple(s.input, s.output)
}

func (gs *goldsmith) Chain(chain interface{}, err error) Goldsmith {


@@ 124,31 131,20 @@ func (gs *goldsmith) Complete(dstDir string) ([]File, error) {

	var files []File
	for file := range s.output {
		if file.Error() == nil {
			data := file.Data()
			if data == nil {
		if file.Err == nil {
			absPath := filepath.Join(dstDir, file.Path)
			if file.Err = os.MkdirAll(path.Dir(absPath), 0755); file.Err != nil {
				continue
			}

			absPath := filepath.Join(dstDir, file.Path())
			if err := os.MkdirAll(path.Dir(absPath), 0755); err != nil {
				file.SetError(err)
				continue
			}

			f, err := os.Create(absPath)
			if err != nil {
				file.SetError(err)
				continue
			}
			defer f.Close()

			if _, err := f.Write(data); err != nil {
				file.SetError(err)
				continue
			var f *os.File
			if f, file.Err = os.Create(absPath); f == nil {
				_, file.Err = f.Write(file.Buff.Bytes())
				f.Close()
			}
		}

		file.Buff.Reset()
		files = append(files, file)
	}


M types.go => types.go +9 -18
@@ 22,33 22,24 @@

package goldsmith

import "bytes"

type Goldsmith interface {
	Chain(task interface{}, err error) Goldsmith
	Complete(dstDir string) ([]File, error)
}

type ChainerSingle interface {
	ChainSingle(ctx Context, file File) File
	ChainSingle(file File) File
}

type ChainerMultiple interface {
	ChainMultiple(ctx Context, input, output chan File)
}

type Context interface {
	NewFile(srcDir string) File
	ChainMultiple(input, output chan File)
}

type File interface {
	Path() string
	SetPath(path string)

	Data() []byte
	SetData(data []byte)

	Property(key, def string) interface{}
	SetProperty(key string, value interface{})

	Error() error
	SetError(err error)
type File struct {
	Path string
	Meta map[string]interface{}
	Buff bytes.Buffer
	Err  error
}

Do not follow this link