Documentation

Overview

    Package config contains the abstraction of multiple config files

    Index

    Constants

    View Source
    const (
    	// DefaultFetchRefSpec is the default refspec used for fetch.
    	DefaultFetchRefSpec = "+refs/heads/*:refs/remotes/%s/*"
    	// DefaultPushRefSpec is the default refspec used for push.
    	DefaultPushRefSpec = "refs/heads/*:refs/heads/*"
    )
    View Source
    const (
    
    	// DefaultPackWindow holds the number of previous objects used to
    	// generate deltas. The value 10 is the same used by git command.
    	DefaultPackWindow = uint(10)
    )

    Variables

    View Source
    var (
    	ErrInvalid               = errors.New("config invalid key in remote or branch")
    	ErrRemoteConfigNotFound  = errors.New("remote config not found")
    	ErrRemoteConfigEmptyURL  = errors.New("remote config: empty URL")
    	ErrRemoteConfigEmptyName = errors.New("remote config: empty name")
    )
    View Source
    var (
    	ErrModuleEmptyURL  = errors.New("module config: empty URL")
    	ErrModuleEmptyPath = errors.New("module config: empty path")
    	ErrModuleBadPath   = errors.New("submodule has an invalid path")
    )
    View Source
    var (
    	ErrRefSpecMalformedSeparator = errors.New("malformed refspec, separators are wrong")
    	ErrRefSpecMalformedWildcard  = errors.New("malformed refspec, mismatched number of wildcards")
    )

    Functions

    func MatchAny

    func MatchAny(l []RefSpec, n plumbing.ReferenceName) bool

      MatchAny returns true if any of the RefSpec match with the given ReferenceName.

      Types

      type Branch

      type Branch struct {
      	// Name of branch
      	Name string
      	// Remote name of remote to track
      	Remote string
      	// Merge is the local refspec for the branch
      	Merge plumbing.ReferenceName
      	// Rebase instead of merge when pulling. Valid values are
      	// "true" and "interactive".  "false" is undocumented and
      	// typically represented by the non-existence of this field
      	Rebase string
      	// contains filtered or unexported fields
      }

        Branch contains information on the local branches and which remote to track

        func (*Branch) Validate

        func (b *Branch) Validate() error

          Validate validates fields of branch

          type Config

          type Config struct {
          	Core struct {
          		// IsBare if true this repository is assumed to be bare and has no
          		// working directory associated with it.
          		IsBare bool
          		// Worktree is the path to the root of the working tree.
          		Worktree string
          		// CommentChar is the character indicating the start of a
          		// comment for commands like commit and tag
          		CommentChar string
          	}
          
          	Pack struct {
          		// Window controls the size of the sliding window for delta
          		// compression.  The default is 10.  A value of 0 turns off
          		// delta compression entirely.
          		Window uint
          	}
          
          	// Remotes list of repository remotes, the key of the map is the name
          	// of the remote, should equal to RemoteConfig.Name.
          	Remotes map[string]*RemoteConfig
          	// Submodules list of repository submodules, the key of the map is the name
          	// of the submodule, should equal to Submodule.Name.
          	Submodules map[string]*Submodule
          	// Branches list of branches, the key is the branch name and should
          	// equal Branch.Name
          	Branches map[string]*Branch
          	// Raw contains the raw information of a config file. The main goal is
          	// preserve the parsed information from the original format, to avoid
          	// dropping unsupported fields.
          	Raw *format.Config
          }

            Config contains the repository configuration ftp://www.kernel.org/pub/software/scm/git/docs/git-config.html#FILES

            func NewConfig

            func NewConfig() *Config

              NewConfig returns a new empty Config.

              func (*Config) Marshal

              func (c *Config) Marshal() ([]byte, error)

                Marshal returns Config encoded as a git-config file.

                func (*Config) Unmarshal

                func (c *Config) Unmarshal(b []byte) error

                  Unmarshal parses a git-config file and stores it.

                  func (*Config) Validate

                  func (c *Config) Validate() error

                    Validate validates the fields and sets the default values.

                    type ConfigStorer

                    type ConfigStorer interface {
                    	Config() (*Config, error)
                    	SetConfig(*Config) error
                    }

                      ConfigStorer generic storage of Config object

                      type Modules

                      type Modules struct {
                      	// Submodules is a map of submodules being the key the name of the submodule.
                      	Submodules map[string]*Submodule
                      	// contains filtered or unexported fields
                      }

                        Modules defines the submodules properties, represents a .gitmodules file https://www.kernel.org/pub/software/scm/git/docs/gitmodules.html

                        func NewModules

                        func NewModules() *Modules

                          NewModules returns a new empty Modules

                          func (*Modules) Marshal

                          func (m *Modules) Marshal() ([]byte, error)

                            Marshal returns Modules encoded as a git-config file.

                            func (*Modules) Unmarshal

                            func (m *Modules) Unmarshal(b []byte) error

                              Unmarshal parses a git-config file and stores it.

                              type RefSpec

                              type RefSpec string

                                RefSpec is a mapping from local branches to remote references. The format of the refspec is an optional +, followed by <src>:<dst>, where <src> is the pattern for references on the remote side and <dst> is where those references will be written locally. The + tells Git to update the reference even if it isn’t a fast-forward. eg.: "+refs/heads/*:refs/remotes/origin/*"

                                https://git-scm.com/book/es/v2/Git-Internals-The-Refspec

                                func (RefSpec) Dst

                                  Dst returns the destination for the given remote reference.

                                  func (RefSpec) IsDelete

                                  func (s RefSpec) IsDelete() bool

                                    IsDelete returns true if the refspec indicates a delete (empty src).

                                    func (RefSpec) IsForceUpdate

                                    func (s RefSpec) IsForceUpdate() bool

                                      IsForceUpdate returns if update is allowed in non fast-forward merges.

                                      func (RefSpec) IsWildcard

                                      func (s RefSpec) IsWildcard() bool

                                        IsWildcard returns true if the RefSpec contains a wildcard.

                                        func (RefSpec) Match

                                        func (s RefSpec) Match(n plumbing.ReferenceName) bool

                                          Match match the given plumbing.ReferenceName against the source.

                                          func (RefSpec) Reverse

                                          func (s RefSpec) Reverse() RefSpec

                                          func (RefSpec) Src

                                          func (s RefSpec) Src() string

                                            Src return the src side.

                                            func (RefSpec) String

                                            func (s RefSpec) String() string

                                            func (RefSpec) Validate

                                            func (s RefSpec) Validate() error

                                              Validate validates the RefSpec

                                              type RemoteConfig

                                              type RemoteConfig struct {
                                              	// Name of the remote
                                              	Name string
                                              	// URLs the URLs of a remote repository. It must be non-empty. Fetch will
                                              	// always use the first URL, while push will use all of them.
                                              	URLs []string
                                              	// Fetch the default set of "refspec" for fetch operation
                                              	Fetch []RefSpec
                                              	// contains filtered or unexported fields
                                              }

                                                RemoteConfig contains the configuration for a given remote repository.

                                                func (*RemoteConfig) IsFirstURLLocal

                                                func (c *RemoteConfig) IsFirstURLLocal() bool

                                                func (*RemoteConfig) Validate

                                                func (c *RemoteConfig) Validate() error

                                                  Validate validates the fields and sets the default values.

                                                  type Submodule

                                                  type Submodule struct {
                                                  	// Name module name
                                                  	Name string
                                                  	// Path defines the path, relative to the top-level directory of the Git
                                                  	// working tree.
                                                  	Path string
                                                  	// URL defines a URL from which the submodule repository can be cloned.
                                                  	URL string
                                                  	// Branch is a remote branch name for tracking updates in the upstream
                                                  	// submodule. Optional value.
                                                  	Branch string
                                                  	// contains filtered or unexported fields
                                                  }

                                                    Submodule defines a submodule.

                                                    func (*Submodule) Validate

                                                    func (m *Submodule) Validate() error

                                                      Validate validates the fields and sets the default values.