package/zip: don't export Root right now as a public API

Author: mitchellh

package/zip/zip.go

@@ -17,12 +17,6 @@ type Options struct {
 	// Files to add to the zip package.
 	Files []string
 
-	// Root is the directory to use as the root of the zip file. This can
-	// optionally be set to specify additional files that you want within
-	// the zip. If this isn't set, we'll create a root with the files specified
-	// in Files.
-	Root string
-
 	// OutputPath is the path where the zip file will be written. The directory
 	// containing this path must already exist. If a file already exist here
 	// it will be overwritten.
@@ -36,23 +30,6 @@ type Options struct {
 	BaseCmd *exec.Cmd
 }
 
-func dittoCmd(ctx context.Context, cmd *exec.Cmd) (*exec.Cmd, error) {
-	path, err := exec.LookPath("ditto")
-	if err != nil {
-		return nil, err
-	}
-
-	// We only set the path if it isn't set. This lets the options set the
-	// path to the codesigning binary that we use.
-	if cmd == nil {
-		cmd = exec.CommandContext(ctx, path)
-	} else if cmd.Path == "" {
-		cmd.Path = path
-	}
-
-	return cmd, nil
-}
-
 // Zip creates a zip archive for notarization using the options given.
 //
 // For now this works by subprocessing to "ditto" which is the recommended
@@ -65,65 +42,16 @@ func Zip(ctx context.Context, opts *Options) error {
 		logger = hclog.NewNullLogger()
 	}
 
-	// Set our root directory. If one wasn't specified, we create an empty
-	// temporary directory to act as our root and we copy over the source files
-	root := opts.Root
-	if root == "" {
-		var td string
-		var err error
-		td, err = ioutil.TempDir("", "gon-createzip")
-		if err != nil {
-			return err
-		}
-		defer os.RemoveAll(td)
-		root = td
-
-		// Build our copy command
-		var cmd *exec.Cmd
-		if opts.BaseCmd != nil {
-			cmdCopy := *opts.BaseCmd
-			cmd = &cmdCopy
-		}
-		if cmd, err = dittoCmd(ctx, cmd); err != nil {
-			return err
-		}
-
-		cmd.Args = []string{
-			filepath.Base(cmd.Path),
-		}
-		cmd.Args = append(cmd.Args, opts.Files...)
-		cmd.Args = append(cmd.Args, root)
-
-		// We store all output in out for logging and in case there is an error
-		var out bytes.Buffer
-		cmd.Stdout = &out
-		cmd.Stderr = cmd.Stdout
-
-		// Log what we're going to execute
-		logger.Info("executing ditto to copy files for archiving",
-			"output_path", opts.OutputPath,
-			"command_path", cmd.Path,
-			"command_args", cmd.Args,
-		)
-
-		// Execute copy
-		if err = cmd.Run(); err != nil {
-			logger.Error(
-				"error copying source files to create zip archive",
-				"err", err,
-				"output", out.String(),
-			)
-			return err
-		}
+	// Setup our root directory with the given files.
+	root, err := createRoot(ctx, logger, opts)
+	if err != nil {
+		return err
 	}
+	defer os.RemoveAll(root)
 
-	var cmd *exec.Cmd
-	var err error
-	if opts.BaseCmd != nil {
-		cmdCopy := *opts.BaseCmd
-		cmd = &cmdCopy
-	}
-	if cmd, err = dittoCmd(ctx, cmd); err != nil {
+	// Make our command for creating the archive
+	cmd, err := dittoCmd(ctx, opts.BaseCmd)
+	if err != nil {
 		return err
 	}
 
@@ -156,3 +84,84 @@ func Zip(ctx context.Context, opts *Options) error {
 	logger.Info("zip archive creation complete", "output", out.String())
 	return nil
 }
+
+// dittoCmd returns an *exec.Cmd ready for executing `ditto` based on
+// the given base command.
+func dittoCmd(ctx context.Context, base *exec.Cmd) (*exec.Cmd, error) {
+	path, err := exec.LookPath("ditto")
+	if err != nil {
+		return nil, err
+	}
+
+	// Copy the base command so we don't modify it. If it isn't set then
+	// we create a new command.
+	var cmd *exec.Cmd
+	if base == nil {
+		cmd = exec.CommandContext(ctx, path)
+	} else {
+		cmdCopy := *base
+		cmd = &cmdCopy
+	}
+
+	// We only set the path if it isn't set. This lets the options set the
+	// path to the codesigning binary that we use.
+	if cmd.Path == "" {
+		cmd.Path = path
+	}
+
+	return cmd, nil
+}
+
+// createRoot creates a root directory we can use `ditto` that contains all
+// the given Files as input. This lets us support multiple files.
+//
+// If the returned directory value is non-empty, you must defer to remove
+// the directory since it is meant to be a temporary directory.
+//
+// The directory is guaranteed to be empty if error is non-nil.
+func createRoot(ctx context.Context, logger hclog.Logger, opts *Options) (string, error) {
+	// Build our copy command
+	cmd, err := dittoCmd(ctx, opts.BaseCmd)
+	if err != nil {
+		return "", err
+	}
+
+	// Create our root directory
+	root, err := ioutil.TempDir("", "gon-createzip")
+	if err != nil {
+		return "", err
+	}
+
+	// Setup our args to copy our files into the root
+	cmd.Args = []string{
+		filepath.Base(cmd.Path),
+	}
+	cmd.Args = append(cmd.Args, opts.Files...)
+	cmd.Args = append(cmd.Args, root)
+
+	// We store all output in out for logging and in case there is an error
+	var out bytes.Buffer
+	cmd.Stdout = &out
+	cmd.Stderr = cmd.Stdout
+
+	// Log what we're going to execute
+	logger.Info("executing ditto to copy files for archiving",
+		"output_path", opts.OutputPath,
+		"command_path", cmd.Path,
+		"command_args", cmd.Args,
+	)
+
+	// Execute copy
+	if err = cmd.Run(); err != nil {
+		os.RemoveAll(root)
+
+		logger.Error(
+			"error copying source files to create zip archive",
+			"err", err,
+			"output", out.String(),
+		)
+		return "", err
+	}
+
+	return root, nil
+}