git

type APIError ¶

type APIError struct {
	Provider   string
	Method     string
	URL        string
	StatusCode int
	Body       string
}

APIError is a non-2xx provider API response.

func (e *APIError) Error() string

type Auth ¶

type Auth struct {
	Username   string
	Password   string
	Token      string
	PrivateKey string
	TLS        TLS
}

Auth carries a repository's credentials. HTTP(S) uses Username/Password or Token (sent as Basic auth with the provider's token user); SSH uses PrivateKey, with Password as its passphrase.

func (a Auth) Validate() error

type BlameAuthor ¶ added in v0.1.62

type BlameAuthor struct {
	Name  string `json:"name"`
	Email string `json:"email"`
}

type BlameCommit ¶ added in v0.1.62

type BlameCommit struct {
	SHA     string      `json:"sha"`
	URL     string      `json:"url,omitempty"`
	Author  BlameAuthor `json:"author"`
	Date    time.Time   `json:"date"`
	Subject string      `json:"subject"`
}

type BlameLine ¶ added in v0.1.62

type BlameLine struct {
	Line         int          `json:"line"`
	OriginalLine int          `json:"originalLine"`
	Path         string       `json:"path"`
	Content      string       `json:"content"`
	Commit       *BlameCommit `json:"commit"`
}

BlameLine has no Commit when its content is outside the selected revision.

type BlameOptions ¶ added in v0.1.62

type BlameOptions struct {
	SHA      string
	Path     string
	Contents []byte
}

BlameOptions supplies the displayed contents of a file at an immutable commit.

type BlobRequest ¶ added in v0.1.62

type BlobRequest struct {
	SHA  string
	Path string
}

BlobRequest identifies a literal file path at a full commit SHA.

type BlobResult ¶ added in v0.1.62

type BlobResult struct {
	Content []byte
	Object  string
	Present bool
}

BlobResult distinguishes absent paths from present files with empty content.

type Cache ¶

type Cache struct {
	Root string
}

Cache keeps one bare mirror per repository and worktrees per ref:

<Root>/<RepoURL.CacheKey>/mirror.git
<Root>/<RepoURL.CacheKey>/mirror.lock
<Root>/<RepoURL.CacheKey>/worktrees/<ref dir>[.lock]

mirror.lock serializes fetches and worktree bookkeeping; each worktree is leased exclusively until Release, so concurrent checkouts of different refs proceed while a second checkout of the same ref waits.

func (c *Cache) Apply(ctx context.Context, repo *Repository, request ChangeRequest) (ChangeResult, error)

func (c *Cache) Blame(ctx context.Context, repo *Repository, options BlameOptions) (lines []BlameLine, err error)

func (c *Cache) Changes(ctx context.Context, repo *Repository, options ChangesOptions) ([]Change, error)

func (c *Cache) Checkout(ctx context.Context, repo *Repository, options CheckoutOptions) (*Worktree, error)

func (c *Cache) Compare(ctx context.Context, repo *Repository, base, head string) (Comparison, error)

func (c *Cache) Files(ctx context.Context, repo *Repository, sha string) ([]string, error)

func (c *Cache) History(ctx context.Context, repo *Repository, ref string, options HistoryOptions) ([]Commit, error)

func (c *Cache) Log(ctx context.Context, repo *Repository, options LogOptions) ([]Commit, error)

func (c *Cache) MergeBase(ctx context.Context, repo *Repository, options MergeBaseOptions) (string, error)

func (c *Cache) OpenTree(ctx context.Context, options TreeOptions) (result *Tree, err error)

func (c *Cache) PrepareSource(ctx context.Context, options SourceOptions) (source *PreparedSource, err error)

func (c *Cache) ReadBlobs(ctx context.Context, repo *Repository, requests []BlobRequest) ([]BlobResult, error)

func (c *Cache) Show(ctx context.Context, repo *Repository, sha, path string) ([]byte, error)

type Change ¶ added in v0.1.62

type Change struct {
	Path      string
	Status    FileStatus
	OldObject string
	NewObject string
	OldMode   string
	NewMode   string
}

Change describes a literal path's object and mode changes. Missing objects have empty IDs; mode-only changes keep equal OldObject and NewObject IDs.

type ChangeRequest ¶

