github.com/goreleaser/nfpm/v2@v2.44.0/internal/cmd/package.go (about)

     1  package cmd
     2  
     3  import (
     4  	"errors"
     5  	"fmt"
     6  	"os"
     7  	"path"
     8  	"path/filepath"
     9  	"strings"
    10  
    11  	"github.com/goreleaser/nfpm/v2"
    12  	"github.com/spf13/cobra"
    13  )
    14  
    15  type packageCmd struct {
    16  	cmd      *cobra.Command
    17  	config   string
    18  	target   string
    19  	packager string
    20  }
    21  
    22  func newPackageCmd() *packageCmd {
    23  	root := &packageCmd{}
    24  	cmd := &cobra.Command{
    25  		Use:               "package",
    26  		Aliases:           []string{"pkg", "p"},
    27  		Short:             "Creates a package based on the given config file and flags",
    28  		SilenceUsage:      true,
    29  		SilenceErrors:     true,
    30  		Args:              cobra.NoArgs,
    31  		ValidArgsFunction: cobra.NoFileCompletions,
    32  		RunE: func(*cobra.Command, []string) error {
    33  			return doPackage(root.config, root.target, root.packager)
    34  		},
    35  	}
    36  
    37  	cmd.Flags().StringVarP(&root.config, "config", "f", "nfpm.yaml", "config file to be used")
    38  	_ = cmd.MarkFlagFilename("config", "yaml", "yml")
    39  	cmd.Flags().StringVarP(&root.target, "target", "t", "", "where to save the generated package (filename, folder or empty for current folder)")
    40  	_ = cmd.MarkFlagFilename("target")
    41  
    42  	pkgs := nfpm.Enumerate()
    43  
    44  	cmd.Flags().StringVarP(&root.packager, "packager", "p", "",
    45  		fmt.Sprintf("which packager implementation to use [%s]", strings.Join(pkgs, "|")))
    46  	_ = cmd.RegisterFlagCompletionFunc("packager", cobra.FixedCompletions(pkgs,
    47  		cobra.ShellCompDirectiveNoFileComp,
    48  	))
    49  
    50  	root.cmd = cmd
    51  	return root
    52  }
    53  
    54  var errInsufficientParams = errors.New("a packager must be specified if target is a directory or blank")
    55  
    56  // nolint:funlen
    57  func doPackage(configPath, target, packager string) error {
    58  	targetIsADirectory := false
    59  	stat, err := os.Stat(target)
    60  	if err == nil && stat.IsDir() {
    61  		targetIsADirectory = true
    62  	}
    63  
    64  	if packager == "" {
    65  		ext := filepath.Ext(target)
    66  		if targetIsADirectory || ext == "" {
    67  			return errInsufficientParams
    68  		}
    69  
    70  		packager = ext[1:]
    71  		fmt.Println("guessing packager from target file extension...")
    72  	}
    73  
    74  	config, err := nfpm.ParseFile(configPath)
    75  	if err != nil {
    76  		return err
    77  	}
    78  
    79  	info, err := config.Get(packager)
    80  	if err != nil {
    81  		return err
    82  	}
    83  
    84  	info = nfpm.WithDefaults(info)
    85  
    86  	fmt.Printf("using %s packager...\n", packager)
    87  	pkg, err := nfpm.Get(packager)
    88  	if err != nil {
    89  		return err
    90  	}
    91  
    92  	if target == "" {
    93  		// if no target was specified create a package in
    94  		// current directory with a conventional file name
    95  		target = pkg.ConventionalFileName(info)
    96  	} else if targetIsADirectory {
    97  		// if a directory was specified as target, create
    98  		// a package with conventional file name there
    99  		target = path.Join(target, pkg.ConventionalFileName(info))
   100  	}
   101  
   102  	f, err := os.Create(target)
   103  	if err != nil {
   104  		return err
   105  	}
   106  	defer f.Close()
   107  
   108  	info.Target = target
   109  
   110  	if err := pkg.Package(info, f); err != nil {
   111  		os.Remove(target)
   112  		return err
   113  	}
   114  
   115  	fmt.Printf("created package: %s\n", target)
   116  	return f.Close()
   117  }