This is an automated email from the ASF dual-hosted git repository.

andk pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/mynewt-newt.git


The following commit(s) were added to refs/heads/master by this push:
     new 6a8f4079 Allow to add external repos from pkg.yml
6a8f4079 is described below

commit 6a8f407909f61a339d28a67532a1d895c95a96a1
Author: Michal Gorecki <[email protected]>
AuthorDate: Mon Feb 20 11:12:25 2023 +0100

    Allow to add external repos from pkg.yml
    
    This allows to add exernal repositories to pkg.yml files.
    Repositories will be downloaded when "newt upgrade" command
    is called. The syntax of adding new repo to the pkg.yml file
    is the same as adding new repo to the project.yml file.
---
 newt/cli/project_cmds.go      |  2 ++
 newt/interfaces/interfaces.go |  3 +++
 newt/pkg/localpackage.go      |  4 ++++
 newt/project/project.go       | 39 +++++++++++++++++++++++++++++++++++++++
 newt/repo/repo.go             |  7 +++++++
 5 files changed, 55 insertions(+)

diff --git a/newt/cli/project_cmds.go b/newt/cli/project_cmds.go
index 2dd3a6e4..2d5f57f8 100644
--- a/newt/cli/project_cmds.go
+++ b/newt/cli/project_cmds.go
@@ -124,6 +124,8 @@ func upgradeRunCmd(cmd *cobra.Command, args []string) {
        proj := TryGetOrDownloadProject()
        interfaces.SetProject(proj)
 
+       proj.GetPkgRepos()
+
        pred := makeRepoPredicate(args)
        if err := proj.UpgradeIf(
                newtutil.NewtForce, newtutil.NewtAsk, pred); err != nil {
diff --git a/newt/interfaces/interfaces.go b/newt/interfaces/interfaces.go
index e84d7a2c..19117a41 100644
--- a/newt/interfaces/interfaces.go
+++ b/newt/interfaces/interfaces.go
@@ -19,12 +19,15 @@
 
 package interfaces
 
+import "mynewt.apache.org/newt/newt/ycfg"
+
 type PackageInterface interface {
        Name() string
        FullName() string
        BasePath() string
        Repo() RepoInterface
        Type() PackageType
+       PkgConfig() *ycfg.YCfg
 }
 
 type PackageType int
diff --git a/newt/pkg/localpackage.go b/newt/pkg/localpackage.go
index 5a2658a3..344633be 100644
--- a/newt/pkg/localpackage.go
+++ b/newt/pkg/localpackage.go
@@ -112,6 +112,10 @@ func (pkg *LocalPackage) BasePath() string {
        return pkg.basePath
 }
 
+func (pkg *LocalPackage) PkgConfig() *ycfg.YCfg {
+       return &pkg.PkgY
+}
+
 func (pkg *LocalPackage) RelativePath() string {
        proj := interfaces.GetProject()
        return strings.TrimPrefix(pkg.BasePath(), proj.Path())
diff --git a/newt/project/project.go b/newt/project/project.go
index 84c1021a..45ecaf32 100644
--- a/newt/project/project.go
+++ b/newt/project/project.go
@@ -163,6 +163,45 @@ func NewProject(dir string, download bool) (*Project, 
error) {
        return proj, nil
 }
 
+func (proj *Project) GetPkgRepos() error {
+
+       for _, pkgList := range proj.packages {
+               for _, pkg := range *pkgList {
+                       if pkg.PkgConfig().HasKey("repository") {
+                               for k, _ := range pkg.PkgConfig().AllSettings() 
{
+                                       repoName := strings.TrimPrefix(k, 
"repository.")
+                                       if repoName != k {
+                                               fields, err := 
pkg.PkgConfig().GetValStringMapString(k, nil)
+                                               util.OneTimeWarningError(err)
+
+                                               r, err := 
proj.loadRepo(repoName, fields)
+                                               if err != nil {
+                                                       // if `repository.yml` 
does not exist, it is not an error; we
+                                                       // will just download a 
new copy.
+                                                       if 
!util.IsNotExist(err) {
+                                                               return err
+                                                       }
+                                               }
+                                               verReq, err := 
newtutil.ParseRepoVersion(fields["vers"])
+                                               if err != nil {
+                                                       return 
util.FmtNewtError(
+                                                               "Repo \"%s\" 
contains invalid version requirement: "+
+                                                                       "%s 
(%s)",
+                                                               repoName, 
fields["vers"], err.Error())
+                                               }
+                                               r.SetPkgName(pkg.Name())
+                                               if err := proj.addRepo(r, 
true); err != nil {
+                                                       return err
+                                               }
+                                               proj.rootRepoReqs[repoName] = 
verReq
+                                       }
+                               }
+                       }
+               }
+       }
+       return nil
+}
+
 func (proj *Project) Path() string {
        return proj.BasePath
 }
diff --git a/newt/repo/repo.go b/newt/repo/repo.go
index 4d8f8d12..9e624b73 100644
--- a/newt/repo/repo.go
+++ b/newt/repo/repo.go
@@ -54,6 +54,9 @@ type Repo struct {
        local      bool
        ncMap      compat.NewtCompatMap
 
+       // If repo was added from package (not from project.yml), this variable 
stores name of this package
+       pkgName string
+
        // True if this repo was cloned during this invocation of newt.
        newlyCloned bool
 
@@ -73,6 +76,10 @@ type RepoDependency struct {
        Fields  map[string]string
 }
 
+func (r *Repo) SetPkgName(pName string) {
+       r.pkgName = pName
+}
+
 func (r *Repo) CommitDepMap() map[string][]*RepoDependency {
        return r.deps
 }

Reply via email to