func (proj *Project) ResolvePackage(
dfltRepo interfaces.RepoInterface, name string) (*pkg.LocalPackage, error) {
// Trim trailing slash from name. This is necessary when tab
// completion is used to specify the name.
name = strings.TrimSuffix(name, "/")
repoName, pkgName, err := newtutil.ParsePackageString(name)
if err != nil {
return nil, util.FmtNewtError("invalid package name: %s (%s)", name,
err.Error())
}
var repo interfaces.RepoInterface
if repoName == "" {
repo = dfltRepo
} else {
repo = proj.repos[repoName]
}
dep, err := pkg.NewDependency(repo, pkgName)
if err != nil {
return nil, util.FmtNewtError("invalid package name: %s (%s)", name,
err.Error())
}
if dep == nil {
return nil, util.NewNewtError("invalid package name: " + name)
}
pack := proj.ResolveDependency(dep)
if pack == nil {
return nil, util.NewNewtError("unknown package: " + name)
}
return pack.(*pkg.LocalPackage), nil
}
func ResolveNewTargetName(name string) (string, error) {
repoName, pkgName, err := newtutil.ParsePackageString(name)
if err != nil {
return "", err
}
if repoName != "" {
return "", util.NewNewtError("Target name cannot contain repo; " +
"must be local")
}
if pkgName == TARGET_KEYWORD_ALL {
return "", util.NewNewtError("Target name " + TARGET_KEYWORD_ALL +
" is reserved")
}
// "Naked" target names translate to "targets/<name>".
if !strings.Contains(pkgName, "/") {
pkgName = TARGET_DEFAULT_DIR + "/" + pkgName
}
if target.GetTargets()[pkgName] != nil {
return "", util.NewNewtError("Target already exists: " + pkgName)
}
return pkgName, nil
}
func (proj *Project) loadConfig() error {
v, err := util.ReadConfig(proj.BasePath,
strings.TrimSuffix(PROJECT_FILE_NAME, ".yml"))
if err != nil {
return util.NewNewtError(err.Error())
}
// Store configuration object for access to future values,
// this avoids keeping every string around as a project variable when
// we need to process it later.
proj.v = v
proj.projState, err = LoadProjectState()
if err != nil {
return err
}
proj.name = v.GetString("project.name")
// Local repository always included in initialization
r, err := repo.NewLocalRepo(proj.name)
if err != nil {
return err
}
proj.repos[proj.name] = r
proj.localRepo = r
for _, ignDir := range ignoreSearchDirs {
r.AddIgnoreDir(ignDir)
}
rstrs := v.GetStringSlice("project.repositories")
for _, repoName := range rstrs {
if err := proj.loadRepo(repoName, v); err != nil {
return err
}
}
ignoreDirs := v.GetStringSlice("project.ignore_dirs")
for _, ignDir := range ignoreDirs {
repoName, dirName, err := newtutil.ParsePackageString(ignDir)
if err != nil {
return err
}
if repoName == "" {
r = proj.LocalRepo()
} else {
r = proj.FindRepo(repoName)
}
if r == nil {
return util.NewNewtError(
fmt.Sprintf("ignore_dirs: unknown repo %s", repoName))
}
r.AddIgnoreDir(dirName)
}
return nil
}
// Resolves a path with an optional repo prefix (e.g., "@apache-mynewt-core").
func (proj *Project) ResolvePath(
basePath string, name string) (string, error) {
repoName, subPath, err := newtutil.ParsePackageString(name)
if err != nil {
return "", util.FmtNewtError("invalid path: %s (%s)", name,
err.Error())
}
if repoName == "" {
return basePath + "/" + subPath, nil
} else {
repo := proj.repos[repoName]
if repo == nil {
return "", util.FmtNewtError("Unknown repository: %s", repoName)
}
return repo.Path() + "/" + subPath, nil
}
}
func (dep *Dependency) setRepoAndName(parentRepo interfaces.RepoInterface, str string) error {
// First part is always repo/dependency name combination.
// If repo is present, string will always begin with a @ sign
// representing the repo name, followed by 'n' slashes.
repoName, pkgName, err := newtutil.ParsePackageString(str)
if err != nil {
return err
}
if repoName != "" {
dep.Repo = repoName
dep.Name = pkgName
} else {
if parentRepo != nil {
dep.Repo = parentRepo.Name()
} else {
dep.Repo = repo.REPO_NAME_LOCAL
}
dep.Name = str
}
return nil
}