type ChangeRequest struct {
	Base               string
	BaseSHA            string
	Branch             string
	Message            string
	Author             Signature
	Source             *Repository
	Head               string
	Rebase             string
	Pick               PickStrategy
	Squash             bool
	CherryPick         []string
	CherryPickMainline int
	AllowEmpty         bool
	Trailers           []string
	Files              []FileChange
	PullRequest        *PullRequestRequest
	Tag                *TagOptions
}

ChangeRequest commits Files on a new Branch cut from Base, pushes it and, optionally, tags the commit and opens a pull request into Base.

BaseSHA, when set, pins the change to the commit the caller verified Files against: the branch is cut from exactly that commit, and a Base whose head is anywhere else fails with ErrBaseMoved before anything is pushed.

CherryPick replays full commit SHAs in order onto the branch (git cherry-pick -x, Author as committer, the original author kept) before Files are committed; Files may then be empty. A conflict aborts with *CherryPickConflictError, a merge commit needs CherryPickMainline (the 1-based parent to replay it against), and a commit already on the base is *CherryPickEmptyError unless AllowEmpty skips it. Trailers ("Key: value" lines) are appended to every replayed commit's message, after its origin line; Message is the message of the Files commit only. Nothing is pushed on any failure.

Head, instead of CherryPick and Files, points Branch at that full commit SHA as is: a pull request of it merges its history into Base. It must share history with Base (ErrUnrelatedHistories) and not already be on it.

Source is the repository the CherryPick, Head or Rebase commits are fetched from when it is not the changed one, e.g. a fork; nil is the changed repository.

Pick is how CherryPick commits land: PickCherryPick (the default) runs git cherry-pick -x and needs history shared with Base; PickReplay applies each commit's patch as a new commit (git format-patch | git am --3way) keeping its message, author and date, and needs no shared history. Squash then folds the landed commits into one: their messages joined in order, the first commit's author and date, a Co-authored-by trailer per other author, then Trailers.

Rebase, instead of CherryPick, Files and Head, rebases the commits of that full SHA which Base lacks onto Base with git rebase: linear, each commit's message, author and date kept, so it takes no Trailers. It must share history with Base (ErrUnrelatedHistories).

type ChangeResult ¶

type ChangeResult struct {
	Branch             string
	CommitSHA          string
	PullRequest        *PullRequest
	Tag                string
	SkippedCherryPicks []string
}

ChangeResult is what Apply pushed and opened. SkippedCherryPicks are the CherryPick commits AllowEmpty skipped as already applied.

type ChangesOptions ¶ added in v0.1.62

type ChangesOptions struct {
	Base string
	Head string
}

ChangesOptions selects the two endpoint trees to compare.

type CheckoutOptions ¶

type CheckoutOptions struct {
	Ref       string
	Depth     int
	Ephemeral bool
}

CheckoutOptions configures Cache.Checkout. Ref is a branch, tag, full ref or 40-char SHA (empty is the remote HEAD). An Ephemeral worktree gets a unique directory removed on Release.

type CherryPickConflictError ¶

type CherryPickConflictError struct {
	Commit string
	Files  []string
}

CherryPickConflictError is a ChangeRequest.CherryPick commit that does not apply cleanly onto the base: the cherry-pick was aborted and nothing was pushed. Files are the paths left unmerged.

func (e *CherryPickConflictError) Error() string

type CherryPickEmptyError ¶

type CherryPickEmptyError struct {
	Commit string
	Base   string
}

CherryPickEmptyError is a ChangeRequest.CherryPick commit whose changes are already on Base (its patch was applied there before): the cherry-pick was aborted and nothing was pushed.

func (e *CherryPickEmptyError) Error() string

type Client ¶

type Client struct {
	Type     string
	Provider Provider
	Auth     Auth
	// contains filtered or unexported fields
}

Client is a git connection: its provider API and the credentials for its repositories.

func FromConnection(ctx dbcontext.Context, conn models.Connection, options ...ClientOptions) (*Client, error)

func (c *Client) Repository(rawURL string) (*Repository, error)

type ClientOptions ¶ added in v0.1.62

type ClientOptions struct {
	TransportPool     *commonshttp.TransportPool
	SecurityNamespace string
}

ClientOptions shares transport connections while keeping middleware per client.

type CloneOptions ¶

type CloneOptions struct {
	Dir   string
	Ref   string
	Depth int
}

CloneOptions configures Clone. An empty Ref is the remote HEAD; Depth 0 fetches full history.

type Commit ¶

