From b0a32a786e740d314bfc3d3ae76a698a81c39eb9 Mon Sep 17 00:00:00 2001 From: Máximo Cuadros Date: Thu, 26 Jan 2017 14:31:46 +0100 Subject: config: git modules config --- config/modules.go | 43 +++++++++++++++++++++++++++++++++++++++++++ config/modules_test.go | 23 +++++++++++++++++++++++ 2 files changed, 66 insertions(+) create mode 100644 config/modules.go create mode 100644 config/modules_test.go (limited to 'config') diff --git a/config/modules.go b/config/modules.go new file mode 100644 index 0000000..3f095fa --- /dev/null +++ b/config/modules.go @@ -0,0 +1,43 @@ +package config + +import "errors" + +var ( + ErrModuleEmptyURL = errors.New("module config: empty URL") + ErrModuleEmptyPath = errors.New("module config: empty path") +) + +const DefaultModuleBranch = "master" + +// Modules defines the submodules properties +type Modules map[string]*Module + +// Module defines a submodule +// https://www.kernel.org/pub/software/scm/git/docs/gitmodules.html +type Module struct { + // 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. + Branch string +} + +// Validate validate the fields and set the default values +func (m *Module) Validate() error { + if m.Path == "" { + return ErrModuleEmptyPath + } + + if m.URL == "" { + return ErrModuleEmptyURL + } + + if m.Branch == "" { + m.Branch = DefaultModuleBranch + } + + return nil +} diff --git a/config/modules_test.go b/config/modules_test.go new file mode 100644 index 0000000..50b5691 --- /dev/null +++ b/config/modules_test.go @@ -0,0 +1,23 @@ +package config + +import . "gopkg.in/check.v1" + +type ModuleSuite struct{} + +var _ = Suite(&ModuleSuite{}) + +func (s *ModuleSuite) TestModuleValidateMissingURL(c *C) { + m := &Module{Path: "foo"} + c.Assert(m.Validate(), Equals, ErrModuleEmptyURL) +} + +func (s *ModuleSuite) TestModuleValidateMissingName(c *C) { + m := &Module{URL: "bar"} + c.Assert(m.Validate(), Equals, ErrModuleEmptyPath) +} + +func (s *ModuleSuite) TestModuleValidateDefault(c *C) { + m := &Module{Path: "foo", URL: "http://foo/bar"} + c.Assert(m.Validate(), IsNil) + c.Assert(m.Branch, Equals, DefaultModuleBranch) +} -- cgit From e2e4e7f748b4accf18950e0731248ed4ace63869 Mon Sep 17 00:00:00 2001 From: Máximo Cuadros Date: Thu, 26 Jan 2017 20:53:32 +0100 Subject: config: marshal and unmarshal implementation --- config/config.go | 111 ++++++++++++++++++++++++++++++++++++++++++++++++++ config/config_test.go | 48 +++++++++++++++++++++- 2 files changed, 157 insertions(+), 2 deletions(-) (limited to 'config') diff --git a/config/config.go b/config/config.go index a2b5012..bffb125 100644 --- a/config/config.go +++ b/config/config.go @@ -2,8 +2,11 @@ package config import ( + "bytes" "errors" "fmt" + + "gopkg.in/src-d/go-git.v4/plumbing/format/config" ) const ( @@ -27,17 +30,24 @@ var ( ) // Config contains the repository configuration +// https://www.kernel.org/pub/software/scm/git/docs/git-config.html type Config struct { Core struct { IsBare bool } Remotes map[string]*RemoteConfig + + // contains the raw information of a config file, the main goal is preserve + // the parsed information from the original format, to avoid miss not + // supported properties + raw *config.Config } // NewConfig returns a new empty Config func NewConfig() *Config { return &Config{ Remotes: make(map[string]*RemoteConfig, 0), + raw: config.New(), } } @@ -56,11 +66,82 @@ func (c *Config) Validate() error { return nil } +const ( + remoteSection = "remote" + coreSection = "core" + fetchKey = "fetch" + urlKey = "url" + bareKey = "bare" +) + +// Unmarshal parses a git-config file and stores it +func (c *Config) Unmarshal(b []byte) error { + r := bytes.NewBuffer(b) + d := config.NewDecoder(r) + + c.raw = config.New() + if err := d.Decode(c.raw); err != nil { + return err + } + + c.unmarshalCore() + c.unmarshalRemotes() + return nil +} + +func (c *Config) unmarshalCore() { + s := c.raw.Section(coreSection) + if s.Options.Get(bareKey) == "true" { + c.Core.IsBare = true + } +} + +func (c *Config) unmarshalRemotes() { + s := c.raw.Section(remoteSection) + for _, sub := range s.Subsections { + r := &RemoteConfig{} + r.unmarshal(sub) + + c.Remotes[r.Name] = r + } +} + +// Marshal returns Config encoded as a git-config file +func (c *Config) Marshal() ([]byte, error) { + c.marshalCore() + c.marshalRemotes() + + buf := bytes.NewBuffer(nil) + if err := config.NewEncoder(buf).Encode(c.raw); err != nil { + return nil, err + } + + return buf.Bytes(), nil +} + +func (c *Config) marshalCore() { + s := c.raw.Section(coreSection) + s.SetOption(bareKey, fmt.Sprintf("%t", c.Core.IsBare)) +} + +func (c *Config) marshalRemotes() { + s := c.raw.Section(remoteSection) + s.Subsections = make(config.Subsections, len(c.Remotes)) + + var i int + for _, r := range c.Remotes { + s.Subsections[i] = r.marshal() + i++ + } +} + // RemoteConfig contains the configuration for a given repository type RemoteConfig struct { Name string URL string Fetch []RefSpec + + raw *config.Subsection } // Validate validate the fields and set the default values @@ -79,3 +160,33 @@ func (c *RemoteConfig) Validate() error { return nil } + +func (c *RemoteConfig) unmarshal(s *config.Subsection) { + c.raw = s + + fetch := []RefSpec{} + for _, f := range c.raw.Options.GetAll(fetchKey) { + rs := RefSpec(f) + if rs.IsValid() { + fetch = append(fetch, rs) + } + } + + c.Name = c.raw.Name + c.URL = c.raw.Option(urlKey) + c.Fetch = fetch +} + +func (c *RemoteConfig) marshal() *config.Subsection { + if c.raw == nil { + c.raw = &config.Subsection{} + } + + c.raw.Name = c.Name + c.raw.SetOption(urlKey, c.URL) + for _, rs := range c.Fetch { + c.raw.SetOption(fetchKey, rs.String()) + } + + return c.raw +} diff --git a/config/config_test.go b/config/config_test.go index f2539d0..2bcefe4 100644 --- a/config/config_test.go +++ b/config/config_test.go @@ -6,7 +6,51 @@ type ConfigSuite struct{} var _ = Suite(&ConfigSuite{}) -func (s *ConfigSuite) TestConfigValidateInvalidRemote(c *C) { +func (s *ConfigSuite) TestUnmarshall(c *C) { + input := []byte(`[core] + bare = true +[remote "origin"] + url = git@github.com:mcuadros/go-git.git + fetch = +refs/heads/*:refs/remotes/origin/* +[branch "master"] + remote = origin + merge = refs/heads/master +`) + + cfg := NewConfig() + err := cfg.Unmarshal(input) + c.Assert(err, IsNil) + + c.Assert(cfg.Core.IsBare, Equals, true) + c.Assert(cfg.Remotes, HasLen, 1) + c.Assert(cfg.Remotes["origin"].Name, Equals, "origin") + c.Assert(cfg.Remotes["origin"].URL, Equals, "git@github.com:mcuadros/go-git.git") + c.Assert(cfg.Remotes["origin"].Fetch, DeepEquals, []RefSpec{"+refs/heads/*:refs/remotes/origin/*"}) +} + +func (s *ConfigSuite) TestUnmarshallMarshall(c *C) { + input := []byte(`[core] + bare = true + custom = ignored +[remote "origin"] + url = git@github.com:mcuadros/go-git.git + fetch = +refs/heads/*:refs/remotes/origin/* + mirror = true +[branch "master"] + remote = origin + merge = refs/heads/master +`) + + cfg := NewConfig() + err := cfg.Unmarshal(input) + c.Assert(err, IsNil) + + output, err := cfg.Marshal() + c.Assert(err, IsNil) + c.Assert(output, DeepEquals, input) +} + +func (s *ConfigSuite) TestValidateInvalidRemote(c *C) { config := &Config{ Remotes: map[string]*RemoteConfig{ "foo": {Name: "foo"}, @@ -16,7 +60,7 @@ func (s *ConfigSuite) TestConfigValidateInvalidRemote(c *C) { c.Assert(config.Validate(), Equals, ErrRemoteConfigEmptyURL) } -func (s *ConfigSuite) TestConfigValidateInvalidKey(c *C) { +func (s *ConfigSuite) TestValidateInvalidKey(c *C) { config := &Config{ Remotes: map[string]*RemoteConfig{ "bar": {Name: "foo"}, -- cgit From 4e78181092744896d9fd4b7bcad18f513ce72dcb Mon Sep 17 00:00:00 2001 From: Máximo Cuadros Date: Thu, 26 Jan 2017 23:42:51 +0100 Subject: config: modules, marshal and unmarshal implementation --- config/modules.go | 110 ++++++++++++++++++++++++++++++++++++++++++++----- config/modules_test.go | 70 ++++++++++++++++++++++++++----- 2 files changed, 160 insertions(+), 20 deletions(-) (limited to 'config') diff --git a/config/modules.go b/config/modules.go index 3f095fa..6733884 100644 --- a/config/modules.go +++ b/config/modules.go @@ -1,20 +1,83 @@ package config -import "errors" +import ( + "bytes" + "errors" + + "gopkg.in/src-d/go-git.v4/plumbing/format/config" +) var ( ErrModuleEmptyURL = errors.New("module config: empty URL") ErrModuleEmptyPath = errors.New("module config: empty path") ) -const DefaultModuleBranch = "master" - // Modules defines the submodules properties -type Modules map[string]*Module +type Modules struct { + Submodules map[string]*Submodule + + raw *config.Config +} + +// NewModules returns a new empty Modules +func NewModules() *Modules { + return &Modules{ + Submodules: make(map[string]*Submodule, 0), + raw: config.New(), + } +} + +const ( + submoduleSection = "submodule" + pathKey = "path" + branchKey = "branch" +) + +// Unmarshal parses a git-config file and stores it +func (m *Modules) Unmarshal(b []byte) error { + r := bytes.NewBuffer(b) + d := config.NewDecoder(r) + + m.raw = config.New() + if err := d.Decode(m.raw); err != nil { + return err + } + + s := m.raw.Section(submoduleSection) + for _, sub := range s.Subsections { + mod := &Submodule{} + mod.unmarshal(sub) + + m.Submodules[mod.Path] = mod + } + + return nil +} + +// Marshal returns Modules encoded as a git-config file +func (m *Modules) Marshal() ([]byte, error) { + s := m.raw.Section(submoduleSection) + s.Subsections = make(config.Subsections, len(m.Submodules)) -// Module defines a submodule + var i int + for _, r := range m.Submodules { + s.Subsections[i] = r.marshal() + i++ + } + + buf := bytes.NewBuffer(nil) + if err := config.NewEncoder(buf).Encode(m.raw); err != nil { + return nil, err + } + + return buf.Bytes(), nil +} + +// Submodule defines a submodule // https://www.kernel.org/pub/software/scm/git/docs/gitmodules.html -type Module struct { +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 @@ -23,10 +86,12 @@ type Module struct { // Branch is a remote branch name for tracking updates in the upstream // submodule. Branch string + + raw *config.Subsection } // Validate validate the fields and set the default values -func (m *Module) Validate() error { +func (m *Submodule) Validate() error { if m.Path == "" { return ErrModuleEmptyPath } @@ -35,9 +100,34 @@ func (m *Module) Validate() error { return ErrModuleEmptyURL } - if m.Branch == "" { - m.Branch = DefaultModuleBranch + return nil +} + +func (m *Submodule) unmarshal(s *config.Subsection) { + m.raw = s + + m.Name = m.raw.Name + m.Path = m.raw.Option(pathKey) + m.URL = m.raw.Option(urlKey) + m.Branch = m.raw.Option(branchKey) +} + +func (m *Submodule) marshal() *config.Subsection { + if m.raw == nil { + m.raw = &config.Subsection{} } - return nil + m.raw.Name = m.Name + if m.raw.Name == "" { + m.raw.Name = m.Path + } + + m.raw.SetOption(pathKey, m.Path) + m.raw.SetOption(urlKey, m.URL) + + if m.Branch != "" { + m.raw.SetOption(branchKey, m.Branch) + } + + return m.raw } diff --git a/config/modules_test.go b/config/modules_test.go index 50b5691..34ad17c 100644 --- a/config/modules_test.go +++ b/config/modules_test.go @@ -2,22 +2,72 @@ package config import . "gopkg.in/check.v1" -type ModuleSuite struct{} +type ModulesSuite struct{} -var _ = Suite(&ModuleSuite{}) +var _ = Suite(&ModulesSuite{}) -func (s *ModuleSuite) TestModuleValidateMissingURL(c *C) { - m := &Module{Path: "foo"} +func (s *ModulesSuite) TestValidateMissingURL(c *C) { + m := &Submodule{Path: "foo"} c.Assert(m.Validate(), Equals, ErrModuleEmptyURL) } -func (s *ModuleSuite) TestModuleValidateMissingName(c *C) { - m := &Module{URL: "bar"} +func (s *ModulesSuite) TestValidateMissingName(c *C) { + m := &Submodule{URL: "bar"} c.Assert(m.Validate(), Equals, ErrModuleEmptyPath) } -func (s *ModuleSuite) TestModuleValidateDefault(c *C) { - m := &Module{Path: "foo", URL: "http://foo/bar"} - c.Assert(m.Validate(), IsNil) - c.Assert(m.Branch, Equals, DefaultModuleBranch) +func (s *ModulesSuite) TestMarshall(c *C) { + input := []byte(`[submodule "qux"] + path = qux + url = baz + branch = bar +`) + + cfg := NewModules() + cfg.Submodules["qux"] = &Submodule{Path: "qux", URL: "baz", Branch: "bar"} + + output, err := cfg.Marshal() + c.Assert(err, IsNil) + c.Assert(output, DeepEquals, input) +} + +func (s *ModulesSuite) TestUnmarshall(c *C) { + input := []byte(`[submodule "qux"] + path = qux + url = https://github.com/foo/qux.git +[submodule "foo/bar"] + path = foo/bar + url = https://github.com/foo/bar.git + branch = dev +`) + + cfg := NewModules() + err := cfg.Unmarshal(input) + c.Assert(err, IsNil) + + c.Assert(cfg.Submodules, HasLen, 2) + c.Assert(cfg.Submodules["qux"].Name, Equals, "qux") + c.Assert(cfg.Submodules["qux"].URL, Equals, "https://github.com/foo/qux.git") + c.Assert(cfg.Submodules["foo/bar"].Name, Equals, "foo/bar") + c.Assert(cfg.Submodules["foo/bar"].URL, Equals, "https://github.com/foo/bar.git") + c.Assert(cfg.Submodules["foo/bar"].Branch, Equals, "dev") +} + +func (s *ModulesSuite) TestUnmarshallMarshall(c *C) { + input := []byte(`[submodule "qux"] + path = qux + url = https://github.com/foo/qux.git +[submodule "foo/bar"] + path = foo/bar + url = https://github.com/foo/bar.git + ignore = all +`) + + cfg := NewModules() + err := cfg.Unmarshal(input) + c.Assert(err, IsNil) + + output, err := cfg.Marshal() + c.Assert(err, IsNil) + c.Assert(output, DeepEquals, input) } -- cgit From 7581d7f76a08869ed1ad1384dea1880c635af58b Mon Sep 17 00:00:00 2001 From: Máximo Cuadros Date: Thu, 26 Jan 2017 23:53:15 +0100 Subject: config: documentation improvements --- config/config.go | 43 ++++++++++++++++++++++++++----------------- config/modules.go | 31 +++++++++++++++++-------------- config/modules_test.go | 2 +- 3 files changed, 44 insertions(+), 32 deletions(-) (limited to 'config') diff --git a/config/config.go b/config/config.go index bffb125..fc6d84c 100644 --- a/config/config.go +++ b/config/config.go @@ -6,7 +6,7 @@ import ( "errors" "fmt" - "gopkg.in/src-d/go-git.v4/plumbing/format/config" + format "gopkg.in/src-d/go-git.v4/plumbing/format/config" ) const ( @@ -30,24 +30,28 @@ var ( ) // Config contains the repository configuration -// https://www.kernel.org/pub/software/scm/git/docs/git-config.html +// ftp://www.kernel.org/pub/software/scm/git/docs/git-config.html#FILES type Config struct { + // Core variables Core struct { + // IsBare if true this repository is assumed to be bare and has no + // working directory associated with it IsBare bool } + // Remote list of repository remotes Remotes map[string]*RemoteConfig // contains the raw information of a config file, the main goal is preserve - // the parsed information from the original format, to avoid miss not - // supported properties - raw *config.Config + // the parsed information from the original format, to avoid missing + // unsupported features. + raw *format.Config } // NewConfig returns a new empty Config func NewConfig() *Config { return &Config{ Remotes: make(map[string]*RemoteConfig, 0), - raw: config.New(), + raw: format.New(), } } @@ -77,9 +81,9 @@ const ( // Unmarshal parses a git-config file and stores it func (c *Config) Unmarshal(b []byte) error { r := bytes.NewBuffer(b) - d := config.NewDecoder(r) + d := format.NewDecoder(r) - c.raw = config.New() + c.raw = format.New() if err := d.Decode(c.raw); err != nil { return err } @@ -112,7 +116,7 @@ func (c *Config) Marshal() ([]byte, error) { c.marshalRemotes() buf := bytes.NewBuffer(nil) - if err := config.NewEncoder(buf).Encode(c.raw); err != nil { + if err := format.NewEncoder(buf).Encode(c.raw); err != nil { return nil, err } @@ -126,7 +130,7 @@ func (c *Config) marshalCore() { func (c *Config) marshalRemotes() { s := c.raw.Section(remoteSection) - s.Subsections = make(config.Subsections, len(c.Remotes)) + s.Subsections = make(format.Subsections, len(c.Remotes)) var i int for _, r := range c.Remotes { @@ -135,13 +139,18 @@ func (c *Config) marshalRemotes() { } } -// RemoteConfig contains the configuration for a given repository +// RemoteConfig contains the configuration for a given remote repository type RemoteConfig struct { - Name string - URL string + // Name of the remote + Name string + // URL the URL of a remote repository + URL string + // Fetch the default set of "refspec" for fetch operation Fetch []RefSpec - raw *config.Subsection + // raw representation of the subsection, filled by marshal or unmarshal are + // called + raw *format.Subsection } // Validate validate the fields and set the default values @@ -161,7 +170,7 @@ func (c *RemoteConfig) Validate() error { return nil } -func (c *RemoteConfig) unmarshal(s *config.Subsection) { +func (c *RemoteConfig) unmarshal(s *format.Subsection) { c.raw = s fetch := []RefSpec{} @@ -177,9 +186,9 @@ func (c *RemoteConfig) unmarshal(s *config.Subsection) { c.Fetch = fetch } -func (c *RemoteConfig) marshal() *config.Subsection { +func (c *RemoteConfig) marshal() *format.Subsection { if c.raw == nil { - c.raw = &config.Subsection{} + c.raw = &format.Subsection{} } c.raw.Name = c.Name diff --git a/config/modules.go b/config/modules.go index 6733884..8b3d2b8 100644 --- a/config/modules.go +++ b/config/modules.go @@ -4,7 +4,7 @@ import ( "bytes" "errors" - "gopkg.in/src-d/go-git.v4/plumbing/format/config" + format "gopkg.in/src-d/go-git.v4/plumbing/format/config" ) var ( @@ -12,18 +12,20 @@ var ( ErrModuleEmptyPath = errors.New("module config: empty path") ) -// Modules defines the submodules properties +// Modules defines the submodules properties, represents a .gitmodules file +// https://www.kernel.org/pub/software/scm/git/docs/gitmodules.html type Modules struct { + // Submodules is a map of submodules being the key the name of the submodule Submodules map[string]*Submodule - raw *config.Config + raw *format.Config } // NewModules returns a new empty Modules func NewModules() *Modules { return &Modules{ Submodules: make(map[string]*Submodule, 0), - raw: config.New(), + raw: format.New(), } } @@ -36,9 +38,9 @@ const ( // Unmarshal parses a git-config file and stores it func (m *Modules) Unmarshal(b []byte) error { r := bytes.NewBuffer(b) - d := config.NewDecoder(r) + d := format.NewDecoder(r) - m.raw = config.New() + m.raw = format.New() if err := d.Decode(m.raw); err != nil { return err } @@ -57,7 +59,7 @@ func (m *Modules) Unmarshal(b []byte) error { // Marshal returns Modules encoded as a git-config file func (m *Modules) Marshal() ([]byte, error) { s := m.raw.Section(submoduleSection) - s.Subsections = make(config.Subsections, len(m.Submodules)) + s.Subsections = make(format.Subsections, len(m.Submodules)) var i int for _, r := range m.Submodules { @@ -66,7 +68,7 @@ func (m *Modules) Marshal() ([]byte, error) { } buf := bytes.NewBuffer(nil) - if err := config.NewEncoder(buf).Encode(m.raw); err != nil { + if err := format.NewEncoder(buf).Encode(m.raw); err != nil { return nil, err } @@ -74,7 +76,6 @@ func (m *Modules) Marshal() ([]byte, error) { } // Submodule defines a submodule -// https://www.kernel.org/pub/software/scm/git/docs/gitmodules.html type Submodule struct { // Name module name Name string @@ -84,10 +85,12 @@ type Submodule struct { // 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. + // submodule. Optional value. Branch string - raw *config.Subsection + // raw representation of the subsection, filled by marshal or unmarshal are + // called + raw *format.Subsection } // Validate validate the fields and set the default values @@ -103,7 +106,7 @@ func (m *Submodule) Validate() error { return nil } -func (m *Submodule) unmarshal(s *config.Subsection) { +func (m *Submodule) unmarshal(s *format.Subsection) { m.raw = s m.Name = m.raw.Name @@ -112,9 +115,9 @@ func (m *Submodule) unmarshal(s *config.Subsection) { m.Branch = m.raw.Option(branchKey) } -func (m *Submodule) marshal() *config.Subsection { +func (m *Submodule) marshal() *format.Subsection { if m.raw == nil { - m.raw = &config.Subsection{} + m.raw = &format.Subsection{} } m.raw.Name = m.Name diff --git a/config/modules_test.go b/config/modules_test.go index 34ad17c..ab7b116 100644 --- a/config/modules_test.go +++ b/config/modules_test.go @@ -69,5 +69,5 @@ func (s *ModulesSuite) TestUnmarshallMarshall(c *C) { output, err := cfg.Marshal() c.Assert(err, IsNil) - c.Assert(output, DeepEquals, input) + c.Assert(string(output), DeepEquals, string(input)) } -- cgit