After go install github.com/markbates/pkger/cmd/pkger on my MBP/Mojave (10.14.6) using go version go1.13 darwin/amd64 pkger hangs when invoked. I've let it run for 10 min before CRL+Cing it.

Code includes this usage:

import (
	"net/http"
	"strconv"

	"github.com/markbates/pkger"
)

func HandleIndexHTML(w http.ResponseWriter, r *http.Request) {
	asset, err := pkger.Open("/ui/index.html")
	if err != nil {
		http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound)
	}

	w.Header().Add("Content-Type", "text/html")
	w.Header().Add("Content-Length", strconv.Itoa(len(asset)))
	w.Write(asset)
}

Am I misunderstanding the usage?

Contrary to what documentation claims the package directive is still main if I ask pkger to write the file in another directory.

$ pkger -o config
$ head -n 1 config/pkged.go 
package main

After generating pkged.go, I was hoping I can run the same way without public folder. but it is failing...

Sample code to reproduce...

pkger-example.zip

Before renaming public

go run main.go pkged.go
in shared init
Name:  index.html
Size:  257
Mode:  -rw-rw-r--
ModTime:  2019-11-10 15:59:20 -0800 PST
in main init
hi
Name:  index.html
Size:  257
Mode:  -rw-rw-r--
ModTime:  2019-11-10 15:59:20 -0800 PST

After renaming public to public1

go run main.go pkged.go
in shared init
2019/11/10 22:04:25 stat /mywork/pkger-example/public/index.html: no such file or directory
exit status

Hi Mark,

More than issue is a doubt to know if I'm doing wrong while use your library. I try to follow your examples and I've the follow structure:

├── cmd
│   ├── reader
│   │   ├── main.go
├── files
│   ├── swapi.go
├── reader.go
├── go.mod

The reader.go code:

package pkg

import (
	"fmt"
	"io"
	"os"
	"time"

	"github.com/markbates/pkger"
)

func ReadCsv() error {
	f, err := pkger.Open("/files/swapi.csv")
	if err != nil {
		return err
	}
	defer f.Close()

	data, err := f.Stat()
	if err != nil {
		return err
	}

	fmt.Println("File name: ", data.Name())
	fmt.Println("File size: ", data.Size())
	fmt.Println("File mode: ", data.Mode())
	fmt.Println("Modification time: ", data.ModTime().Format(time.RFC3339))

	fmt.Println()
	if _, err := io.Copy(os.Stdout, f); err != nil {
		return err
	}

	return nil

}

So when I executed the code go run cmd/reader/main.go everything is fine, but if I move the reader.go inside another directory:

├── cmd
│   ├── reader
│   │   ├── main.go
├── files
│   ├── swapi.go
├── pkg
│   ├── reader.go
├── go.mod

And I executed again the code go run cmd/reader/main.go I got the follow error:

2019/11/09 15:57:49 exit status 1: go: cannot find main module; see 'go help modules'

2019/11/09 15:57:49 open /files/swapi.csv: no such file or directory
exit status 1

I understand if the static files are in a level without any .go file that indicate a package, then the pkger can't find the go.mod. Because if I add a simple sample.go in the root folder, to the same level that files directory, then the application works fine.

Could you help me to understand what is my wrong here?

Hi @markbates 👋!

Context

I've been trying to use pkger as a replacement for packr2 in a small tool I've been writing (github.com/paganotoni/admon).

The things I need to replace initially are the assets and templates Boxes. To do so, I'm walking both paths with pkger and filling in a pckd.MemoryBox with those files so buffalo can use them.

var (
        assetsBox    = packd.NewMemoryBox()
	templatesBox = packd.NewMemoryBox()
)
func init() {
	logrus.Info("Reading templates")
	err := pkger.Walk("/web/templates", func(path string, info os.FileInfo, err error) error {
		logrus.Info(path)

		if err != nil {
			return err
		}

		if info.IsDir() {
			return nil
		}

		file, err := pkger.Open(path)
		if err != nil {
			return err
		}

		data, err := ioutil.ReadAll(file)
		if err != nil {
			return err
		}

		return templatesBox.AddBytes(path, data)
	})

	if err != nil {
		logrus.Error(err)
	}

	logrus.Info("Reading assets")
	err = pkger.Walk("/web/public", func(path string, info os.FileInfo, err error) error {
		logrus.Info(path)

		if err != nil {
			return err
		}

		if info.IsDir() {
			return nil
		}

		file, err := pkger.Open(path)
		if err != nil {
			return err
		}

		data, err := ioutil.ReadAll(file)
		return assetsBox.AddBytes(path, data)
	})

	if err != nil {
		logrus.Error(err)
	}

	renderEngine = render.New(render.Options{
		HTMLLayout:   "admon.plush.html",
		TemplatesBox: templatesBox,

		AssetsBox: assetsBox,
		Helpers:   helpers,
	})
}