type Commit struct {
	SHA      string
	ShortSHA string
	Subject  string
	Body     string
	Author   Signature
	Date     time.Time
	Parents  []string
	Files    []string
	Status   map[string]FileStatus
	Renames  []Rename
}

Commit is one commit as Cache.Log or Cache.History reads it. Files are the paths it changed against its first parent (a rename lists its new path); a merge commit (len(Parents) > 1) lists none. Status and Renames are filled by History only: how each of Files changed, and which renamed from what.

func (c Commit) IsMerge() bool

type CommitOptions ¶

type CommitOptions struct {
	Message string
	Author  Signature
}

CommitOptions configures Worktree.Commit.

type CommitState ¶ added in v0.1.60

type CommitState string

CommitState is a provider-neutral commit status state.

const (
	CommitStatePending CommitState = "pending"
	CommitStateSuccess CommitState = "success"
	CommitStateFailure CommitState = "failure"
	CommitStateError   CommitState = "error"
)

type CommitStatus ¶ added in v0.1.60

type CommitStatus struct {
	State       CommitState
	Context     string
	Description string
	TargetURL   string
}

CommitStatus is a status reported on a commit. Context names the check (statuses with the same context replace each other); TargetURL links to its details.

type Comparison ¶

type Comparison struct {
	Ahead     int
	Behind    int
	MergeBase string
}

Comparison is how head relates to base: Ahead commits on head not on base, Behind commits on base not on head, and their merge base.

type DirtyStats ¶

type DirtyStats struct {
	Staged    int
	Unstaged  int
	Untracked int
	Conflicts int
}

func (s DirtyStats) Clean() bool

type FileChange ¶

type FileChange struct {
	Path    string
	Content []byte
	Delete  bool
}

FileChange writes Content to Path, or deletes Path when Delete is set.

type FileStatus ¶ added in v0.1.60

type FileStatus string

FileStatus is git's --name-status letter for one changed path.

const (
	FileAdded       FileStatus = "A"
	FileModified    FileStatus = "M"
	FileDeleted     FileStatus = "D"
	FileRenamed     FileStatus = "R"
	FileCopied      FileStatus = "C"
	FileTypeChanged FileStatus = "T"
)

type Fingerprint ¶ added in v0.1.62

type Fingerprint struct {
	Root string
	SHA  string
}

func WorktreeFingerprint(ctx context.Context, directory string) (Fingerprint, error)

type HistoryDetail ¶ added in v0.1.62

type HistoryDetail string

HistoryDetail controls the file metadata included with each commit.

const (
	HistoryStatus   HistoryDetail = ""
	HistoryMetadata HistoryDetail = "metadata"
	HistoryNames    HistoryDetail = "names"
)

type HistoryOptions ¶ added in v0.1.60

type HistoryOptions struct {
	Detail HistoryDetail
	Paths  []string
	Follow bool
	Limit  int
	Since  string
	Offset int
}

HistoryOptions configures Cache.History. Paths (matched literally, never as globs) keeps only the commits that touch them; Follow continues one path's history past its renames (git log --follow, so exactly one path); Limit > 0 keeps the newest Limit commits; Since is a git date (--since) bounding how far back to read. Detail controls file metadata; its default detects renames.

type InspectOptions ¶

type InspectOptions struct {
	RepositoryHint string
	BranchHint     string
}

InspectOptions carries the requested URL and ref, which a detached cache worktree cannot report itself.

type LastCommit ¶

type LastCommit struct {
	Subject     string
	Author      string
	CommittedAt time.Time
}

type ListPullRequestsOptions ¶ added in v0.1.60

type ListPullRequestsOptions struct {
	// Base is the branch the pull requests merge into; empty matches any.
	Base string
	// Head is the branch the pull requests merge from; empty matches any.
	Head string
	// State is the state to list; the zero value lists open pull requests.
	State PullRequestState
	// Limit caps how many pull requests are returned, following pages until
	// it is reached; <= 0 means 100.
	Limit int
}

ListPullRequestsOptions filters ListPullRequests.

type ListRepositoriesOptions ¶

type ListRepositoriesOptions struct {
	Namespace string
}

ListRepositoriesOptions scopes ListRepositories. Namespace is a GitHub owner, GitLab group or Azure DevOps project; empty uses the connection's configured namespace, else every repository the credentials can see.

type LogOptions ¶

type LogOptions struct {
	Base     string
	Head     string
	Limit    int
	Paths    []string
	HeadFrom *Repository
}

