190 lines
3.6 KiB
Go
190 lines
3.6 KiB
Go
package goldsmith
|
|
|
|
import (
|
|
"bytes"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"time"
|
|
)
|
|
|
|
type Prop interface{}
|
|
type PropMap map[string]Prop
|
|
|
|
// File represents in-memory or on-disk files in a chain.
|
|
type File struct {
|
|
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 (self *File) Rename(path string) {
|
|
self.relPath = path
|
|
}
|
|
|
|
func (self *File) Rewrite(reader io.Reader) error {
|
|
data, err := io.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 (self *File) Path() string {
|
|
return filepath.ToSlash(self.relPath)
|
|
}
|
|
|
|
// Name returns the base name of the file.
|
|
func (self *File) Name() string {
|
|
return filepath.Base(self.relPath)
|
|
}
|
|
|
|
// Dir returns the containing directory of the file.
|
|
func (self *File) Dir() string {
|
|
return filepath.ToSlash(filepath.Dir(self.relPath))
|
|
}
|
|
|
|
// Ext returns the extension of the file.
|
|
func (self *File) Ext() string {
|
|
return filepath.Ext(self.relPath)
|
|
}
|
|
|
|
// Size returns the file length in bytes.
|
|
func (self *File) Size() int64 {
|
|
return self.size
|
|
}
|
|
|
|
// ModTime returns the time of the file's last modification.
|
|
func (self *File) ModTime() time.Time {
|
|
return self.modTime
|
|
}
|
|
|
|
// Read reads file data into the provided buffer.
|
|
func (self *File) Read(data []byte) (int, error) {
|
|
if err := self.load(); err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return self.reader.Read(data)
|
|
}
|
|
|
|
// Write writes file data into the provided writer.
|
|
func (self *File) WriteTo(writer io.Writer) (int64, error) {
|
|
if err := self.load(); err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return self.reader.WriteTo(writer)
|
|
}
|
|
|
|
// Seek updates the file pointer to the desired position.
|
|
func (self *File) Seek(offset int64, whence int) (int64, error) {
|
|
if self.reader == nil && offset == 0 && (whence == io.SeekStart || whence == io.SeekCurrent) {
|
|
return 0, nil
|
|
}
|
|
|
|
if err := self.load(); err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return self.reader.Seek(offset, whence)
|
|
}
|
|
|
|
// Returns value for string formatting.
|
|
func (self *File) GoString() string {
|
|
return self.relPath
|
|
}
|
|
|
|
func (self *File) SetProp(name string, value Prop) {
|
|
self.props[name] = value
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
if err := os.MkdirAll(filepath.Dir(targetPath), 0755); err != nil {
|
|
return err
|
|
}
|
|
|
|
fw, err := os.Create(targetPath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer fw.Close()
|
|
|
|
if self.reader == nil {
|
|
fr, err := os.Open(self.dataPath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer fr.Close()
|
|
|
|
if _, err := io.Copy(fw, fr); err != nil {
|
|
return err
|
|
}
|
|
} else {
|
|
if _, err := self.Seek(0, io.SeekStart); err != nil {
|
|
return err
|
|
}
|
|
|
|
if _, err := self.WriteTo(fw); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (self *File) load() error {
|
|
if self.reader != nil {
|
|
return nil
|
|
}
|
|
|
|
data, err := os.ReadFile(self.dataPath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
self.reader = bytes.NewReader(data)
|
|
return nil
|
|
}
|