The problem

The problem i'm facing is that pkger seems to only walk through the first path alphabetically. And is ignoring the second one as the following logs show:

time="2019-10-23T08:21:47-05:00" level=info msg="Reading templates"
time="2019-10-23T08:21:47-05:00" level=info msg="Reading assets"
time="2019-10-23T08:21:47-05:00" level=info msg="github.com/paganotoni/admon:/web/public"
time="2019-10-23T08:21:47-05:00" level=info msg="github.com/paganotoni/admon:/web/public/assets"
time="2019-10-23T08:21:47-05:00" level=info msg="github.com/paganotoni/admon:/web/public/assets/admin.e4904589a02627deb099.css"
time="2019-10-23T08:21:47-05:00" level=info msg="github.com/paganotoni/admon:/web/public/assets/admin.f11b630e4512aaa573d4.js"
time="2019-10-23T08:21:47-05:00" level=info msg="github.com/paganotoni/admon:/web/public/assets/manifest.json"

With gobuffalo/packr you can use the actual files on the system for development, allowing you to swap your static file's contents without needing to rebuild. Is there a similar functionality here?

Go has a very useful ioutil.ReadFile function which slurps an entire file into memory.

It would be very helpful to have an equivalent both at the top level and as part of the Pkger interface.

Hi, I ran pkger in a go modules enabled project, built the binary and ran it from the source folder and it worked. When I run this binary from /tmp it fails.

log:

~/p/play-pkger (master|✚2…) $ cat cmd/play-pkger/play-pkger.go 
package main

import (
	"fmt"

	"github.com/markbates/pkger"
)

func main() {
	err := run()
	if err != nil {
		panic(err)
	}
}

func run() error {
	f, err := pkger.Open("/LICENSE")
	if err != nil {
		return err
	}
	defer f.Close()

	info, err := f.Stat()
	if err != nil {
		return err
	}

	fmt.Println("Name: ", info.Name())
	fmt.Println("Size: ", info.Size())
	fmt.Println("Mode: ", info.Mode())
	fmt.Println("ModTime: ", info.ModTime())
	return nil
}
~/p/play-pkger (master|✚2…) $ pkger
~/p/play-pkger (master|✚2…) $ tree
.
├── cmd
│   └── play-pkger
│       └── play-pkger.go
├── go.mod
├── go.sum
├── LICENSE
└── pkged.go

2 directories, 5 files
~/p/p/c/play-pkger (master|✚2…) $ go build -o /tmp/play-pkger
~/p/p/c/play-pkger (master|✚2…) $ /tmp/play-pkger
Name:  LICENSE
Size:  11353
Mode:  -rw-r--r--
ModTime:  2019-11-20 10:46:18.276189286 +0100 CET
~/p/p/c/play-pkger (master|✚2…) $ cd /tmp/
/tmp $ /tmp/play-pkger
2019/11/20 10:51:45 exit status 1: "go list -json -m": go list -m: not using modules

panic: open /LICENSE: no such file or directory

goroutine 1 [running]:
main.main()
	/home/play/pr/play-pkger/cmd/play-pkger/play-pkger.go:12 +0x44
/tmp [2] $ 

Hi!

I'm using Go 1.13.5.

On my ./cmd/myapp/main.go:

package main

import "github.com/markbates/pkger"

func main() {
	pkger.Include("/configs")

	// ...
}