LogOptions configures Cache.Log. Limit > 0 keeps only the newest Limit commits; Paths (matched literally, never as globs) keeps only the commits that touch them. HeadFrom, when set, is the repository head is read from (e.g. a fork of the logged repository): it resolves and is fetched there, into the logged repository's mirror. A head sharing no history with base lists every commit whose patch base lacks; MergeBase tells the two apart.

type MergeBaseOptions ¶ added in v0.1.62

type MergeBaseOptions struct {
	Base     string
	Head     string
	HeadFrom *Repository
}

MergeBaseOptions configures Cache.MergeBase. HeadFrom is the repository Head is read from (e.g. a fork); nil is the base's own.

type Metadata ¶

type Metadata struct {
	Repository string
	Branch     string
	SHA        string
	Dirty      DirtyStats
	LastCommit LastCommit
}

func Inspect(ctx context.Context, dir string, options InspectOptions) (Metadata, error)

type Page ¶ added in v0.1.62

type Page[T any] struct {
	Items      []T    `json:"items"`
	NextCursor string `json:"nextCursor,omitempty"`
}

type PickStrategy ¶ added in v0.1.62

type PickStrategy string

PickStrategy is how ChangeRequest.CherryPick commits land on the branch.

const (
	// PickCherryPick runs git cherry-pick -x: it records the origin commit and
	// needs history shared with the base. It is the zero value's meaning.
	PickCherryPick PickStrategy = "cherry-pick"
	// PickReplay applies each commit's patch as a new commit (git format-patch
	// | git am --3way), keeping its message, author and date; it needs no
	// shared history and refuses merge commits.
	PickReplay PickStrategy = "replay"
)

type Pipeline ¶ added in v0.1.62

type Pipeline struct {
	ID    string `json:"id"`
	Name  string `json:"name"`
	Path  string `json:"path,omitempty"`
	URL   string `json:"url,omitempty"`
	State string `json:"state,omitempty"`
}

type PipelineExecution ¶ added in v0.1.62

type PipelineExecution struct {
	ID        string    `json:"id"`
	Pipeline  string    `json:"pipeline"`
	Number    string    `json:"number"`
	Name      string    `json:"name"`
	Attempt   int       `json:"attempt,omitempty"`
	Branch    string    `json:"branch"`
	SHA       string    `json:"sha"`
	Status    string    `json:"status"`
	Result    string    `json:"result,omitempty"`
	Author    string    `json:"author,omitempty"`
	CreatedAt time.Time `json:"createdAt"`
	URL       string    `json:"url,omitempty"`
}

type PipelineOptions ¶ added in v0.1.62

type PipelineOptions struct {
	Repository RepoURL
	Pipeline   string
	Branch     string
	Cursor     string
	Limit      int
}

type PipelineProvider ¶ added in v0.1.62

type PipelineProvider interface {
	ListPipelines(context.Context, PipelineOptions) (Page[Pipeline], error)
	ListPipelineExecutions(context.Context, PipelineOptions) (Page[PipelineExecution], error)
}

func PipelineAPI(provider Provider) (PipelineProvider, error)

type PreparedSource ¶ added in v0.1.62

type PreparedSource struct {
	// contains filtered or unexported fields
}

PreparedSource owns an isolated tree, or borrows the live working tree for SourceWorktree.

func (s *PreparedSource) Changes() []SourceChange

func (s *PreparedSource) Info() SourceInfo

func (s *PreparedSource) Release() error

type Provider ¶

type Provider interface {
	// Type is the models.ConnectionType* of the provider.
	Type() string
	// Verify checks the credentials against the provider.
	Verify(ctx context.Context) error
	ListRepositories(ctx context.Context, options ListRepositoriesOptions) ([]RepositoryInfo, error)
	// SupportsPullRequests reports whether OpenPullRequest can succeed, so a
	// change can be refused before anything is pushed.
	SupportsPullRequests() bool
	OpenPullRequest(ctx context.Context, repo RepoURL, request PullRequestRequest) (PullRequest, error)
	GetPullRequest(ctx context.Context, repo RepoURL, number int) (PullRequest, error)
	ListPullRequestActivity(ctx context.Context, repo RepoURL, number int) ([]PullRequestActivity, error)
	ListPullRequests(ctx context.Context, repo RepoURL, options ListPullRequestsOptions) ([]PullRequest, error)
	ClosePullRequest(ctx context.Context, repo RepoURL, number int) error
	// SetCommitStatus reports a commit status (a check) on sha.
	SetCommitStatus(ctx context.Context, repo RepoURL, sha string, status CommitStatus) error
	// CommentPullRequest adds a comment to the pull request and returns the
	// comment's web URL.
	CommentPullRequest(ctx context.Context, repo RepoURL, number int, body string) (string, error)
}

