mergefs

Documentation

Index

• func New(fss ...fs.FS) fs.FS
• type MergeFS
  • func (mfs *MergeFS) Glob(pattern string) ([]string, error)
  • func (mfs *MergeFS) Open(name string) (fs.File, error)
  • func (mfs *MergeFS) ReadDir(name string) ([]fs.DirEntry, error)
  • func (mfs *MergeFS) ReadFile(name string) ([]byte, error)
  • func (mfs *MergeFS) Stat(name string) (fs.FileInfo, error)

Examples

• MergeFS.Glob
• MergeFS.Open
• MergeFS.ReadDir
• MergeFS.ReadFile
• MergeFS.Stat

Functions

func New

func New(fss ...fs.FS) fs.FS

Types

type MergeFS

type MergeFS struct {
	// contains filtered or unexported fields
}

func (*MergeFS) Glob

func (mfs *MergeFS) Glob(pattern string) ([]string, error)

Example

package main

import (
	"embed"
	"fmt"
	"io/fs"

	"github.com/l4go/mergefs"
)

//go:embed test/fs1
var fs1Fs embed.FS

//go:embed test/fs2
var fs2Fs embed.FS

func new_fs1() fs.FS {
	fs1fs, err := fs.Sub(fs1Fs, "test/fs1")
	if err != nil {
		panic("crash embed FS")
	}

	return fs1fs
}

func new_fs2() fs.FS {
	fs2fs, err := fs.Sub(fs2Fs, "test/fs2")
	if err != nil {
		panic("crash embed FS")
	}

	return fs2fs
}

func main() {
	mfs := mergefs.New(new_fs1(), new_fs2())

	lst, err := fs.Glob(mfs, "foo/*.txt")
	if err != nil {
		return
	}

	for _, name := range lst {
		fmt.Println(name)
	}

}

Output:

foo/foo.txt
foo/bar.txt
foo/baz.txt

func (*MergeFS) Open

func (mfs *MergeFS) Open(name string) (fs.File, error)

Example

package main

import (
	"embed"
	"fmt"
	"io/fs"

	"github.com/l4go/mergefs"
)

//go:embed test/fs1
var fs1Fs embed.FS

//go:embed test/fs2
var fs2Fs embed.FS

func new_fs1() fs.FS {
	fs1fs, err := fs.Sub(fs1Fs, "test/fs1")
	if err != nil {
		panic("crash embed FS")
	}

	return fs1fs
}

func new_fs2() fs.FS {
	fs2fs, err := fs.Sub(fs2Fs, "test/fs2")
	if err != nil {
		panic("crash embed FS")
	}

	return fs2fs
}

func main() {
	mfs := mergefs.New(new_fs1(), new_fs2())

	var err error
	_, err = mfs.Open("foo.txt")
	fmt.Println(err == nil)
	_, err = mfs.Open("bar.txt")
	fmt.Println(err == nil)
	_, err = mfs.Open("baz.txt")
	fmt.Println(err == nil)
}

Output:

true
true
true

func (*MergeFS) ReadDir

func (mfs *MergeFS) ReadDir(name string) ([]fs.DirEntry, error)

Example

package main

import (
	"embed"
	"fmt"
	"io/fs"

	"github.com/l4go/mergefs"
)

//go:embed test/fs1
var fs1Fs embed.FS

//go:embed test/fs2
var fs2Fs embed.FS

func new_fs1() fs.FS {
	fs1fs, err := fs.Sub(fs1Fs, "test/fs1")
	if err != nil {
		panic("crash embed FS")
	}

	return fs1fs
}

func new_fs2() fs.FS {
	fs2fs, err := fs.Sub(fs2Fs, "test/fs2")
	if err != nil {
		panic("crash embed FS")
	}

	return fs2fs
}

func main() {
	mfs := mergefs.New(new_fs1(), new_fs2())

	ents, derr := fs.ReadDir(mfs, ".")
	if derr != nil {
		return
	}

	for _, e := range ents {
		fmt.Println(e.Name())
	}

}

Output:

foo
bar
baz
foo.txt
bar.txt
baz.txt
hoge.txt

func (*MergeFS) ReadFile

func (mfs *MergeFS) ReadFile(name string) ([]byte, error)

Example

package main

import (
	"embed"
	"fmt"
	"io/fs"

	"github.com/l4go/mergefs"
)

//go:embed test/fs1
var fs1Fs embed.FS

//go:embed test/fs2
var fs2Fs embed.FS

func new_fs1() fs.FS {
	fs1fs, err := fs.Sub(fs1Fs, "test/fs1")
	if err != nil {
		panic("crash embed FS")
	}

	return fs1fs
}

func new_fs2() fs.FS {
	fs2fs, err := fs.Sub(fs2Fs, "test/fs2")
	if err != nil {
		panic("crash embed FS")
	}

	return fs2fs
}

func main() {
	fs1 := new_fs1()
	fs2 := new_fs2()
	mfs := mergefs.New(fs1, fs2)

	var buf []byte
	var err error
	buf, err = fs.ReadFile(fs1, "baz.txt")
	if err != nil {
		fmt.Println("error")
	} else {
		fmt.Print(string(buf))
	}

	buf, err = fs.ReadFile(fs2, "baz.txt")
	if err != nil {
		fmt.Println("error")
	} else {
		fmt.Print(string(buf))
	}

	buf, err = fs.ReadFile(mfs, "baz.txt")
	if err != nil {
		fmt.Println("error")
	} else {
		fmt.Print(string(buf))
	}

}

Output:

baz
hoge
baz

func (*MergeFS) Stat

func (mfs *MergeFS) Stat(name string) (fs.FileInfo, error)

Example

package main

import (
	"embed"
	"fmt"
	"io/fs"

	"github.com/l4go/mergefs"
)

//go:embed test/fs1
var fs1Fs embed.FS

//go:embed test/fs2
var fs2Fs embed.FS

func new_fs1() fs.FS {
	fs1fs, err := fs.Sub(fs1Fs, "test/fs1")
	if err != nil {
		panic("crash embed FS")
	}

	return fs1fs
}

func new_fs2() fs.FS {
	fs2fs, err := fs.Sub(fs2Fs, "test/fs2")
	if err != nil {
		panic("crash embed FS")
	}

	return fs2fs
}

func main() {
	mfs := mergefs.New(new_fs1(), new_fs2())

	var err error
	_, err = fs.Stat(mfs, "foo")
	fmt.Println(err == nil)
	_, err = fs.Stat(mfs, "bar")
	fmt.Println(err == nil)
	_, err = fs.Stat(mfs, "baz")
	fmt.Println(err == nil)
	_, err = fs.Stat(mfs, "boo")
	fmt.Println(err == nil)
	_, err = fs.Stat(mfs, "foo.txt")
	fmt.Println(err == nil)
	_, err = fs.Stat(mfs, "bar.txt")
	fmt.Println(err == nil)
	_, err = fs.Stat(mfs, "baz.txt")
	fmt.Println(err == nil)
	_, err = fs.Stat(mfs, "boo.txt")
	fmt.Println(err == nil)

}

Output:

true
true
true
false
true
true
true
false