go-git.v4: gopkg.in/src-d/go-git.v4/plumbing/format/config Index | Files

package config

import "gopkg.in/src-d/go-git.v4/plumbing/format/config"

Package config implements encoding and decoding of git config files.

Configuration File
------------------

The Git configuration file contains a number of variables that affect
the Git commands' behavior. The `.git/config` file in each repository
is used to store the configuration for that repository, and
`$HOME/.gitconfig` is used to store a per-user configuration as
fallback values for the `.git/config` file. The file `/etc/gitconfig`
can be used to store a system-wide default configuration.

The configuration variables are used by both the Git plumbing
and the porcelains. The variables are divided into sections, wherein
the fully qualified variable name of the variable itself is the last
dot-separated segment and the section name is everything before the last
dot. The variable names are case-insensitive, allow only alphanumeric
characters and `-`, and must start with an alphabetic character.  Some
variables may appear multiple times; we say then that the variable is
multivalued.

Syntax
~~~~~~

The syntax is fairly flexible and permissive; whitespaces are mostly
ignored.  The '#' and ';' characters begin comments to the end of line,
blank lines are ignored.

The file consists of sections and variables.  A section begins with
the name of the section in square brackets and continues until the next
section begins.  Section names are case-insensitive.  Only alphanumeric
characters, `-` and `.` are allowed in section names.  Each variable
must belong to some section, which means that there must be a section
header before the first setting of a variable.

Sections can be further divided into subsections.  To begin a subsection
put its name in double quotes, separated by space from the section name,
in the section header, like in the example below:

--------
	[section "subsection"]

--------

Subsection names are case sensitive and can contain any characters except
newline (doublequote `"` and backslash can be included by escaping them
as `\"` and `\\`, respectively).  Section headers cannot span multiple
lines.  Variables may belong directly to a section or to a given subsection.
You can have `[section]` if you have `[section "subsection"]`, but you
don't need to.

There is also a deprecated `[section.subsection]` syntax. With this
syntax, the subsection name is converted to lower-case and is also
compared case sensitively. These subsection names follow the same
restrictions as section names.

All the other lines (and the remainder of the line after the section
header) are recognized as setting variables, in the form
'name = value' (or just 'name', which is a short-hand to say that
the variable is the boolean "true").
The variable names are case-insensitive, allow only alphanumeric characters
and `-`, and must start with an alphabetic character.

A line that defines a value can be continued to the next line by
ending it with a `\`; the backquote and the end-of-line are
stripped.  Leading whitespaces after 'name =', the remainder of the
line after the first comment character '#' or ';', and trailing
whitespaces of the line are discarded unless they are enclosed in
double quotes.  Internal whitespaces within the value are retained
verbatim.

Inside double quotes, double quote `"` and backslash `\` characters
must be escaped: use `\"` for `"` and `\\` for `\`.

The following escape sequences (beside `\"` and `\\`) are recognized:
`\n` for newline character (NL), `\t` for horizontal tabulation (HT, TAB)
and `\b` for backspace (BS).  Other char escape sequences (including octal
escape sequences) are invalid.

Includes
~~~~~~~~

You can include one config file from another by setting the special
`include.path` variable to the name of the file to be included. The
variable takes a pathname as its value, and is subject to tilde
expansion.

The included file is expanded immediately, as if its contents had been
found at the location of the include directive. If the value of the
`include.path` variable is a relative path, the path is considered to be
relative to the configuration file in which the include directive was
found.  See below for examples.

Example
~~~~~~~

	# Core variables
	[core]
		; Don't trust file modes
		filemode = false

	# Our diff algorithm
	[diff]
		external = /usr/local/bin/diff-wrapper
		renames = true

	[branch "devel"]
		remote = origin
		merge = refs/heads/devel

	# Proxy settings
	[core]
		gitProxy="ssh" for "kernel.org"
		gitProxy=default-proxy ; for the rest

	[include]
		path = /path/to/foo.inc ; include by absolute path
		path = foo ; expand "foo" relative to the current file
		path = ~/foo ; expand "foo" in your `$HOME` directory

Index

Package Files

common.go decoder.go doc.go encoder.go option.go section.go

Constants

const (
    // NoSubsection token is passed to Config.Section and Config.SetSection to
    // represent the absence of a section.
    NoSubsection = ""
)

type Comment Uses

type Comment string

Comment string without the prefix '#' or ';'.

type Config Uses

type Config struct {
    Comment  *Comment
    Sections Sections
    Includes Includes
}

Config contains all the sections, comments and includes from a config file.

func New Uses

func New() *Config

New creates a new config instance.

func (*Config) AddOption Uses

func (c *Config) AddOption(section string, subsection string, key string, value string) *Config

AddOption adds an option to a given section and subsection. Use the NoSubsection constant for the subsection argument if no subsection is wanted.

func (*Config) RemoveSection Uses

func (c *Config) RemoveSection(name string) *Config

RemoveSection removes a section from a config file.

func (*Config) RemoveSubsection Uses

func (c *Config) RemoveSubsection(section string, subsection string) *Config

RemoveSubsection remove s a subsection from a config file.

func (*Config) Section Uses

func (c *Config) Section(name string) *Section

Section returns a existing section with the given name or creates a new one.