Provider is a git hosting provider's REST API.

type PullRequest ¶

type PullRequest struct {
	Number    int
	URL       string
	State     PullRequestState
	Head      string
	Base      string
	Title     string
	Author    string
	Body      string
	CreatedAt time.Time
	// HeadSHA is the commit the head branch points at.
	HeadSHA string
	// HeadRepository is the full name (as RepositoryInfo.FullName) of the
	// repository the head branch lives in: the fork for a fork pull request,
	// the pull request's own repository otherwise. Empty only when the
	// provider no longer knows it (GitHub: a deleted fork).
	HeadRepository string
	Metadata       *PullRequestMetadata
}

PullRequest is an opened pull (or merge) request.

type PullRequestActivity ¶ added in v0.1.60

type PullRequestActivity struct {
	Kind      PullRequestActivityKind `json:"kind"`
	Author    string                  `json:"author"`
	Body      string                  `json:"body"`
	CreatedAt time.Time               `json:"createdAt"`
	URL       string                  `json:"url,omitempty"`
	ID        string                  `json:"id,omitempty"`
	Action    string                  `json:"action,omitempty"`
	UpdatedAt time.Time               `json:"updatedAt,omitempty"`
	Mentions  []string                `json:"mentions,omitempty"`
}

type PullRequestActivityKind ¶ added in v0.1.60

type PullRequestActivityKind string

const (
	PullRequestComment PullRequestActivityKind = "comment"
	PullRequestHistory PullRequestActivityKind = "history"
)

type PullRequestCheck ¶ added in v0.1.62

type PullRequestCheck struct {
	Name     string `json:"name"`
	State    string `json:"state"`
	URL      string `json:"url,omitempty"`
	Required bool   `json:"required,omitempty"`
}

type PullRequestChecksReader ¶ added in v0.1.62

type PullRequestChecksReader interface {
	PullRequestChecks(context.Context, RepoURL, PullRequest) ([]PullRequestCheck, error)
}

type PullRequestMetadata ¶ added in v0.1.62

type PullRequestMetadata struct {
	Author          string             `json:"author"`
	AuthorAvatarURL string             `json:"authorAvatarUrl,omitempty"`
	CreatedAt       time.Time          `json:"createdAt"`
	BaseSHA         string             `json:"baseSha,omitempty"`
	HeadSHA         string             `json:"headSha"`
	HeadBranch      string             `json:"headBranch"`
	BaseBranch      string             `json:"baseBranch"`
	HeadBranchURL   string             `json:"headBranchUrl,omitempty"`
	HeadCommitURL   string             `json:"headCommitUrl,omitempty"`
	BaseBranchURL   string             `json:"baseBranchUrl,omitempty"`
	BaseCommitURL   string             `json:"baseCommitUrl,omitempty"`
	Mergeability    string             `json:"mergeability"`
	MergeReason     string             `json:"mergeReason,omitempty"`
	Draft           bool               `json:"draft,omitempty"`
	Checks          []PullRequestCheck `json:"checks"`
}

func ReadPullRequestMetadata(ctx context.Context, provider Provider, repo RepoURL, options PullRequestMetadataOptions) (*PullRequestMetadata, error)

type PullRequestMetadataOptions ¶ added in v0.1.62

type PullRequestMetadataOptions struct {
	Number  int
	BaseSHA string
}

type PullRequestPolicy ¶ added in v0.1.60

type PullRequestPolicy struct {
	ID                   int
	Name                 string
	Status               string
	Required             bool
	BuildID              int
	URL                  string
	MinimumApproverCount int
}

type PullRequestRequest ¶

type PullRequestRequest struct {
	Title     string
	Body      string
	Head      string
	Base      string
	Draft     bool
	Labels    []string
	Assignees []string
	Reviewers []string
	AutoMerge bool
}

PullRequestRequest opens a pull request from Head into Base.

type PullRequestReview ¶ added in v0.1.60

