Rename AccessType to AccessLevel

repo.go

@@ -46,7 +46,7 @@ func (r RepoType) String() string {
 type RepoLookup struct {
 	Type      RepoType
 	PathParts []string
-	Access    AccessType
+	Access    AccessLevel
 }
 
 // Path returns the full path to this repository on disk. This is relative to

repo_perms.go

@@ -7,30 +7,30 @@ import (
 	"github.com/rs/zerolog/log"
 )
 
-// AccessType represents the level of access being requested and the level of
+// AccessLevel represents the level of access being requested and the level of
 // access a user has.
-type AccessType int
+type AccessLevel int
 
-// AccessType defaults to AccessTypeNone for security. A repo lookup returns the
+// AccessLevel defaults to AccessLevelNone for security. A repo lookup returns the
 // level of permissions a user has and if it's not explicitly set, they don't
 // have any.
 const (
-	AccessTypeNone AccessType = iota
-	AccessTypeRead
-	AccessTypeWrite
-	AccessTypeAdmin
+	AccessLevelNone AccessLevel = iota
+	AccessLevelRead
+	AccessLevelWrite
+	AccessLevelAdmin
 )
 
 // String implements Stringer
-func (a AccessType) String() string {
+func (a AccessLevel) String() string {
 	switch a {
-	case AccessTypeNone:
+	case AccessLevelNone:
 		return "None"
-	case AccessTypeRead:
+	case AccessLevelRead:
 		return "Read"
-	case AccessTypeWrite:
+	case AccessLevelWrite:
 		return "Write"
-	case AccessTypeAdmin:
+	case AccessLevelAdmin:
 		return "Admin"
 	default:
 		return fmt.Sprintf("Unknown(%d)", a)
@@ -84,31 +84,31 @@ func (c *Config) checkListsForUser(username string, userLists ...[]string) bool
 }
 
 // TODO: clean up nolint here
-func (c *Config) checkUserRepoAccess(user *User, repo *RepoLookup) AccessType { //nolint:funlen
+func (c *Config) checkUserRepoAccess(user *User, repo *RepoLookup) AccessLevel { //nolint:funlen
 	// Admins always have access to everything.
 	if user.IsAdmin {
-		return AccessTypeAdmin
+		return AccessLevelAdmin
 	}
 
 	switch repo.Type {
 	case RepoTypeAdmin:
 		// If we made it this far, they're not an admin, so they don't have
 		// access.
-		return AccessTypeNone
+		return AccessLevelNone
 	case RepoTypeOrgConfig:
 		org := c.Orgs[repo.PathParts[0]]
 		if c.checkListsForUser(user.Username, org.Admin) {
-			return AccessTypeAdmin
+			return AccessLevelAdmin
 		}
 
-		return AccessTypeNone
+		return AccessLevelNone
 	case RepoTypeOrg:
 		org := c.Orgs[repo.PathParts[0]]
 
 		// Because we already checked to see if this repo exists, this user has
 		// admin on the repo if they're an org admin.
 		if c.checkListsForUser(user.Username, org.Admin) {
-			return AccessTypeAdmin
+			return AccessLevelAdmin
 		}
 
 		repo := org.Repos[repo.PathParts[1]]
@@ -118,34 +118,34 @@ func (c *Config) checkUserRepoAccess(user *User, repo *RepoLookup) AccessType {
 			if c.Options.ImplicitRepos {
 				switch {
 				case c.checkListsForUser(user.Username, org.Write):
-					return AccessTypeWrite
+					return AccessLevelWrite
 				case c.checkListsForUser(user.Username, org.Read):
-					return AccessTypeRead
+					return AccessLevelRead
 				}
 			}
 
-			return AccessTypeNone
+			return AccessLevelNone
 		}
 
 		switch {
 		case c.checkListsForUser(user.Username, org.Write, repo.Write):
-			return AccessTypeWrite
+			return AccessLevelWrite
 		case c.checkListsForUser(user.Username, org.Read, repo.Read):
-			return AccessTypeRead
+			return AccessLevelRead
 		}
 
-		return AccessTypeNone
+		return AccessLevelNone
 	case RepoTypeUserConfig:
 		if repo.PathParts[0] == user.Username {
-			return AccessTypeAdmin
+			return AccessLevelAdmin
 		}
 
-		return AccessTypeNone
+		return AccessLevelNone
 	case RepoTypeUser:
 		// Because we already checked to see if this repo exists, the user has
 		// admin on the repo if they own the repo.
 		if repo.PathParts[0] == user.Username {
-			return AccessTypeAdmin
+			return AccessLevelAdmin
 		}
 
 		userConfig := c.Users[repo.PathParts[0]]
@@ -154,29 +154,29 @@ func (c *Config) checkUserRepoAccess(user *User, repo *RepoLookup) AccessType {
 		// Only the given user has access to implicit repos, so if the repo
 		// isn't explicitly defined, noone else has access.
 		if repo == nil {
-			return AccessTypeNone
+			return AccessLevelNone
 		}
 
 		switch {
 		case c.checkListsForUser(user.Username, repo.Write):
-			return AccessTypeWrite
+			return AccessLevelWrite
 		case c.checkListsForUser(user.Username, repo.Read):
-			return AccessTypeRead
+			return AccessLevelRead
 		}
 	case RepoTypeTopLevel:
 		repo := c.Repos[repo.PathParts[0]]
 		if repo == nil {
 			// Only admins have access to implicitly created top-level repos.
-			return AccessTypeNone
+			return AccessLevelNone
 		}
 
 		switch {
 		case c.checkListsForUser(user.Username, repo.Write):
-			return AccessTypeWrite
+			return AccessLevelWrite
 		case c.checkListsForUser(user.Username, repo.Read):
-			return AccessTypeRead
+			return AccessLevelRead
 		}
 	}
 
-	return AccessTypeNone
+	return AccessLevelNone
 }

repo_test.go

@@ -102,14 +102,14 @@ func TestRepoTypeStringer(t *testing.T) {
 	assert.Equal(t, "Unknown(42)", RepoType(42).String())
 }
 
-func TestAccessTypeStringer(t *testing.T) {
+func TestAccessLevelStringer(t *testing.T) {
 	t.Parallel()
 
-	assert.Equal(t, "None", AccessTypeNone.String())
-	assert.Equal(t, "Read", AccessTypeRead.String())
-	assert.Equal(t, "Write", AccessTypeWrite.String())
-	assert.Equal(t, "Admin", AccessTypeAdmin.String())
-	assert.Equal(t, "Unknown(42)", AccessType(42).String())
+	assert.Equal(t, "None", AccessLevelNone.String())
+	assert.Equal(t, "Read", AccessLevelRead.String())
+	assert.Equal(t, "Write", AccessLevelWrite.String())
+	assert.Equal(t, "Admin", AccessLevelAdmin.String())
+	assert.Equal(t, "Unknown(42)", AccessLevel(42).String())
 }
 
 func TestRepoLookup(t *testing.T) { //nolint:funlen
@@ -260,21 +260,21 @@ func TestCheckListsForUser(t *testing.T) {
 }
 
 type allRepoAccessLevels struct {
-	Admin      AccessType
-	OrgConfig  AccessType
-	OrgRepo    AccessType
-	UserConfig AccessType
-	UserRepo   AccessType
-	TopLevel   AccessType
+	Admin      AccessLevel
+	OrgConfig  AccessLevel
+	OrgRepo    AccessLevel
+	UserConfig AccessLevel
+	UserRepo   AccessLevel
+	TopLevel   AccessLevel
 }
 
 type allImplicitAccessLevels struct {
-	Org      AccessType
-	User     AccessType
-	TopLevel AccessType
+	Org      AccessLevel
+	User     AccessLevel
+	TopLevel AccessLevel
 }
 
-func lookupAndCheck(t *testing.T, c *Config, u *User, path string, access AccessType) {
+func lookupAndCheck(t *testing.T, c *Config, u *User, path string, access AccessLevel) {
 	repo, err := c.LookupRepoAccess(u, path)
 	require.Nil(t, err)
 	require.NotNil(t, repo)
@@ -345,72 +345,72 @@ func TestCheckUserRepoAccess(t *testing.T) { //nolint:funlen
 		{
 			"an-admin",
 			allRepoAccessLevels{
-				Admin:      AccessTypeAdmin,
-				OrgConfig:  AccessTypeAdmin,
-				OrgRepo:    AccessTypeAdmin,
-				UserConfig: AccessTypeAdmin,
-				UserRepo:   AccessTypeAdmin,
-				TopLevel:   AccessTypeAdmin,
+				Admin:      AccessLevelAdmin,
+				OrgConfig:  AccessLevelAdmin,
+				OrgRepo:    AccessLevelAdmin,
+				UserConfig: AccessLevelAdmin,
+				UserRepo:   AccessLevelAdmin,
+				TopLevel:   AccessLevelAdmin,
 			},
 			allImplicitAccessLevels{
-				Org:      AccessTypeAdmin,
-				User:     AccessTypeAdmin,
-				TopLevel: AccessTypeAdmin,
+				Org:      AccessLevelAdmin,
+				User:     AccessLevelAdmin,
+				TopLevel: AccessLevelAdmin,
 			},
 		},
 		{
 			"org-admin",
 			allRepoAccessLevels{
-				OrgConfig: AccessTypeAdmin,
-				OrgRepo:   AccessTypeAdmin,
+				OrgConfig: AccessLevelAdmin,
+				OrgRepo:   AccessLevelAdmin,
 			},
 			allImplicitAccessLevels{
-				Org: AccessTypeAdmin,
+				Org: AccessLevelAdmin,
 			},
 		},
 		{
 			"org-write",
 			allRepoAccessLevels{
-				OrgRepo: AccessTypeWrite,
+				OrgRepo: AccessLevelWrite,
 			},
 			allImplicitAccessLevels{
-				Org: AccessTypeWrite,
+				Org: AccessLevelWrite,
 			},
 		},
 		{
 			"org-read",
 			allRepoAccessLevels{
-				OrgRepo: AccessTypeRead,
+				OrgRepo: AccessLevelRead,
 			},
 			allImplicitAccessLevels{
-				Org: AccessTypeRead,
+				Org: AccessLevelRead,
 			},
 		},
 		{
 			"non-admin",
 			allRepoAccessLevels{
-				UserConfig: AccessTypeAdmin,
-				UserRepo:   AccessTypeAdmin,
+				UserConfig: AccessLevelAdmin,
+				UserRepo:   AccessLevelAdmin,
 			},
 			allImplicitAccessLevels{
-				User: AccessTypeAdmin,
+				User: AccessLevelAdmin,
 			},
 		},
 		{
 			"write-user",
 			allRepoAccessLevels{
-				OrgRepo:  AccessTypeWrite,
-				UserRepo: AccessTypeWrite,
-				TopLevel: AccessTypeWrite,
+				OrgRepo:  AccessLevelWrite,
+				UserRepo: AccessLevelWrite,
+				TopLevel: AccessLevelWrite,
 			},
 			allImplicitAccessLevels{},
 		},
 		{
 			"read-user",
 			allRepoAccessLevels{
-				OrgRepo:  AccessTypeRead,
-				UserRepo: AccessTypeRead,
-				TopLevel: AccessTypeRead,
+				OrgRepo:  AccessLevelRead,
+				UserRepo: AccessLevelRead,
+				TopLevel: AccessLevelRead,
 			},
 			allImplicitAccessLevels{},
 		},

ssh_commands.go

@@ -22,7 +22,7 @@ func cmdNotFound(ctx context.Context, s ssh.Session, cmd []string) int {
 	return 1
 }
 
-func (serv *Server) cmdRepoAction(ctx context.Context, s ssh.Session, cmd []string, access AccessType) int {
+func (serv *Server) cmdRepoAction(ctx context.Context, s ssh.Session, cmd []string, access AccessLevel) int {
 	if len(cmd) != 2 {
 		_ = writeStringFmt(s.Stderr(), "Missing repo name argument\r\n")
 		return 1
@@ -54,7 +54,7 @@ func (serv *Server) cmdRepoAction(ctx context.Context, s ssh.Session, cmd []stri
 
 	// Because we check ImplicitRepos earlier, if they have admin access, it's
 	// safe to ensure this repo exists.
-	if repo.Access >= AccessTypeAdmin {
+	if repo.Access >= AccessLevelAdmin {
 		_, err = git.EnsureRepo(serv.config.fs, repo.Path())
 		if err != nil {
 			return -1
@@ -69,7 +69,7 @@ func (serv *Server) cmdRepoAction(ctx context.Context, s ssh.Session, cmd []stri
 	})
 
 	// Reload the server config if a config repo was changed.
-	if access == AccessTypeWrite {
+	if access == AccessLevelWrite {
 		switch repo.Type {
 		case RepoTypeAdmin, RepoTypeOrgConfig, RepoTypeUserConfig:
 			err = serv.Reload()

ssh_server.go

@@ -180,9 +180,9 @@ func (serv *Server) handleSession(s ssh.Session) {
 	case "whoami":
 		exit = cmdWhoami(ctx, s, cmd)
 	case "git-receive-pack":
-		exit = serv.cmdRepoAction(ctx, s, cmd, AccessTypeWrite)
+		exit = serv.cmdRepoAction(ctx, s, cmd, AccessLevelWrite)
 	case "git-upload-pack":
-		exit = serv.cmdRepoAction(ctx, s, cmd, AccessTypeRead)
+		exit = serv.cmdRepoAction(ctx, s, cmd, AccessLevelRead)
 	default:
 		exit = cmdNotFound(ctx, s, cmd)
 	}