// CopyFolder function for copy all files from app config
func CopyFolder() error {
	return pkger.Walk("/configs/dotfiles", func(path string, file os.FileInfo, err error) error {
		// Define files paths
		folder := "." + string(os.PathSeparator) + file.Name()

		// Create files (skip directories)
		if !file.IsDir() {
			// Open file
			from, err := pkger.Open(path)
			ErrChecker(err)
			defer from.Close()

			// Create file
			to, err := os.Create(folder)
			ErrChecker(err)
			defer to.Close()

			// Copy file
			_, err = io.Copy(to, from)
			ErrChecker(err)

			// Show report for each file
			fmt.Printf("— File '%v' was copied!\n", folder)
		}

		// Default return
		return nil
	})
}

App structure:

$ tree .

myapp
├── cmd
│   └── myapp
│       └── main.go
├── configs
│   └── dotfiles
│       └── .env
├── go.mod
├── go.sum
└── pkged.go

I packed my app like this:

$ pkger && go build -o myapp ./cmd/myapp/*.go

If I run binary ./myapp from folder — all okay. Files from ./config was copied.

But, if I run $ go install ./cmd/myapp and call binary (who installed to $GOPATH/bin) as usual, by $ myapp [args], I got this error:

Error: lstat configs/dotfiles: no such file or directory

What's wrong? How to solve this? Help me please 😞

Still experiencing the same issue as outlined in #34. @markbates, you mentioned this would be fixed in v0.12.3 in that thread. I'm using v0.12.8

I get error:

 "go list -json -find <my_package>: cannot find module providing package <my_package>

I addressed this by putting a dummy.go file at the root of the module.

Is having a .go file at the root of the module, a requirement?

Hello.

I write simple CLI script, which make some automation for creating web server (based on net/http). I include folder with completed app structure via pkger to binary, but how to save (or copy) packed app from binary to outer folder?

I read README, but not sure it's possible?

Something like ioutil.WriteFile(fileOutput, fileInput, 0644) will be great, but doesn't work with pkger.Open() file.

Running pkger 1.17.1 will error when running on Go 1.18 code that uses type parameters/generics. An example can be found in this gist.

$ pkger
2022/03/30 13:10:19 /tmp/pkger-test/main.go:10:13: expected '(', found '[' (and 5 more errors): ParseDir failed /tmp/pkger-test: /tmp/pkger-test

An example of Go code that will cause the error.

package main

import (
	"io"
	"os"

	"github.com/markbates/pkger"
)

func Example[T any]() {}

func main() {
	f, err := pkger.Open("/file.txt")
	if err != nil {
		panic(err)
	}
	defer func() { _ = f.Close() }()

	if _, err := io.Copy(os.Stdout, f); err != nil {
		panic(err)
	}
}

Maybe it would be nice if the readme featured some kind of comparison between the native embed and wrapping pkger. After skimming over the description it feels more or less like using embed.FS. Edit: Just to clarify, I don't mean to disrespect the work you're doing here. I just would love to see some of the project's core features to make a decision whether it makes sense for me to add another 3rd party library or not.

Go 1.17 is starting a migration with build constraints, so they are looking for //go:build ... stanzas in source files before any //+build ... lines. This breaks builds which check source code formatting/validation in CI that automatically updated.

It can be resolved with gofmt -s -w pkged.go which will add the required line. Example

The 1.17 release notes mention this change and the design proposal has a migration section for more details.

I use go v1.16.4 and have a mac running mojave. I create a simple go project as a module and tried to download pkger. However after that when I try the command pkger -h or any cli it says command not found. Can anybody help?

Error: bash: pkger: command not found

Thanks

//go:generate pkger
package main

import (
	"fmt"
	"time"

	"github.com/markbates/pkger"
	"github.com/markbates/pkger/pkging"
)

func main() {
	var err error
	Dir := pkger.Include("/static/run.log")

	var f pkging.File
	if f, err = pkger.Open(Dir); err != nil {
		fmt.Println(err)
		return
	}
	if _, err = f.Write([]byte("bbb")); err != nil {
		fmt.Println(err)
		return
	}
	f.Close()

	fmt.Println("write end")
	time.Sleep(time.Second * 3)

	var f2 pkging.File
	if f2, err = pkger.Open(Dir); err != nil {
		fmt.Println(err)
		return
	}
	var da []byte = make([]byte, 100)
	if n, err := f2.Read(da); err != nil {
		fmt.Println(err)
		return
	} else {
		fmt.Println(string(da[:n]))
	}
	f2.Close()

}

go generate
go build -o run.exe
run
// echo
// aaa