type PullRequestReview struct {
	Policies  []PullRequestPolicy
	Reviewers []PullRequestReviewer
}

type PullRequestReviewReader ¶ added in v0.1.60

type PullRequestReviewReader interface {
	PullRequestReview(ctx context.Context, repo RepoURL, number int) (PullRequestReview, error)
}

PullRequestReviewReader reads a host's current review and merge requirements.

type PullRequestReviewer ¶ added in v0.1.60

type PullRequestReviewer struct {
	ID       string
	Name     string
	Required bool
	Vote     int
}

type PullRequestState ¶

type PullRequestState string

PullRequestState is a provider-neutral pull request state.

const (
	PullRequestOpen   PullRequestState = "open"
	PullRequestClosed PullRequestState = "closed"
	PullRequestMerged PullRequestState = "merged"
)

type PushOptions ¶

type PushOptions struct {
	Branch        string
	RemoteBranch  string
	Tags          []string
	Force         bool
	ExpectedSHA   string
	ServerOptions []string
}

PushOptions configures Worktree.Push. Branch is a local branch pushed to RemoteBranch (default: the same name). A push never overwrites history unless Force is set, and then only with --force-with-lease against ExpectedSHA. ServerOptions are sent as git push options (-o).

type Ref ¶

type Ref struct {
	Name      string
	FullName  string
	SHA       string
	Kind      RefKind
	Annotated bool
}

Ref is a remote ref resolved to a commit. For an annotated tag SHA is the peeled commit and Annotated is set.

func Clone(ctx context.Context, repo *Repository, options CloneOptions) (Ref, error)

type RefKind ¶

type RefKind string

RefKind is what a resolved ref names.

const (
	RefBranch RefKind = "branch"
	RefTag    RefKind = "tag"
	// RefHead is a remote HEAD that is not a symbolic ref to a branch.
	RefHead RefKind = "head"
	// RefSHA is a full commit SHA given directly.
	RefSHA RefKind = "sha"
)

type RemoteRefs ¶

type RemoteRefs struct {
	Head     *Ref
	Branches []Ref
	Tags     []Ref
}

RemoteRefs are the branches and tags a remote advertises, plus its HEAD.

func (r RemoteRefs) Resolve(name string) (Ref, error)

type Rename ¶ added in v0.1.60

type Rename struct {
	From string
	To   string
}

Rename is a path a commit moved From one name To another.

type RepoURL ¶

type RepoURL struct {
	Clone    string
	Scheme   string
	Host     string
	Path     string
	Provider string
	// Owner is the GitHub owner, the GitLab group path (nested groups joined
	// with "/"), or the Azure DevOps organization.
	Owner string
	// Project is the Azure DevOps project; empty elsewhere.
	Project string
	Name    string
	// Ref and Depth come from the ?ref= and ?depth= query parameters.
	Ref   string
	Depth *int
	User  string
}

RepoURL is a parsed repository URL. Clone is what git is given: the URL without query, fragment or password.

func ParseRepoURL(raw, providerHint string) (RepoURL, error)

func (u RepoURL) CacheKey() string

func (u RepoURL) CommitURL(sha string) (string, error)

func (u RepoURL) FileURL(ref Ref, path string) (string, error)

func (u RepoURL) FullName() string

func (u RepoURL) Redacted() string

func (u RepoURL) RefWebURL(options WebRefOptions) (string, error)

func (u RepoURL) Short() string

func (u RepoURL) SourceRepository(name string) (RepoURL, error)

type Repository ¶

type Repository struct {
	URL  RepoURL
	Auth Auth
	// Provider opens pull requests; nil or a generic git provider has none.
	Provider Provider
}

Repository is one remote repository with the credentials to reach it and, when it is hosted on a supported provider, that provider's API.

func NewRepository(options RepositoryOptions) (*Repository, error)

func (r *Repository) LsRemote(ctx context.Context) (refs RemoteRefs, err error)

func (r *Repository) OpenPullRequest(ctx context.Context, request PullRequestRequest) (PullRequest, error)

func (r *Repository) Resolve(ctx context.Context, ref string) (Ref, error)

type RepositoryInfo ¶

type RepositoryInfo struct {
	Name          string
	FullName      string
	Namespace     string
	CloneURL      string
	SSHURL        string
	WebURL        string
	DefaultBranch string
	Private       bool
	Archived      bool
}

RepositoryInfo is one repository as the provider lists it.

type RepositoryOptions ¶

