Merge branch 'master' of github.com:deadcheat/awsset

README.md

@@ -44,10 +44,10 @@ NAME:
    goblet - make a binary contain some assets
 
 USAGE:
-   goblet [global options] command [command options] [arguments...]
+   main [global options] command [command options] [arguments...]
 
 VERSION:
-   1.0.4
+   1.1.0
 
 COMMANDS:
      help, h  Shows a list of commands or help for one command

cmd/goblet/main.go

@@ -17,7 +17,7 @@ func main() {
 
 	app.Name = "goblet"
 	app.Usage = "make a binary contain some assets"
-	app.Version = "1.0.4"
+	app.Version = "1.1.0"
 
 	app.Flags = values.FlagDefs
 	// mount presenter

generator/presenter/file/presenter.go

@@ -44,8 +44,8 @@ func (p *Presenter) action(c *cli.Context) error {
 		return ErrNoArguments
 	}
 	paths := append([]string{c.Args().First()}, c.Args().Tail()...)
-	ignores := c.StringSlice("except")
-	e, err := p.usecase.LoadFiles(paths, ignores)
+	includes := c.StringSlice(values.FlagKeyExpression)
+	e, err := p.usecase.LoadFiles(paths, includes)
 	if err != nil {
 		return err
 	}
@@ -63,20 +63,20 @@ func (p *Presenter) action(c *cli.Context) error {
 			},
 		},
 	).Parse(pt.AssetFileTemplate)
-	generateGoGen := c.Bool("generate")
+	generateGoGen := c.Bool(values.FlagKeyGenerate)
 	var b bytes.Buffer
 	assets := &pt.Assets{
 		ExecutedCommand:    strings.Join(os.Args, " "),
-		PackageName:        c.String("package"),
+		PackageName:        c.String(values.FlagKeyPackage),
 		GenerateGoGenerate: generateGoGen,
-		VarName:            c.String("name"),
+		VarName:            c.String(values.FlagKeyName),
 		DirMap:             e.DirMap,
 		FileMap:            e.FileMap,
 		Paths:              e.Paths,
 	}
 	targetPaths := paths
 	var writer io.Writer = os.Stdout