func (*Config) SetOption Uses

func (c *Config) SetOption(section string, subsection string, key string, value string) *Config

SetOption sets an option to a given section and subsection. Use the NoSubsection constant for the subsection argument if no subsection is wanted.

type Decoder Uses

type Decoder struct {
    io.Reader
}

A Decoder reads and decodes config files from an input stream.

func NewDecoder Uses

func NewDecoder(r io.Reader) *Decoder

NewDecoder returns a new decoder that reads from r.

func (*Decoder) Decode Uses

func (d *Decoder) Decode(config *Config) error

Decode reads the whole config from its input and stores it in the value pointed to by config.

type Encoder Uses

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

An Encoder writes config files to an output stream.

func NewEncoder Uses

func NewEncoder(w io.Writer) *Encoder

NewEncoder returns a new encoder that writes to w.

func (*Encoder) Encode Uses

func (e *Encoder) Encode(cfg *Config) error

Encode writes the config in git config format to the stream of the encoder.

type Include Uses

type Include struct {
    Path   string
    Config *Config
}

Include is a reference to an included config file.

type Includes Uses

type Includes []*Include

Includes is a list of Includes in a config file.

type Option Uses

type Option struct {
    // Key preserving original caseness.
    // Use IsKey instead to compare key regardless of caseness.
    Key string
    // Original value as string, could be not normalized.
    Value string
}

Option defines a key/value entity in a config file.

func (*Option) IsKey Uses

func (o *Option) IsKey(key string) bool

IsKey returns true if the given key matches this option's key in a case-insensitive comparison.

type Options Uses

type Options []*Option

func (Options) Get Uses

func (opts Options) Get(key string) string

Get gets the value for the given key if set, otherwise it returns the empty string.

Note that there is no difference

This matches git behaviour since git v1.8.1-rc1, if there are multiple definitions of a key, the last one wins.

See: http://article.gmane.org/gmane.linux.kernel/1407184

In order to get all possible values for the same key, use GetAll.

func (Options) GetAll Uses

func (opts Options) GetAll(key string) []string

GetAll returns all possible values for the same key.

func (Options) GoString Uses

func (opts Options) GoString() string

type Section Uses

type Section struct {
    Name        string
    Options     Options
    Subsections Subsections
}

Section is the representation of a section inside git configuration files. Each Section contains Options that are used by both the Git plumbing and the porcelains. Sections can be further divided into subsections. To begin a subsection put its name in double quotes, separated by space from the section name, in the section header, like in the example below:

[section "subsection"]

All the other lines (and the remainder of the line after the section header) are recognized as option variables, in the form "name = value" (or just name, which is a short-hand to say that the variable is the boolean "true"). The variable names are case-insensitive, allow only alphanumeric characters and -, and must start with an alphabetic character:

[section "subsection1"]
    option1 = value1
    option2
[section "subsection2"]
    option3 = value2

func (*Section) AddOption Uses

func (s *Section) AddOption(key string, value string) *Section

AddOption adds a new Option to the Section. The updated Section is returned.

func (*Section) HasSubsection Uses

func (s *Section) HasSubsection(name string) bool

HasSubsection checks if the Section has a Subsection with the specified name.

func (*Section) IsName Uses

func (s *Section) IsName(name string) bool

IsName checks if the name provided is equals to the Section name, case insensitive.

func (*Section) Option Uses

func (s *Section) Option(key string) string

Option return the value for the specified key. Empty string is returned if key does not exists.

func (*Section) RemoveOption Uses

func (s *Section) RemoveOption(key string) *Section

Remove an option with the specified key. The updated Section is returned.

func (*Section) SetOption Uses

func (s *Section) SetOption(key string, value string) *Section

SetOption adds a new Option to the Section. If the option already exists, is replaced. The updated Section is returned.

func (*Section) Subsection Uses

func (s *Section) Subsection(name string) *Subsection

Subsection returns a Subsection from the specified Section. If the Subsection does not exists, new one is created and added to Section.

type Sections Uses

type Sections []*Section

func (Sections) GoString Uses

func (s Sections) GoString() string

type Subsection Uses

type Subsection struct {
    Name    string
    Options Options
}

func (*Subsection) AddOption Uses

func (s *Subsection) AddOption(key string, value string) *Subsection

AddOption adds a new Option to the Subsection. The updated Subsection is returned.

func (*Subsection) IsName Uses

func (s *Subsection) IsName(name string) bool

IsName checks if the name of the subsection is exactly the specified name.

func (*Subsection) Option Uses

func (s *Subsection) Option(key string) string

Option returns an option with the specified key. If the option does not exists, empty spring will be returned.

func (*Subsection) RemoveOption Uses

func (s *Subsection) RemoveOption(key string) *Subsection

RemoveOption removes the option with the specified key. The updated Subsection is returned.

func (*Subsection) SetOption Uses

func (s *Subsection) SetOption(key string, value ...string) *Subsection

SetOption adds a new Option to the Subsection. If the option already exists, is replaced. The updated Subsection is returned.

type Subsections Uses

type Subsections []*Subsection

func (Subsections) GoString Uses

func (s Subsections) GoString() string

Package config imports 4 packages (graph) and is imported by 13 packages. Updated 2019-08-03. Refresh now. Tools for package owners.