type RepositoryOptions struct {
	URL      string
	Auth     Auth
	Provider Provider
	// ProviderType is the URL parsing hint (models.ConnectionType*); it
	// defaults to Provider.Type().
	ProviderType string
}

RepositoryOptions configures NewRepository.

type Signature ¶

type Signature struct {
	Name  string
	Email string
}

Signature is a commit author or tag tagger.

func DefaultIdentity(ctx context.Context) (Signature, error)

type SourceChange ¶ added in v0.1.62

type SourceChange struct {
	Path   string
	Status FileStatus
}

SourceChange uses a slash-separated, repository-relative literal path. Renames are a deletion and addition.

type SourceInfo ¶ added in v0.1.62

type SourceInfo struct {
	Kind           SourceKind
	RepositoryRoot string
	Dir            string
	// BaseCommit is empty for an initial commit or an unborn checkout.
	BaseCommit string
	// TargetCommit is populated only for SourceCommit.
	TargetCommit string
	// TreeID is the native Git tree ID for commit and staged sources; live worktrees have none.
	TreeID string
}

SourceInfo separates the source's temporary read location from its original checkout and Git identity.

type SourceKind ¶ added in v0.1.62

type SourceKind string

const (
	SourceWorktree SourceKind = "worktree"
	SourceCommit   SourceKind = "commit"
	SourceStaged   SourceKind = "staged"
)

type SourceOptions ¶ added in v0.1.62

type SourceOptions struct {
	Directory string
	Kind      SourceKind
	// Revision is required only for SourceCommit: one commit, A..B, or A...B.
	Revision string
}

SourceOptions selects a local repository source. Directory may be any directory inside its checkout.

type TLS ¶

type TLS struct {
	CA                 string
	Cert               string
	Key                string
	InsecureSkipVerify bool
}

TLS customizes HTTPS verification: an extra CA bundle (added to the system pool), a client certificate for mutual TLS, or no verification at all. InsecureSkipVerify also disables SSH host-key checking.

type TagOptions ¶

type TagOptions struct {
	Name    string
	Message string
	Tagger  Signature
}

TagOptions configures Worktree.CreateTag; an empty Message makes a lightweight tag.

type Tree ¶ added in v0.1.62

type Tree struct {
	// contains filtered or unexported fields
}

Tree is a read-only filesystem over one immutable Git commit.

func (t *Tree) Close() error

func (t *Tree) Info() TreeInfo

func (t *Tree) Metadata(options InspectOptions) (Metadata, error)

func (t *Tree) Open(name string) (fs.File, error)

func (t *Tree) ReadDir(name string) ([]fs.DirEntry, error)

func (t *Tree) ReadFile(name string) ([]byte, error)

type TreeInfo ¶ added in v0.1.62

type TreeInfo struct {
	SHA          string
	GitDirectory string
}

TreeInfo identifies a tree's immutable commit and original object database.

type TreeOptions ¶ added in v0.1.62

type TreeOptions struct {
	Repository *Repository
	Directory  string
	Revision   string
}

TreeOptions selects an immutable commit from one cached remote repository or one existing local repository. Directory accepts working and bare repositories.

type VisiblePaths ¶ added in v0.1.60

type VisiblePaths struct {
	// contains filtered or unexported fields
}

VisiblePaths contains tracked and unignored files and their parent directories. Outside a Git checkout, every filesystem path is visible.

func ListVisiblePaths(ctx context.Context, directory string) (VisiblePaths, error)

func (visible VisiblePaths) Contains(path string) bool

func (visible VisiblePaths) IsIgnored(ctx context.Context, path string) (bool, error)

type WebRefOptions ¶ added in v0.1.62

type WebRefOptions struct {
	Repository string
	Ref        string
	Kind       RefKind
}

type Worktree ¶

type Worktree struct {
	Dir string
	Ref Ref
	// contains filtered or unexported fields
}

Worktree is a leased checkout from a Cache. Release it when done.

func (w *Worktree) Commit(ctx context.Context, options CommitOptions) (string, error)

func (w *Worktree) CreateBranch(ctx context.Context, name string) error

func (w *Worktree) CreateTag(ctx context.Context, options TagOptions) error

func (w *Worktree) DeleteFile(path string) error

func (w *Worktree) Push(ctx context.Context, options PushOptions) error

func (w *Worktree) Release() error

func (w *Worktree) WriteFile(path string, content []byte) error