Init.

LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2024 k2u2
+
+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.

buildfs.go

@@ -0,0 +1,198 @@
+package buildfs
+
+import (
+	"embed"
+	"errors"
+	"io"
+	"io/fs"
+	"time"
+)
+
+type buildFS struct {
+	fsys       embed.FS
+	build_time time.Time
+}
+
+func BuildInFS(fsys embed.FS, build_time time.Time) fs.FS {
+	return &buildFS{fsys: fsys, build_time: build_time}
+}
+
+func (bfs buildFS) Open(name string) (fs.File, error) {
+	f, err := bfs.fsys.Open(name)
+	if err != nil {
+		return nil, err
+	}
+
+	s, err := f.Stat()
+	if err != nil {
+		return nil, err
+	}
+
+	if !s.IsDir() {
+		return &buildFile{f: f, mod_time: bfs.build_time}, nil
+	}
+
+	return &buildDir{f: f, mod_time: bfs.build_time}, nil
+}
+
+func (bf buildFS) ReadDir(name string) ([]fs.DirEntry, error) {
+	f, err := bf.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	dir, ok := f.(*buildDir)
+	if !ok {
+		return nil, &fs.PathError{Op: "read", Path: name, Err: errors.New("not a directory")}
+	}
+
+	return dir.ReadDir(-1)
+}
+
+func (bf buildFS) ReadFile(name string) ([]byte, error) {
+	f, err := bf.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	return io.ReadAll(f)
+}
+
+type buildFileInfo struct {
+	fi fs.FileInfo
+	mt time.Time
+}
+
+func (bfi *buildFileInfo) Name() string {
+	return bfi.fi.Name()
+}
+
+func (bfi *buildFileInfo) Size() int64 {
+	return bfi.fi.Size()
+}
+
+func (bfi *buildFileInfo) Mode() fs.FileMode {
+	return bfi.fi.Mode()
+}
+
+func (bfi *buildFileInfo) ModTime() time.Time {
+	return bfi.mt
+}
+
+func (bfi *buildFileInfo) IsDir() bool {
+	return bfi.fi.IsDir()
+}
+
+func (bfi *buildFileInfo) Sys() any {
+	return bfi.fi.Sys()
+}
+
+type buildDirEntry buildFileInfo
+
+func newBuildDirEntry(bfi *buildFileInfo) *buildDirEntry {
+	return (*buildDirEntry)(bfi)
+}
+
+func (bde *buildDirEntry) Name() string {
+	return (*buildFileInfo)(bde).Name()
+}
+
+func (bde *buildDirEntry) IsDir() bool {
+	return (*buildFileInfo)(bde).IsDir()
+}
+
+func (bde *buildDirEntry) Type() fs.FileMode {
+	return (*buildFileInfo)(bde).Mode()
+}
+
+func (bde *buildDirEntry) Info() (fs.FileInfo, error) {
+	return (*buildFileInfo)(bde), nil
+}
+
+type buildFile struct {
+	f        fs.File
+	mod_time time.Time
+}
+
+func (bf *buildFile) Close() error {
+	return bf.f.Close()
+}
+
+func (bf *buildFile) Stat() (fs.FileInfo, error) {
+	fi, err := bf.f.Stat()
+	if err != nil {
+		return nil, err
+	}
+
+	return &buildFileInfo{fi: fi, mt: bf.mod_time}, nil
+}
+
+func (bf *buildFile) Read(b []byte) (int, error) {
+	return bf.f.Read(b)
+}
+
+func (bf *buildFile) Seek(offset int64, whence int) (int64, error) {
+	s, ok := bf.f.(io.Seeker)
+	if !ok {
+		panic("Not embed.FS .")
+	}
+
+	return s.Seek(offset, whence)
+}
+
+func (bf *buildFile) ReadAt(b []byte, offset int64) (int, error) {
+	ra, ok := bf.f.(io.ReaderAt)
+	if !ok {
+		panic("Not embed.FS .")
+	}
+
+	return ra.ReadAt(b, offset)
+}
+
+type buildDir struct {
+	f        fs.File
+	mod_time time.Time
+}
+
+func (bd *buildDir) Close() error {
+	return bd.f.Close()
+}
+
+func (bd *buildDir) Stat() (fs.FileInfo, error) {
+	fi, err := bd.f.Stat()
+	if err != nil {
+		return nil, err
+	}
+
+	return &buildFileInfo{fi: fi, mt: bd.mod_time}, nil
+}
+
+func (bd *buildDir) Read(b []byte) (int, error) {
+	return bd.f.Read(b)
+}
+
+func (bd *buildDir) ReadDir(count int) ([]fs.DirEntry, error) {
+	rd, ok := bd.f.(fs.ReadDirFile)
+	if !ok {
+		panic("Not embed.FS .")
+	}
+
+	ents, err := rd.ReadDir(count)
+	if err != nil {
+		return nil, err
+	}
+
+	new_ents := make([]fs.DirEntry, len(ents))
+	for i, ent := range ents {
+		fi, ierr := ent.Info()
+		if ierr != nil {
+			return nil, ierr
+		}
+		new_ents[i] = newBuildDirEntry(&buildFileInfo{fi: fi, mt: bd.mod_time})
+	}
+
+	return new_ents, nil
+}
+

