fix(init): TargetDir for init, can be absolute, is created if needed

Prior to this change, lib.InitDataset would take two parameters, Dir which would need to exist already, and Mkdir which would be created but could only be a single directory name instead of a relative path. Fix this problem, and also add multiple tests, and cleanup some TODOs.

api/fsi.go

@@ -142,18 +142,11 @@ func (h *FSIHandlers) InitHandler(routePrefix string) http.HandlerFunc {
 
 func (h *FSIHandlers) initHandler(routePrefix string) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		// Backwards compatibility shim for now, can use either "dir" or "filepath".
-		// TODO: Update desktop to always use "dir", delete "filepath".
-		dir := r.FormValue("dir")
-		if dir == "" && r.FormValue("filepath") != "" {
-			dir = r.FormValue("filepath")
-		}
-		p := &lib.InitFSIDatasetParams{
-			Dir:            dir,
-			Name:           r.FormValue("name"),
-			Format:         r.FormValue("format"),
-			Mkdir:          r.FormValue("mkdir"),
-			SourceBodyPath: r.FormValue("sourcebodypath"),
+		p := &lib.InitDatasetParams{
+			TargetDir: r.FormValue("targetdir"),
+			Name:      r.FormValue("name"),
+			Format:    r.FormValue("format"),
+			BodyPath:  r.FormValue("bodypath"),
 		}
 
 		var name string

api/fsi_test.go

@@ -98,9 +98,9 @@ func TestNoHistory(t *testing.T) {
 
 	// Create a linked dataset without saving, it has no versions in the repository
 	ref, err := run.Inst.FSI().InitDataset(fsi.InitParams{
-		Dir:    workDir,
-		Name:   "test_ds",
-		Format: "csv",
+		TargetDir: workDir,
+		Name:      "test_ds",
+		Format:    "csv",
 	})
 	if err != nil {
 		t.Fatal(err)

cmd/fsi_integration_test.go

@@ -276,6 +276,22 @@ func TestInitExplicitDirectory(t *testing.T) {
 	}
 }
 
+// Test init command can use an explicit directory
+func TestInitExplicitAbsoluteDirectory(t *testing.T) {
+	run := NewFSITestRunner(t, "test_peer_init_abs_dir", "qri_test_init_abs_dir")
+	defer run.Delete()
+
+	absDir := filepath.Join(run.RootPath, "datasets/my_work_dir")
+	run.MustExec(t, fmt.Sprintf("qri init --name abs_dir --format csv %s", absDir))
+
+	// Verify the directory contains the files that we expect.
+	dirContents := listDirectory(absDir)
+	expectContents := []string{".qri-ref", "body.csv", "meta.json", "structure.json"}
+	if diff := cmp.Diff(expectContents, dirContents); diff != "" {
+		t.Errorf("directory contents (-want +got):\n%s", diff)
+	}
+}
+
 // Test init command can build dscache
 func TestInitDscache(t *testing.T) {
 	run := NewFSITestRunner(t, "test_peer_init_dscache", "qri_test_init_dscache")
@@ -376,6 +392,27 @@ func TestGetBodyWithoutStructure(t *testing.T) {
 	}
 }
 
+// Test init command accepts dataset name on standard input
+func TestInitUsingStdin(t *testing.T) {
+	run := NewFSITestRunner(t, "test_peer_init_json_body", "qri_test_init_json_body")
+	defer run.Delete()
+
+	workDir := run.CreateAndChdirToWorkDir("json_body")
+
+	// Init with configuration from standard input
+	err := run.ExecCommandWithStdin(run.Context, "qri init", "my_dataset\njson")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Verify the directory contains the files that we expect.
+	dirContents := listDirectory(workDir)
+	expectContents := []string{".qri-ref", "body.json", "meta.json", "structure.json"}
+	if diff := cmp.Diff(expectContents, dirContents); diff != "" {
+		t.Errorf("directory contents (-want +got):\n%s", diff)
+	}
+}
+
 // Test init command can create a json body using the format flag
 func TestInitForJsonBody(t *testing.T) {
 	run := NewFSITestRunner(t, "test_peer_init_json_body", "qri_test_init_json_body")

cmd/init.go

@@ -1,7 +1,6 @@
 package cmd
 
 import (
-	"os"
 	"path/filepath"
 	"strings"
 
@@ -46,8 +45,8 @@ already existing body file using the 'body' flag.`,
 	}
 
 	cmd.Flags().StringVar(&o.Name, "name", "", "name of the dataset")
-	cmd.Flags().StringVar(&o.Format, "format", "", "format of dataset")
-	cmd.Flags().StringVar(&o.SourceBodyPath, "body", "", "path to the body file")
+	cmd.Flags().StringVar(&o.Format, "format", "", "format of dataset body")
+	cmd.Flags().StringVar(&o.BodyPath, "body", "", "path to the body file")
 	cmd.Flags().BoolVarP(&o.UseDscache, "use-dscache", "", false, "experimental: build and use dscache if none exists")
 
 	return cmd
@@ -57,11 +56,16 @@ already existing body file using the 'body' flag.`,
 type InitOptions struct {
 	ioes.IOStreams
 
-	Name           string
-	Format         string
-	SourceBodyPath string
-	Mkdir          string
-	UseDscache     bool
+	// Name of the dataset that will be created
+	Name string
+	// Format of the body
+	Format string
+	// Body file to initialize dataset with, if blank an example csv will be used
+	BodyPath string
+	// Path to use as a working directory. Will be created if it does not exist yet.
+	TargetDir string
+	// Experimental: Use dscache subsystem to store dataset references
+	UseDscache bool
 
 	DatasetMethods *lib.DatasetMethods
 	FSIMethods     *lib.FSIMethods
@@ -73,48 +77,37 @@ func (o *InitOptions) Complete(f Factory, args []string) (err error) {
 		return err
 	}
 	o.FSIMethods, err = f.FSIMethods()
-	if len(args) > 0 && args[0] != "." {
-		o.Mkdir = args[0]
+	if len(args) > 0 {
+		o.TargetDir = args[0]
 	}
 	return err
 }
 
 // Run executes the `init` command
 func (o *InitOptions) Run() (err error) {
-	pwd, err := os.Getwd()
-	if err != nil {
-		return err
-	}
-	targetDir := pwd
-	if o.Mkdir != "" {
-		targetDir = o.Mkdir
-	}
-
 	// First, check if the directory can be init'd, before prompting for any input
-	canInitParams := lib.InitFSIDatasetParams{
-		Dir:            targetDir,
-		SourceBodyPath: o.SourceBodyPath,
+	canInitParams := lib.InitDatasetParams{
+		TargetDir: o.TargetDir,
+		BodyPath:  o.BodyPath,
 	}
 	if err = o.FSIMethods.CanInitDatasetWorkDir(&canInitParams, nil); err != nil {
 		return err
 	}
 
 	// Suggestion for the dataset name defaults to directory it is being linked into
 	if o.Name == "" {
-		// TODO(dustmop): Currently all tests that call `init` use the --name flag. Add a test
-		// that receives stdin and checks what is written to stdout.
-		suggestedName := dsref.GenerateName(filepath.Base(targetDir), "dataset_")
+		suggestedName := dsref.GenerateName(filepath.Base(o.TargetDir), "dataset_")
 		o.Name = inputText(o.Out, o.In, "Name of new dataset", suggestedName)
 	}
 
-	// If user inputted there own dataset name, make sure it's valid.
+	// If user inputted their own dataset name, make sure it's valid.
 	if err := dsref.EnsureValidName(o.Name); err != nil {
 		return err
 	}
 
 	// If --body flag is set, use that to figure out the format
-	if o.SourceBodyPath != "" {
-		ext := filepath.Ext(o.SourceBodyPath)
+	if o.BodyPath != "" {
+		ext := filepath.Ext(o.BodyPath)
 		if strings.HasPrefix(ext, ".") {
 			ext = ext[1:]
 		}
@@ -125,13 +118,12 @@ func (o *InitOptions) Run() (err error) {
 		o.Format = inputText(o.Out, o.In, "Format of dataset, csv or json", "csv")
 	}
 
-	p := &lib.InitFSIDatasetParams{
-		Dir:            pwd,
-		Mkdir:          o.Mkdir,
-		Format:         o.Format,
-		Name:           o.Name,
-		SourceBodyPath: o.SourceBodyPath,
-		UseDscache:     o.UseDscache,
+	p := &lib.InitDatasetParams{
+		TargetDir:  o.TargetDir,
+		Format:     o.Format,
+		Name:       o.Name,
+		BodyPath:   o.BodyPath,
+		UseDscache: o.UseDscache,
 	}
 	var refstr string
 	if err = o.FSIMethods.InitDataset(p, &refstr); err != nil {

cmd/test_runner_test.go

@@ -222,6 +222,7 @@ func (run *TestRunner) ExecCommand(cmdText string) error {
 // ExecCommandWithStdin executes the given command string with the string as stdin content
 func (run *TestRunner) ExecCommandWithStdin(ctx context.Context, cmdText, stdinText string) error {
 	setNoColor(true)
+	run.Streams.In = strings.NewReader(stdinText)
 	cmd, shutdown := NewQriCommand(ctx, run.RepoPath, run.RepoRoot.TestCrypto, run.Streams)
 	cmd.SetOutput(run.OutStream)
 	run.CmdR = cmd