-	outName := c.String("out")
+	outName := c.String(values.FlagKeyOut)
 	if outName != "" {
 		// current dir
 		target, _ := filepath.Abs(outName)

generator/presenter/file/presenter_test.go

@@ -146,8 +146,8 @@ func TestActionSuccessWithStdout(t *testing.T) {
 		panic(err)
 	}
 
-	set.String("name", "Asset", "")
-	set.String("package", "assets", "")
+	set.String(values.FlagKeyName, "Asset", "")
+	set.String(values.FlagKeyPackage, "assets", "")
 
 	// stdout pattern
 	ctx := cli.NewContext(a, set, nil)
@@ -206,18 +206,18 @@ func TestActionSuccessWithFile(t *testing.T) {
 		panic(err)
 	}
 
-	a.Flags = values.FlagDefs
-	set.String("expression", "", "")
-	set.String("out", "", "")
-	set.String("name", "", "")
-	set.String("package", "", "")
-	set.Bool("generate", false, "")
+	var v cli.StringSlice
+	set.Var(&v, values.FlagKeyExpression, "")
+	set.String(values.FlagKeyOut, "", "")
+	set.String(values.FlagKeyName, "", "")
+	set.String(values.FlagKeyPackage, "", "")
+	set.Bool(values.FlagKeyGenerate, false, "")
 
 	ctx := cli.NewContext(a, set, nil)
-	ctx.Set("out", f.Path)
-	ctx.Set("name", "Asset")
-	ctx.Set("package", "assets")
-	ctx.Set("generate", "true")
+	ctx.Set(values.FlagKeyOut, f.Path)
+	ctx.Set(values.FlagKeyName, "Asset")
+	ctx.Set(values.FlagKeyPackage, "assets")
+	ctx.Set(values.FlagKeyGenerate, "true")
 	if err := p.action(ctx); err != nil {
 		t.Error("Mount should not return any error: ", err)
 	}
@@ -267,20 +267,21 @@ func TestActionFailWhenCouldNotOpenFile(t *testing.T) {
 	a := cli.NewApp()
 	p.Mount(a)
 	set := flag.NewFlagSet("test", flag.ContinueOnError)
-	set.String("expression", "", "")
-	set.String("out", "", "")
-	set.String("name", "", "")
-	set.String("package", "", "")
+	var v cli.StringSlice
+	set.Var(&v, values.FlagKeyExpression, "")
+	set.String(values.FlagKeyOut, "", "")
+	set.String(values.FlagKeyName, "", "")
+	set.String(values.FlagKeyPackage, "", "")
 
 	a.Flags = values.FlagDefs
 
 	if err := set.Parse([]string{filepath.Join(f.Path, "config")}); err != nil {
 		panic(err)
 	}
 	ctx := cli.NewContext(a, set, nil)
-	ctx.Set("out", filepath.Join(f.Path, "testfile.txt"))
-	ctx.Set("name", "Asset")
-	ctx.Set("package", "assets")
+	ctx.Set(values.FlagKeyOut, filepath.Join(f.Path, "testfile.txt"))
+	ctx.Set(values.FlagKeyName, "Asset")
+	ctx.Set(values.FlagKeyPackage, "assets")
 	if err := p.action(ctx); err == nil {
 		t.Error("Mount should return any error: ", err)
 	}
@@ -290,18 +291,19 @@ func TestExecutedCommand(t *testing.T) {
 
 	a := cli.NewApp()
 	set := flag.NewFlagSet("test", flag.ContinueOnError)
-	set.String("expression", "", "")
-	set.String("out", "", "")
-	set.String("name", "", "")
-	set.String("package", "", "")
-	set.Bool("generate", false, "")
+	var v cli.StringSlice
+	set.Var(&v, values.FlagKeyExpression, "")
+	set.String(values.FlagKeyOut, "", "")
+	set.String(values.FlagKeyName, "", "")
+	set.String(values.FlagKeyPackage, "", "")
+	set.Bool(values.FlagKeyGenerate, false, "")
 
 	a.Flags = values.FlagDefs
 
 	ctx := cli.NewContext(a, set, nil)
-	ctx.Set("out", "/tmp/hoge/test.go")
-	ctx.Set("name", "Asset")
-	ctx.Set("package", "assets")
-	ctx.Set("generate", "true")
+	ctx.Set(values.FlagKeyOut, "/tmp/hoge/test.go")
+	ctx.Set(values.FlagKeyName, "Asset")
+	ctx.Set(values.FlagKeyPackage, "assets")
+	ctx.Set(values.FlagKeyGenerate, "true")
 	fmt.Println(executedCommand(ctx, []string{"/tmp/hoge/files", "test/files"}))
 }

generator/repository/regexp/repository.go

@@ -37,8 +37,8 @@ func (r *Repository) MatchAny(path string) bool {
 		return true
 	}
 	for i := range r.rs {
-		regexp := r.rs[i]
-		if regexp != nil && regexp.MatchString(path) {
+		reg := r.rs[i]
+		if reg != nil && reg.MatchString(path) {
 			return true
 		}
 	}

generator/usecase/file/usecase.go

@@ -3,6 +3,7 @@ package file
 import (
 	"errors"
 	"io/ioutil"
+	"log"
 	"os"
 	"path/filepath"
 
@@ -38,14 +39,18 @@ func New(rr generator.RegexpRepository) generator.UseCase {
 }
 
 // LoadFiles load files for given paths, except what matches given ignore path regex
-func (u *UseCase) LoadFiles(paths []string, ignorePatterns []string) (*generator.Entity, error) {
-	if err := u.rr.CompilePatterns(ignorePatterns); err != nil {
+func (u *UseCase) LoadFiles(paths []string, includePatterns []string) (*generator.Entity, error) {
+	if err := u.rr.CompilePatterns(includePatterns); err != nil {
 		return nil, err
 	}
 
 	for i := range paths {
 		path := paths[i]
 		if err := u.addFile(path); err != nil {
+			if err == ErrFileIsNotMatchExpression {
+				log.Printf("path %s is not matched pattern given in 'expression(e)' flag", path)
+				continue
+			}
 			return nil, err
 		}
 	}
@@ -64,11 +69,11 @@ func (u *UseCase) addFile(path string) (err error) {
 	if err != nil {
 		return err
 	}
-	u.validPaths = append(u.validPaths, vPath)
 	if !fi.IsDir() {
 		if !u.rr.MatchAny(path) {
 			return ErrFileIsNotMatchExpression
 		}
+		u.validPaths = append(u.validPaths, vPath)
 		var data []byte
 		data, err = ioutil.ReadFile(path)
 		if err != nil {
@@ -78,6 +83,7 @@ func (u *UseCase) addFile(path string) (err error) {
 		u.fileMap[vPath] = file
 		return nil
 	}
+	u.validPaths = append(u.validPaths, vPath)
 	children := u.dirMap[vPath]
 	if children == nil {
 		children = make([]string, 0)
@@ -93,6 +99,10 @@ func (u *UseCase) addFile(path string) (err error) {
 		childPath := filepath.Join(path, f.Name())
 		err = u.addFile(childPath)
 		if err != nil {
+			if err == ErrFileIsNotMatchExpression {
+				log.Printf("path %s is not matched pattern given in 'expression(e)' flag", path)
+				continue
+			}
 			return err
 		}
 		children = append(children, filepath.Base(childPath))

generator/usecase/file/usecase_test.go

@@ -83,10 +83,10 @@ func TestLoadFilesErrorAddFile(t *testing.T) {
 	m := mock.NewMockRegexpRepository(c)
 
 	// should not be contained
-	fileWrongPath := "doesnotmatch.txt"
-	wrongPath := filepath.Join(d.Dir(), fileWrongPath)
-	d.AddFile("wrong path file", fileWrongPath, content, 0666)
-	m.EXPECT().MatchAny(wrongPath).Return(false)
+	fileDoesNotPermitted := "fail.txt"
+	permitWrongPath := filepath.Join(d.Dir(), fileDoesNotPermitted)
+	d.AddFile("success", fileDoesNotPermitted, content, 0000)
+	m.EXPECT().MatchAny(permitWrongPath).AnyTimes().Return(true)
 
 	// add Expects for CompilePatterns
 	emptyPatterns := make([]string, 0)
@@ -95,10 +95,58 @@ func TestLoadFilesErrorAddFile(t *testing.T) {
 	// create usecase
 	iu := New(m)
 
-	_, err := iu.LoadFiles([]string{d.Dir()}, emptyPatterns)
+	_, err := iu.LoadFiles([]string{d.Dir(), permitWrongPath}, emptyPatterns)
 	if err == nil {
 		t.Error("addFile should return error")
 	}
+
+}
+
+func TestLoadFilesSkipNotMatchedFile(t *testing.T) {
+	// Prepare dir and file
+	contentStr := "hello world!"
+	content := []byte(contentStr)
+	d := gonch.New("", "tmpdir")
+	defer d.Close() // clean up
+
+	// Prepare mock
+	c := gomock.NewController(t)
+	defer c.Finish()
+
+	m := mock.NewMockRegexpRepository(c)
+
+	// should not be contained
+	fileDoesNotMatch := "doesnotmatch.txt"
+	notMatchPath := filepath.Join(d.Dir(), fileDoesNotMatch)
+	d.AddFile("wrong path file", fileDoesNotMatch, content, 0666)
+	m.EXPECT().MatchAny(notMatchPath).AnyTimes().Return(false)
+
+	// add Expects for CompilePatterns
+	emptyPatterns := make([]string, 0)
+	m.EXPECT().CompilePatterns(emptyPatterns).Return(nil)
+
+	// create usecase
+	iu := New(m)
+
+	result, err := iu.LoadFiles([]string{d.Dir(), notMatchPath}, emptyPatterns)
+	if err != nil {
+		t.Error("addFile should not return error")
+	}
+
+	if len(result.DirMap[d.Dir()]) != 0 {
+		t.Error("some files are included in dirmap")
+	}
+
+	_, ok := result.FileMap[notMatchPath]
+	if ok {
+		t.Error("unmatched file are included in filemap")
+	}
+
+	for _, v := range result.Paths {
+		if v == notMatchPath {
+			t.Error("unmatched file are included in path slice")
+		}
+	}
 }
 
 func TestAddFileForSingleFiles(t *testing.T) {
@@ -119,12 +167,12 @@ func TestAddFileForSingleFiles(t *testing.T) {
 	d.AddFile("success", filenameSuccess, content, 0666)
 	m.EXPECT().MatchAny(path).Return(true)
 	// should not be contained
-	fileWrongPath := "doesnotmatch.txt"
-	wrongPath := filepath.Join(d.Dir(), fileWrongPath)
-	d.AddFile("wrong path file", fileWrongPath, content, 0666)
-	m.EXPECT().MatchAny(wrongPath).Return(false)
+	fileDoesNotMatch := "doesnotmatch.txt"
+	pathDoesNotMatch := filepath.Join(d.Dir(), fileDoesNotMatch)
+	d.AddFile("wrong path file", fileDoesNotMatch, content, 0666)
+	m.EXPECT().MatchAny(pathDoesNotMatch).Return(false)
 	// file can not be opened
-	d.AddFile("wrong path file", wrongPath, content, 0666)
+	d.AddFile("wrong path file", pathDoesNotMatch, content, 0666)
 	closedPath := filepath.Join(d.Dir(), "closed.txt")
 	ioutil.WriteFile(closedPath, []byte(""), 0000)
 	m.EXPECT().MatchAny(closedPath).Return(true)
@@ -138,7 +186,7 @@ func TestAddFileForSingleFiles(t *testing.T) {
 	if err != nil {
 		t.Error("addFile should not return any errors", err)
 	}
-	err = u.addFile(wrongPath)
+	err = u.addFile(pathDoesNotMatch)
 	if err != ErrFileIsNotMatchExpression {
 		t.Error("addFile should return ErrFileIsNotMatchExpression but returned ", err)
 	}
@@ -182,6 +230,11 @@ func TestAddFileForDirectory(t *testing.T) {
 		panic(err)
 	}
 
+	filenameSuccess3 := "/fail.txt"
+	path3 := filepath.Join(d.Dir(), filenameSuccess3)
+	d.AddFile("success", filenameSuccess3, content, 0000)
+	m.EXPECT().MatchAny(path3).AnyTimes().Return(true)
+
 	// permission denied file in permitted dir
 	permittedDir := "/permitteddir"
 	if err := d.AddDir("permitteddir", permittedDir, os.ModePerm); err != nil {
@@ -213,4 +266,8 @@ func TestAddFileForDirectory(t *testing.T) {
 	if err := u.addFile(filepath.Join(d.Dir(), permittedDir)); err == nil {
 		t.Error("addFile should return any error when file in dir is denied")
 	}
+	// when file in dir is not permitted
+	if err := u.addFile(path3); err == nil {
+		t.Error("addFile should return any error when file in dir is denied")
+	}
 }