buildfs_test.go

@@ -0,0 +1,87 @@
+//go:generate go run ./gen
+package buildfs_test
+
+import (
+	"embed"
+	"fmt"
+	"io/fs"
+	"log"
+
+	"github.com/l4go/buildfs"
+)
+
+func MustSub(fsys fs.FS, subpath string) fs.FS {
+	subfs, err := fs.Sub(fsys, subpath)
+	if err != nil {
+		panic("Fail fs.Sub: " + err.Error())
+	}
+
+	return subfs
+}
+
+//go:embed testfs
+var raw_testFS embed.FS
+var testFS = MustSub(buildfs.BuildInFS(raw_testFS, BuildTime), "testfs")
+
+func Example() {
+	f, err := testFS.Open(".")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	df, ok := f.(fs.ReadDirFile)
+	if !ok {
+		log.Fatal("Not fs.ReadDirFile")
+	}
+
+	dir, err := df.ReadDir(-1)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	for _, de := range dir {
+		fi, err := de.Info()
+		if err != nil {
+			log.Fatal(err)
+		}
+		fmt.Println(de.Name(), fi.ModTime().IsZero())
+	}
+
+	// Unordered output:
+	// foo.txt false
+	// bar.txt false
+}
+
+func Example_file() {
+	f, err := testFS.Open("foo.txt")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	fi, err := f.Stat()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	fmt.Println(fi.Name(), fi.ModTime().IsZero())
+
+	// Output:
+	// foo.txt false
+}
+
+func Example_dir() {
+	f, err := testFS.Open(".")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	fi, err := f.Stat()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	fmt.Println(fi.IsDir(), fi.ModTime().IsZero())
+
+	// Output:
+	// true false
+}

buildtime_test.go.tmpl

@@ -0,0 +1,8 @@
+// Code generated by {{.Name}}; DO NOT EDIT.
+package buildfs_test
+
+import (
+	"time"
+)
+
+var BuildTime = time.UnixMicro({{.BuildMicroSeconds}})

docs/README.md

@@ -0,0 +1,42 @@
+# l4go/buildfs ライブラリ
+
+embed.FSの更新時刻を変更したfs.FSを提供するライブラリーです。  
+embed.FSは、更新時刻がtime.Timeのゼロ値に固定されていますが、
+この時刻を別の時間に替えることができます。
+
+## embed.FSのゼロ値の更新時刻が起こす問題
+
+embed.FSは、更新時刻(FileInfoのModTime())として、常に`time.Time`型のゼロ値を返します。
+そして、ゼロ値を特別扱いするプログラムで、この仕様が問題になります。
+
+例えば、httpモジュールの`http.FileServer()`や`http.ServeContent()`は、更新時刻がゼロ値の時、
+`Last-Modified`ヘッダの出力を止めます。  
+ということは、embed.FSをそのまま利用すると`Last-Modified`ヘッダ無くなるので、HTTPキャッシュ制御に影響が出てしまいます。
+
+## 利用方法
+
+使い方は単純で、`BuildInFS()`というラッパー関数呼び出すだけです。
+
+### `BuildInFS()`仕様
+
+ラッパー関数の`BuildInFS()`の定義は以下の通りです。
+
+``` go
+func BuildInFS(fsys embed.FS, build_time time.Time) fs.FS
+```
+引数にembed.FSと更新時刻を渡すと、更新時刻が替えられたfs.FSが生成されます。
+
+### サンプルコード
+
+以下のようなコードで、embed.FSの更新時刻を変えることが出来ます。
+
+``` go
+//go:embed testfs
+var raw_testFS embed.FS
+
+var BuildTime = time.UnixMicro(1702377180976629)
+var testFS = buildfs.BuildInFS(raw_testFS, BuildTime)
+```
+
+上記のサンプルコードでは`BuildTime`変数として更新時刻を決め打ちにしていますが、
+実際の利用時には、Goのgenerateの機能などで適切な時刻を生成してください。