git

package
v2.0.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 16, 2020 License: Apache-2.0 Imports: 4 Imported by: 15

Documentation

Overview

Package git Main package of the git commands.

Reference: https://git-scm.com/docs/

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func Add 

func Add(options ...types.Option) (string, error)

Add https://git-scm.com/docs/git-add

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/add"
	"github.com/ldez/go-git-cmd-wrapper/v2/git"
)

func main() {
	out, _ := git.Add(add.All, git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git add --all

func AddWithContext 

func AddWithContext(ctx context.Context, options ...types.Option) (string, error)

AddWithContext https://git-scm.com/docs/git-add

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/add"
	"github.com/ldez/go-git-cmd-wrapper/v2/git"
)

func main() {
	out, _ := git.AddWithContext(context.Background(), add.All, git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git add --all

func Branch 

func Branch(options ...types.Option) (string, error)

Branch https://git-scm.com/docs/git-branch

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/branch"
	"github.com/ldez/go-git-cmd-wrapper/v2/git"
)

func main() {
	out, _ := git.Branch(branch.DeleteForce, branch.BranchName("myBranch"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git branch -D myBranch

func BranchWithContext 

func BranchWithContext(ctx context.Context, options ...types.Option) (string, error)

BranchWithContext https://git-scm.com/docs/git-branch

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/branch"
	"github.com/ldez/go-git-cmd-wrapper/v2/git"
)

func main() {
	out, _ := git.BranchWithContext(context.Background(), branch.DeleteForce, branch.BranchName("myBranch"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git branch -D myBranch

func Checkout 

func Checkout(options ...types.Option) (string, error)

Checkout https://git-scm.com/docs/git-checkout

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/checkout"
	"github.com/ldez/go-git-cmd-wrapper/v2/git"
)

func main() {
	out, _ := git.Checkout(checkout.NewBranch("myBranchName"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git checkout -b myBranchName

func CheckoutWithContext 

func CheckoutWithContext(ctx context.Context, options ...types.Option) (string, error)

CheckoutWithContext https://git-scm.com/docs/git-checkout

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/checkout"
	"github.com/ldez/go-git-cmd-wrapper/v2/git"
)

func main() {
	out, _ := git.CheckoutWithContext(context.Background(), checkout.NewBranch("myBranchName"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git checkout -b myBranchName

func Clone 

func Clone(options ...types.Option) (string, error)

Clone https://git-scm.com/docs/git-clone

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/clone"
	"github.com/ldez/go-git-cmd-wrapper/v2/git"
)

func main() {
	out, _ := git.Clone(clone.Repository("git@github.com:ldez/go-git-cmd-wrapper.git"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git clone git@github.com:ldez/go-git-cmd-wrapper.git

func CloneWithContext 

func CloneWithContext(ctx context.Context, options ...types.Option) (string, error)

CloneWithContext https://git-scm.com/docs/git-clone

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/clone"
	"github.com/ldez/go-git-cmd-wrapper/v2/git"
)

func main() {
	out, _ := git.CloneWithContext(context.Background(), clone.Repository("git@github.com:ldez/go-git-cmd-wrapper.git"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git clone git@github.com:ldez/go-git-cmd-wrapper.git

func CmdExecutor 

func CmdExecutor(executor types.Executor) types.Option

CmdExecutor Allow to override the Git command call (useful for testing purpose)

func Commit 

func Commit(options ...types.Option) (string, error)

Commit https://git-scm.com/docs/git-commit

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/commit"
	"github.com/ldez/go-git-cmd-wrapper/v2/git"
)

func main() {
	out, _ := git.Commit(commit.Amend, commit.Message("chore: foo"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git commit --amend --message="chore: foo"

func CommitWithContext 

func CommitWithContext(ctx context.Context, options ...types.Option) (string, error)

CommitWithContext https://git-scm.com/docs/git-commit

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/commit"
	"github.com/ldez/go-git-cmd-wrapper/v2/git"
)

func main() {
	out, _ := git.CommitWithContext(context.Background(), commit.Amend, commit.Message("chore: foo"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git commit --amend --message="chore: foo"

func Cond 

func Cond(apply bool, options ...types.Option) types.Option

Cond apply conditionally some options

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"
	"github.com/ldez/go-git-cmd-wrapper/v2/push"
)

func main() {
	param := false
	out, _ := git.Push(push.All, git.Cond(param, push.DryRun), push.FollowTags, push.ReceivePack("aaa"), git.CmdExecutor(cmdExecutorMock))

	fmt.Print(out)

	param = true
	out, _ = git.Push(push.All, git.Cond(param, push.DryRun), push.FollowTags, push.ReceivePack("aaa"), git.CmdExecutor(cmdExecutorMock))

	fmt.Print(out)

}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git push --all --follow-tags --receive-pack=aaa
git push --all --dry-run --follow-tags --receive-pack=aaa

func Config 

func Config(options ...types.Option) (string, error)

Config https://git-scm.com/docs/git-config

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/config"
	"github.com/ldez/go-git-cmd-wrapper/v2/git"
)

func main() {
	out, _ := git.Config(config.Entry("rebase.autoSquash", "true"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git config rebase.autoSquash true

func ConfigWithContext 

func ConfigWithContext(ctx context.Context, options ...types.Option) (string, error)

ConfigWithContext https://git-scm.com/docs/git-config

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/config"
	"github.com/ldez/go-git-cmd-wrapper/v2/git"
)

func main() {
	out, _ := git.ConfigWithContext(context.Background(), config.Entry("rebase.autoSquash", "true"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git config rebase.autoSquash true

func Debug 

func Debug(g *types.Cmd)

Debug display command line

func Debugger 

func Debugger(debug bool) types.Option

Debugger display command line

func Fetch 

func Fetch(options ...types.Option) (string, error)

Fetch https://git-scm.com/docs/git-fetch

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/fetch"
	"github.com/ldez/go-git-cmd-wrapper/v2/git"
)

func main() {
	out, _ := git.Fetch(fetch.NoTags, fetch.Remote("upstream"), fetch.RefSpec("myBranchName"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git fetch --no-tags upstream myBranchName

func FetchWithContext 

func FetchWithContext(ctx context.Context, options ...types.Option) (string, error)

FetchWithContext https://git-scm.com/docs/git-fetch

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/fetch"
	"github.com/ldez/go-git-cmd-wrapper/v2/git"
)

func main() {
	out, _ := git.FetchWithContext(context.Background(), fetch.NoTags, fetch.Remote("upstream"), fetch.RefSpec("myBranchName"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git fetch --no-tags upstream myBranchName

func Init 

func Init(options ...types.Option) (string, error)

Init https://git-scm.com/docs/git-init

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"

	ginit "github.com/ldez/go-git-cmd-wrapper/v2/init"
)

func main() {
	out, _ := git.Init(ginit.Bare, ginit.Quiet, ginit.Directory("foobar"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git init --bare --quiet foobar

func InitWithContext 

func InitWithContext(ctx context.Context, options ...types.Option) (string, error)

InitWithContext https://git-scm.com/docs/git-init

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"

	ginit "github.com/ldez/go-git-cmd-wrapper/v2/init"
)

func main() {
	out, _ := git.InitWithContext(context.Background(), ginit.Bare, ginit.Quiet, ginit.Directory("foobar"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git init --bare --quiet foobar

func LogOutput 

func LogOutput(w io.Writer) types.Option

LogOutput Writer used by the internal logger.

func Merge 

func Merge(options ...types.Option) (string, error)

Merge https://git-scm.com/docs/git-merge

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"
	"github.com/ldez/go-git-cmd-wrapper/v2/merge"
)

func main() {
	out, _ := git.Merge(merge.Squash, merge.Commits("myBranch"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git merge --squash myBranch

func MergeWithContext 

func MergeWithContext(ctx context.Context, options ...types.Option) (string, error)

MergeWithContext https://git-scm.com/docs/git-merge

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"
	"github.com/ldez/go-git-cmd-wrapper/v2/merge"
)

func main() {
	out, _ := git.MergeWithContext(context.Background(), merge.Squash, merge.Commits("myBranch"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git merge --squash myBranch

func NoOp 

func NoOp(_ *types.Cmd)

NoOp do nothing.

func Pull 

func Pull(options ...types.Option) (string, error)

Pull https://git-scm.com/docs/git-pull

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"
	"github.com/ldez/go-git-cmd-wrapper/v2/pull"
)

func main() {
	out, _ := git.Pull(pull.All, pull.Force, pull.Repository("upstream"), pull.Refspec("master"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git pull --all --force upstream master

func PullWithContext 

func PullWithContext(ctx context.Context, options ...types.Option) (string, error)

PullWithContext https://git-scm.com/docs/git-pull

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"
	"github.com/ldez/go-git-cmd-wrapper/v2/pull"
)

func main() {
	out, _ := git.PullWithContext(context.Background(), pull.All, pull.Force, pull.Repository("upstream"), pull.Refspec("master"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git pull --all --force upstream master

func Push 

func Push(options ...types.Option) (string, error)

Push https://git-scm.com/docs/git-push

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"
	"github.com/ldez/go-git-cmd-wrapper/v2/push"
)

func main() {
	out, _ := git.Push(push.All, push.FollowTags, push.ReceivePack("aaa"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git push --all --follow-tags --receive-pack=aaa

func PushWithContext 

func PushWithContext(ctx context.Context, options ...types.Option) (string, error)

PushWithContext https://git-scm.com/docs/git-push

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"
	"github.com/ldez/go-git-cmd-wrapper/v2/push"
)

func main() {
	out, _ := git.PushWithContext(context.Background(), push.All, push.FollowTags, push.ReceivePack("aaa"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git push --all --follow-tags --receive-pack=aaa

func Raw 

func Raw(cmd string, options ...types.Option) (string, error)

Raw use to execute arbitrary git commands.

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"
	"github.com/ldez/go-git-cmd-wrapper/v2/types"
)

func main() {
	out, _ := git.Raw("stash", git.CmdExecutor(cmdExecutorMock), func(g *types.Cmd) {
		g.AddOptions("list")
		g.AddOptions("--pretty=format:'%Cblue%gd%Creset%Cred:%Creset %C(yellow)%s%Creset'")
	})

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git stash list --pretty=format:'%Cblue%gd%Creset%Cred:%Creset %C(yellow)%s%Creset'

func RawWithContext 

func RawWithContext(ctx context.Context, cmd string, options ...types.Option) (string, error)

RawWithContext use to execute arbitrary git commands.

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"
	"github.com/ldez/go-git-cmd-wrapper/v2/types"
)

func main() {
	out, _ := git.RawWithContext(context.Background(), "stash", git.CmdExecutor(cmdExecutorMock), func(g *types.Cmd) {
		g.AddOptions("list")
		g.AddOptions("--pretty=format:'%Cblue%gd%Creset%Cred:%Creset %C(yellow)%s%Creset'")
	})

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git stash list --pretty=format:'%Cblue%gd%Creset%Cred:%Creset %C(yellow)%s%Creset'

func Rebase 

func Rebase(options ...types.Option) (string, error)

Rebase https://git-scm.com/docs/git-rebase

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"
	"github.com/ldez/go-git-cmd-wrapper/v2/rebase"
)

func main() {
	out, _ := git.Rebase(rebase.PreserveMerges, rebase.Branch(fmt.Sprintf("%s/%s", "upstream", "master")), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git rebase --preserve-merges upstream/master

func RebaseWithContext 

func RebaseWithContext(ctx context.Context, options ...types.Option) (string, error)

RebaseWithContext https://git-scm.com/docs/git-rebase

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"
	"github.com/ldez/go-git-cmd-wrapper/v2/rebase"
)

func main() {
	out, _ := git.RebaseWithContext(context.Background(), rebase.PreserveMerges, rebase.Branch(fmt.Sprintf("%s/%s", "upstream", "master")), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git rebase --preserve-merges upstream/master

func Remote 

func Remote(options ...types.Option) (string, error)

Remote https://git-scm.com/docs/git-remote

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"
	"github.com/ldez/go-git-cmd-wrapper/v2/remote"
)

func main() {
	out, _ := git.Remote(remote.Add("upstream", "git@github.com:johndoe/go-git-cmd-wrapper.git"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git remote add upstream git@github.com:johndoe/go-git-cmd-wrapper.git

func RemoteWithContext 

func RemoteWithContext(ctx context.Context, options ...types.Option) (string, error)

RemoteWithContext https://git-scm.com/docs/git-remote

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"
	"github.com/ldez/go-git-cmd-wrapper/v2/remote"
)

func main() {
	out, _ := git.RemoteWithContext(context.Background(), remote.Add("upstream", "git@github.com:johndoe/go-git-cmd-wrapper.git"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git remote add upstream git@github.com:johndoe/go-git-cmd-wrapper.git

func Reset 

func Reset(options ...types.Option) (string, error)

Reset https://git-scm.com/docs/git-reset

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"
	"github.com/ldez/go-git-cmd-wrapper/v2/reset"
)

func main() {
	out, _ := git.Reset(reset.Soft, reset.Commit("e41f083"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git reset --soft e41f083

func ResetWithContext 

func ResetWithContext(ctx context.Context, options ...types.Option) (string, error)

ResetWithContext https://git-scm.com/docs/git-reset

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"
	"github.com/ldez/go-git-cmd-wrapper/v2/reset"
)

func main() {
	out, _ := git.ResetWithContext(context.Background(), reset.Soft, reset.Commit("e41f083"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git reset --soft e41f083

func RevParse 

func RevParse(options ...types.Option) (string, error)

RevParse https://git-scm.com/docs/git-rev-parse

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"
	"github.com/ldez/go-git-cmd-wrapper/v2/revparse"
)

func main() {
	out, _ := git.RevParse(revparse.AbbrevRef(""), revparse.Args("HEAD"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git rev-parse --abbrev-ref HEAD

func RevParseWithContext 

func RevParseWithContext(ctx context.Context, options ...types.Option) (string, error)

RevParseWithContext https://git-scm.com/docs/git-rev-parse

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"
	"github.com/ldez/go-git-cmd-wrapper/v2/revparse"
)

func main() {
	out, _ := git.RevParseWithContext(context.Background(), revparse.AbbrevRef(""), revparse.Args("HEAD"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git rev-parse --abbrev-ref HEAD

func Status 

func Status(options ...types.Option) (string, error)

Status https://git-scm.com/docs/git-status

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"
	"github.com/ldez/go-git-cmd-wrapper/v2/status"
)

func main() {
	out, _ := git.Status(status.Short, status.Branch, git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git status --short --branch

func StatusWithContext 

func StatusWithContext(ctx context.Context, options ...types.Option) (string, error)

StatusWithContext https://git-scm.com/docs/git-status

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"
	"github.com/ldez/go-git-cmd-wrapper/v2/status"
)

func main() {
	out, _ := git.StatusWithContext(context.Background(), status.Short, status.Branch, git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git status --short --branch

func Tag 

func Tag(options ...types.Option) (string, error)

Tag https://git-scm.com/docs/git-tag

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"
	"github.com/ldez/go-git-cmd-wrapper/v2/tag"
)

func main() {
	out, _ := git.Tag(tag.List, git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git tag --list

func TagWithContext 

func TagWithContext(ctx context.Context, options ...types.Option) (string, error)

TagWithContext https://git-scm.com/docs/git-tag

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"
	"github.com/ldez/go-git-cmd-wrapper/v2/tag"
)

func main() {
	out, _ := git.TagWithContext(context.Background(), tag.List, git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git tag --list

func Worktree 

func Worktree(options ...types.Option) (string, error)

Worktree https://git-scm.com/docs/git-worktree

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"
	"github.com/ldez/go-git-cmd-wrapper/v2/worktree"
)

func main() {
	out, _ := git.Worktree(worktree.Add("v1.0", "origin/v1.0"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git worktree add v1.0 origin/v1.0

func WorktreeWithContext 

func WorktreeWithContext(ctx context.Context, options ...types.Option) (string, error)

WorktreeWithContext https://git-scm.com/docs/git-worktree

Example 
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/ldez/go-git-cmd-wrapper/v2/git"
	"github.com/ldez/go-git-cmd-wrapper/v2/worktree"
)

func main() {
	out, _ := git.WorktreeWithContext(context.Background(), worktree.Add("v1.0", "origin/v1.0"), git.CmdExecutor(cmdExecutorMock))

	fmt.Println(out)
}

func cmdExecutorMock(_ context.Context, name string, _ bool, args ...string) (string, error) {
	return fmt.Sprintln(name, strings.Join(args, " ")), nil
}

Output:

git worktree add v1.0 origin/v1.0

Types

This section is empty.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.