func produceCommits(ctx context.Context, cloneURL *url.URL) <-chan commitProduct {
	out := make(chan commitProduct, 1)
	done := func(err error) {
		out <- commitProduct{
			Err: err,
		}
	}

	dir := tmp.ForURL(cloneURL)
	go func() {
		defer func() {
			// TODO: bring back?
			if err := os.RemoveAll(dir); err != nil {
				done(err)
			}
			close(out)
		}()

		buf := bytes.NewBuffer(nil)
		repo, err := git.PlainCloneContext(ctx, dir, false, &git.CloneOptions{
			URL:      cloneURL.String(),
			Progress: buf,
			// NoCheckout: true,
		})
		if err != nil {
			var ert *fs.PathError
			switch {
			case errors.As(err, &ert):
				done(ert)
				return
			case errors.Is(err, git.ErrRepositoryAlreadyExists):
				repo, err = git.PlainOpenWithOptions(dir, &git.PlainOpenOptions{})
				if err != nil {
					done(err)
					return
				}
			case errors.Is(err, git.ErrRemoteExists):
			default:
				done(err)
				return
			}
		}

		iter, err := repo.CommitObjects()
		if err != nil {
			done(err)
			return
		}

		err = iter.ForEach(func(commit *object.Commit) error {
			select {
			case <-ctx.Done():
				return ctx.Err()
			default:
			}

			wt, err := repo.Worktree()
			if err != nil {
				return err
			}

			if err := wt.Checkout(&git.CheckoutOptions{Hash: commit.Hash, Force: true, Keep: false}); err != nil {
				if errors.Is(err, git.NoErrAlreadyUpToDate) {
					return nil
				}

				return err
			}

			out <- commitProduct{
				Hash: commit.Hash,
				Dir:  dir,
			}

			return nil
		})
		if err != nil {
			done(err)
			return
		}
	}()

	return out
}

// 拉取代码
func (p *Puller) Pull(ctx context.Context) error {
	p.logger.Printf("Pulling %s\n", p.options.Repo)

	p.logger.Printf("拉取项目到目录 %s\n", p.options.Dir)

	switch {
	// 按 Hash 克隆
	case p.options.Hash != nil && *p.options.Hash != "":
		if err := util.EnsureDir(p.options.Dir); err != nil {
			return errors.WithStack(err)
		}

		if err := shell.Run(ctx, "git init", p.options.Writer, p.options.Dir); err != nil {
			return errors.WithStack(err)
		}

		if err := shell.Run(ctx, fmt.Sprintf("git fetch --no-tags --recurse-submodules --depth 1 --no-write-fetch-head %s %s", p.options.Repo, *p.options.Hash), p.options.Writer, p.options.Dir); err != nil {
			return errors.WithStack(err)
		}

		if err := shell.Run(ctx, fmt.Sprintf("git checkout %s", *p.options.Hash), p.options.Writer, p.options.Dir); err != nil {
			return errors.WithStack(err)
		}
	// 按 Tag 克隆
	case p.options.Tag != "":
		fallthrough
	// 按分支克隆
	case p.options.Branch != "":
		var target string

		if p.options.Tag != "" {
			target = p.options.Tag
		} else {
			target = p.options.Branch
		}

		parentFolder := filepath.Dir(p.options.Dir)
		folderName := filepath.Base(p.options.Dir)

		if err := os.RemoveAll(p.options.Dir); err != nil {
			return errors.WithStack(err)
		}

		if err := shell.Run(ctx, fmt.Sprintf("git clone --single-branch --depth 1 --no-tags --progress --branch %s %s %s", target, p.options.Repo, folderName), p.options.Writer, parentFolder); err != nil {
			return errors.WithStack(err)
		}
	default:
		parentFolder := filepath.Dir(p.options.Dir)
		folderName := filepath.Base(p.options.Dir)

		if err := util.EnsureDir(parentFolder); err != nil {
			return errors.WithStack(err)
		}

		if err := shell.Run(ctx, fmt.Sprintf("git clone %s %s", p.options.Repo, folderName), p.options.Writer, parentFolder); err != nil {
			return errors.WithStack(err)
		}
	}

	if p.options.Recurse {
		if err := shell.Run(ctx, "git submodule update --init --recursive --single-branch --depth 1 --checkout --force --progress", p.options.Writer, p.options.Dir); err != nil {
			return errors.WithStack(err)
		}
	}

	// 更新子模块
	if p.options.Submodule != nil {
		for submodule, config := range *p.options.Submodule {
			if !config.Latest {
				continue
			}

			if err := shell.Run(ctx, fmt.Sprintf("git submodule update --remote --recursive --depth 1 --progress %s", submodule), p.options.Writer, p.options.Dir); err != nil {
				return errors.WithStack(err)
			}
		}
	}

	return nil
}