1 files changed, 337 insertions, 0 deletions
diff --git a/forgeConfig.Common.go b/forgeConfig.Common.go
new file mode 100644
index 0000000..8bc009d
--- /dev/null
+++ b/forgeConfig.Common.go
@@ -0,0 +1,337 @@
+package forgepb
+
+/*
+	lookup settings for a particular *gitpb.Repo or namespace string
+
+	user settings are configured in ~/.config/forge/forge.text
+
+	// searchs by string
+	Configs.IsReadOnly(path)	// user can't push commits
+	Configs.IsWritable(path)	// the opposite, but maybe different so I put both here
+
+	IsPrivate(repo)		// repo can't be published to the pkg.go.dev system
+	DebName()		// for 'zookeeper' returns 'zookeeper-go'
+
+	This code is practical, not perfect
+*/
+
+import (
+	"path/filepath"
+	"strings"
+
+	"go.wit.com/lib/protobuf/gitpb"
+)
+
+// move away from IsReadOnly. Only use repo.Namespace
+func (f *Forge) IsWritable(repo *gitpb.Repo) bool {
+	if f.Config.IsWritable(repo.Namespace) {
+		return true
+	}
+	//	if f.Config.IsWritable(repo.FullPath) {
+	//		return true
+	//	}
+	//	if !f.Config.IsWritable(repo.GetNamespace()) {
+	//		return true
+	//	}
+	return false
+}
+
+// returns true if namespace is readonly()
+// will attempt to match IsWritable("foo") against anything ending in "foo"
+func (fc *ForgeConfigs) IsReadOnly(namespace string) bool {
+	var match *ForgeConfig
+
+	all := fc.All() // get the list of repos
+	for all.Scan() {
+		r := all.Next()
+		if r.Namespace == namespace {
+			// exact namespace match
+			if r.Writable {
+				return false
+			}
+			if r.ReadOnly {
+				return true
+			}
+			// private is assumed to be r/w unless above is specifically set
+			if r.Private {
+				return false
+			}
+		}
+		// if namespace == "foo" will return false if "go.wit.com/apps/foo" is Writable
+		base := filepath.Base(r.Namespace)
+		if base == namespace {
+			if r.Writable {
+				return false
+			}
+		}
+		// search for potential dir matches
+		if r.Directory {
+			// test the dir
+			if strings.HasPrefix(namespace, r.Namespace) {
+				match = r
+			}
+		}
+	}
+
+	if match == nil {
+		// log.Info("did not match in IsReadOnly()", namespace)
+		return true
+	}
+
+	// take the settings from the directory match
+	if match.Writable {
+		return false
+	}
+	if match.ReadOnly {
+		return true
+	}
+	// private is assumed to be r/w unless above is specifically set
+	if match.Private {
+		return false
+	}
+
+	// always assume readonly
+	return true
+}
+
+// returns the deb package name
+// this let's you check a git tag version against a package .deb version
+// allows namespace's to not need to match the .deb name
+// this is important in lots of cases! It is normal and happens often enough.
+func (fc *ForgeConfigs) DebName(namespace string) string {
+	// get "zookeeper" from "go.wit.com/apps/zookeeper"
+	normalBase := filepath.Base(namespace)
+
+	all := fc.All()
+	for all.Scan() {
+		r := all.Next()
+		if r.Namespace == namespace {
+			// returns "zookeeper-go" for "go.wit.com/apps/zookeeper"
+			if r.DebName != "" {
+				// log.Info("FOUND DebName", r.DebName)
+				return r.DebName
+			} else {
+				return normalBase
+			}
+		}
+	}
+	return normalBase
+}
+
+// a work in progress
+func (f *Forge) IsPrivate(repo *gitpb.Repo) bool {
+	namespace := repo.GetNamespace()
+	if namespace == "" {
+		// assume true
+		return true
+	}
+
+	return f.Config.IsPrivate(namespace)
+}
+
+// is this a non-publishable repo?
+// matches package names from apt
+//
+// IsPrivate("foo") will match anything in the config file ending in "foo"
+//
+// IsPrivate("go.foo.com/jcarr/foo") returns true if private
+// IsPrivate("foo") also returns true if "go.bar.com/jcarr/foo" is private
+func (fc *ForgeConfigs) IsPrivate(thing string) bool {
+	var match *ForgeConfig
+
+	// sort by path means the simple 'match' logic
+	// here works in the sense the last directory match
+	// is the one that is used
+	all := fc.All() // get the list of repos
+	for all.Scan() {
+		r := all.Next()
+		if r.Namespace == thing {
+			// if private is set here, then ok, otherwise
+			// still check if a Directory match exists
+			if r.Private {
+				return true
+			}
+		}
+		base := filepath.Base(r.Namespace)
+		if base == thing {
+			if r.Private {
+				return true
+			}
+		}
+		// check to see if IsPrivate("foo")
+		// search for potential dir matches
+		if r.Directory {
+			// test the dir
+			if strings.HasPrefix(thing, r.Namespace) {
+				match = r
+			}
+		}
+	}
+	if match == nil {
+		// log.Info("did not match in IsPrivate()", thing)
+		return false
+	}
+
+	// otherwise, assume not private
+	return match.Private
+}
+
+// IsFavorite() -- fun option for the config
+// file that lets you set things as favorites
+// so you can just go-clone a bunch of common things
+// on a new box or after you reset/delete your ~/go/src dir
+func (fc *ForgeConfigs) IsFavorite(thing string) bool {
+	var match *ForgeConfig
+
+	all := fc.All() // get the list of repos
+	for all.Scan() {
+		r := all.Next()
+		if r.Namespace == thing {
+			if r.Favorite {
+				return true
+			}
+		}
+		base := filepath.Base(r.Namespace)
+		if base == thing {
+			if r.Favorite {
+				return true
+			}
+		}
+		if r.Directory {
+			if strings.HasPrefix(thing, r.Namespace) {
+				match = r
+			}
+		}
+	}
+	if match == nil {
+		return false
+	}
+
+	return match.Favorite
+}
+
+// IsWritable() checks your .config/forge/ settings
+// looks for an exact match, then
+// looks for a directory match
+func (fc *ForgeConfigs) IsWritable(thing string) bool {
+	var match *ForgeConfig
+
+	all := fc.All() // get the list of repos
+	for all.Scan() {
+		r := all.Next()
+		if r.Namespace == thing {
+			if r.Writable {
+				return true
+			}
+		}
+		base := filepath.Base(r.Namespace)
+		if base == thing {
+			if r.Writable {
+				return true
+			}
+		}
+		if r.Directory {
+			if strings.HasPrefix(thing, r.Namespace) {
+				match = r
+			}
+		}
+	}
+	if match == nil {
+		return false
+	}
+
+	return match.Writable
+}
+
+// allows custom user branch names in the forge config
+func (fc *ForgeConfigs) FindUserBranch(thing string) string {
+	var match *ForgeConfig
+
+	all := fc.All() // get the list of repos
+	for all.Scan() {
+		r := all.Next()
+		if r.Namespace == thing {
+			if r.UserBranchName != "" {
+				return r.UserBranchName
+			}
+		}
+		base := filepath.Base(r.Namespace)
+		if base == thing {
+			if r.UserBranchName != "" {
+				return r.UserBranchName
+			}
+		}
+		if r.Directory {
+			if strings.HasPrefix(thing, r.Namespace) {
+				match = r
+			}
+		}
+	}
+	if match == nil {
+		return ""
+	}
+
+	return match.UserBranchName
+}
+
+// allows custom devel branch names in the forge config
+func (fc *ForgeConfigs) FindDevelBranch(thing string) string {
+	var match *ForgeConfig
+
+	all := fc.All() // get the list of repos
+	for all.Scan() {
+		r := all.Next()
+		if r.Namespace == thing {
+			if r.DevelBranchName != "" {
+				return r.DevelBranchName
+			}
+		}
+		base := filepath.Base(r.Namespace)
+		if base == thing {
+			if r.DevelBranchName != "" {
+				return r.DevelBranchName
+			}
+		}
+		if r.Directory {
+			if strings.HasPrefix(thing, r.Namespace) {
+				match = r
+			}
+		}
+	}
+	if match == nil {
+		return ""
+	}
+
+	return match.DevelBranchName
+}
+
+// allows custom devel branch names in the forge config
+func (fc *ForgeConfigs) FindMasterBranch(thing string) string {
+	var match *ForgeConfig
+
+	all := fc.All() // get the list of repos
+	for all.Scan() {
+		r := all.Next()
+		if r.Namespace == thing {
+			if r.MasterBranchName != "" {
+				return r.MasterBranchName
+			}
+		}
+		base := filepath.Base(r.Namespace)
+		if base == thing {
+			if r.MasterBranchName != "" {
+				return r.MasterBranchName
+			}
+		}
+		if r.Directory {
+			if strings.HasPrefix(thing, r.Namespace) {
+				match = r
+			}
+		}
+	}
+	if match == nil {
+		return ""
+	}
+
+	return match.MasterBranchName
+}