dehub/cmd/dehub/cmd_commit.go

package main

import (
	"context"
	"dehub"
	"errors"
	"fmt"

	"dehub/cmd/dehub/dcmd"

	"gopkg.in/src-d/go-git.v4/plumbing"
)

func cmdCommit(ctx context.Context, cmd *dcmd.Cmd) {
	flag := cmd.FlagSet()
	accountID := flag.String("account-id", "", "Account to sign commit as")

	repo := ctxRepo(ctx)
	accreditAndCommit := func(commit dehub.Commit) error {

		cfg, err := repo.LoadConfig()
		if err != nil {
			return err
		}

		var account dehub.Account
		var ok bool
		for _, account = range cfg.Accounts {
			if account.ID == *accountID {
				ok = true
				break
			}
		}
		if !ok {
			return fmt.Errorf("account ID %q not found in config", *accountID)
		} else if l := len(account.Signifiers); l == 0 || l > 1 {
			return fmt.Errorf("account %q has %d signifiers, only one is supported right now", *accountID, l)
		}

		sig := account.Signifiers[0]
		sigInt, err := sig.Interface(*accountID)
		if err != nil {
			return fmt.Errorf("casting %#v to SignifierInterface: %w", sig, err)

		} else if commit, err = repo.AccreditCommit(commit, sigInt); err != nil {
			return fmt.Errorf("accrediting commit: %w", err)
		}

		gitCommit, err := repo.Commit(commit, *accountID)
		if err != nil {
			return fmt.Errorf("committing to git: %w", err)
		}

		fmt.Printf("committed to HEAD as %s\n", gitCommit.GitCommit.Hash)
		return nil
	}

	var hasStaged bool
	body := func() (context.Context, error) {
		if *accountID == "" {
			return nil, errors.New("-account-id is required")
		}

		var err error
		if hasStaged, err = repo.HasStagedChanges(); err != nil {
			return nil, fmt.Errorf("determining if any changes have been staged: %w", err)
		}
		return ctx, nil
	}

	cmd.SubCmd("change", "Commit file changes",
		func(ctx context.Context, cmd *dcmd.Cmd) {
			flag := cmd.FlagSet()
			msg := flag.String("msg", "", "Commit message")
			cmd.Run(func() (context.Context, error) {
				if !hasStaged {
					return nil, errors.New("no changes have been staged for commit")
				}

				if *msg == "" {
					var err error
					if *msg, err = tmpFileMsg(); err != nil {
						return nil, fmt.Errorf("error collecting commit message from user: %w", err)

					} else if *msg == "" {
						return nil, errors.New("empty commit message, not doing anything")
					}
				}

				commit, err := repo.NewCommitChange(*msg)
				if err != nil {
					return nil, fmt.Errorf("could not construct change commit: %w", err)

				} else if err := accreditAndCommit(commit); err != nil {
					return nil, err
				}
				return nil, nil
			})
		},
	)

	cmd.SubCmd("credential", "Commit credential of a different commit",
		func(ctx context.Context, cmd *dcmd.Cmd) {
			flag := cmd.FlagSet()
			rev := flag.String("rev", "", "Revision of commit to accredit")
			cmd.Run(func() (context.Context, error) {
				if *rev == "" {
					return nil, errors.New("-rev is required")
				} else if hasStaged {
					return nil, errors.New("credential commit cannot have any files changed")
				}

				gitCommit, err := repo.GetGitRevision(plumbing.Revision(*rev))
				if err != nil {
					return nil, fmt.Errorf("resolving revision %q: %w", *rev, err)
				}

				credCommit, err := repo.NewCommitCredential(gitCommit.Interface.GetHash())
				if err != nil {
					return nil, fmt.Errorf("constructing credential commit: %w", err)
				} else if err := accreditAndCommit(credCommit); err != nil {
					return nil, err
				}
				return nil, nil
			})
		},
	)

	cmd.Run(body)
}