wip: commit more progress

Author: buenos-nachos

.env.example

@@ -4,10 +4,6 @@
 # can set this to your GitHub username.
 CI_ACTOR=
 
-# This is the Git ref that you want to merge into the main branch. In local
-# development, this should be set to the value of the branch you're working from
-CI_BASE_REF=
-
 # This is the configurable base URL for accessing the GitHub REST API. This
 # value will be injected by the CI script's Actions context, but if the value is
 # not defined (either in CI or when running locally), "https://api.github.com/"

cmd/github/github.go

@@ -7,46 +7,12 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"log"
 	"net/http"
-	"os"
 	"time"
 )
 
 const defaultGithubAPIBaseRoute = "https://api.github.com/"
 
-const (
-	actionsActorKey   = "CI_ACTOR"
-	actionsBaseRefKey = "CI_BASE_REF"
-)
-
-const (
-	githubAPIURLKey   = "GITHUB_API_URL"
-	githubAPITokenKey = "GITHUB_API_TOKEN"
-)
-
-// ActionsActor returns the username of the GitHub user who triggered the
-// current CI run as part of GitHub Actions. The value must be loaded into the
-// env as part of the Github Actions YAML file, or else the function fails.
-func ActionsActor() (string, error) {
-	username := os.Getenv(actionsActorKey)
-	if username == "" {
-		return "", fmt.Errorf("value for %q is not in env. If running from CI, please add value via ci.yaml file", actionsActorKey)
-	}
-	return username, nil
-}
-
-// BaseRef returns the name of the base ref for the Git branch that will be
-// merged into the main branch.
-func BaseRef() (string, error) {
-	baseRef := os.Getenv(actionsBaseRefKey)
-	if baseRef == "" {
-		return "", fmt.Errorf("value for %q is not in env. If running from CI, please add value via ci.yaml file", actionsBaseRefKey)
-	}
-
-	return baseRef, nil
-}
-
 // Client is a reusable REST client for making requests to the GitHub API.
 // It should be instantiated via NewGithubClient
 type Client struct {
@@ -55,19 +21,25 @@ type Client struct {
 	httpClient http.Client
 }
 
-// NewClient instantiates a GitHub client
-func NewClient() (*Client, error) {
+// ClientInit is used to instantiate a new client. If the value of BaseURL is
+// not defined, a default value of "https://api.github.com/" is used instead
+type ClientInit struct {
+	BaseURL  string
+	APIToken string
+}
+
+// NewClient instantiates a GitHub client. If the baseURL is
+func NewClient(init ClientInit) (*Client, error) {
 	// Considered letting the user continue on with no token and more aggressive
 	// rate-limiting, but from experimentation, the non-authenticated experience
 	// hit the rate limits really quickly, and had a lot of restrictions
-	apiToken := os.Getenv(githubAPITokenKey)
+	apiToken := init.APIToken
 	if apiToken == "" {
-		return nil, fmt.Errorf("missing env variable %q", githubAPITokenKey)
+		return nil, errors.New("API token is missing")
 	}
 
-	baseURL := os.Getenv(githubAPIURLKey)
+	baseURL := init.BaseURL
 	if baseURL == "" {
-		log.Printf("env variable %q is not defined. Falling back to %q\n", githubAPIURLKey, defaultGithubAPIBaseRoute)
 		baseURL = defaultGithubAPIBaseRoute
 	}
 
@@ -129,9 +101,11 @@ const (
 	// could not be determined. It is the zero value of the OrgStatus type, and
 	// any users with this value should be treated as completely untrusted
 	OrgStatusIndeterminate = iota
+
 	// OrgStatusNonMember indicates when a user is definitely NOT part of an
 	// organization
 	OrgStatusNonMember
+
 	// OrgStatusMember indicates when a user is a member of a Github
 	// organization
 	OrgStatusMember

cmd/readmevalidation/coderResources.go

@@ -4,11 +4,16 @@ import (
 	"errors"
 	"fmt"
 	"net/url"
+	"os"
+	"path"
+	"slices"
 	"strings"
 
 	"coder.com/coder-registry/cmd/github"
 )
 
+var supportedResourceTypes = []string{"modules", "templates"}
+
 type coderResourceFrontmatter struct {
 	Description string   `yaml:"description"`
 	IconURL     string   `yaml:"icon"`
@@ -166,14 +171,68 @@ func validateCoderResourceChanges(resource coderResource, actorOrgStatus github.
 	return problems
 }
 
-func parseCoderResourceFiles(oldReadmeFiles []readme, newReadmeFiles []readme) (map[string]coderResource, error) {
+func parseCoderResourceFiles(oldReadmeFiles []readme, newReadmeFiles []readme, actorOrgStatus github.OrgStatus) (map[string]coderResource, error) {
 	return nil, nil
 }
 
 func validateCoderResourceRelativeUrls(map[string]coderResource) []error {
 	return nil
 }
 
-func aggregateCoderResourceReadmeFiles() ([]readme, error) {
-	return nil, nil
+func aggregateCoderResourceReadmeFiles(resourceDirectoryName string) ([]readme, error) {
+	if !slices.Contains(supportedResourceTypes, resourceDirectoryName) {
+		return nil, fmt.Errorf("%q is not a supported resource type. Must be one of [%s]", resourceDirectoryName, strings.Join(supportedResourceTypes, ", "))
+	}
+
+	registryFiles, err := os.ReadDir(rootRegistryPath)
+	if err != nil {
+		return nil, err
+	}
+
+	var allReadmeFiles []readme
+	var problems []error
+	for _, f := range registryFiles {
+		if !f.IsDir() {
+			continue
+		}
+
+		resourceDirPath := path.Join(rootRegistryPath, f.Name(), resourceDirectoryName)
+		resourceFiles, err := os.ReadDir(resourceDirPath)
+		if err != nil {
+			if !errors.Is(err, os.ErrNotExist) {
+				problems = append(problems, err)
+			}
+			continue
+		}
+
+		for _, resFile := range resourceFiles {
+			// Not sure if we want to allow non-directories to live inside of
+			// main directories like /modules or /templates, but we can tighten
+			// things up later
+			if !resFile.IsDir() {
+				continue
+			}
+
+			readmePath := path.Join(resourceDirPath, resFile.Name(), "README.md")
+			rawRm, err := os.ReadFile(readmePath)
+			if err != nil {
+				problems = append(problems, err)
+				continue
+			}
+			allReadmeFiles = append(allReadmeFiles, readme{
+				filePath: readmePath,
+				rawText:  string(rawRm),
+			})
+
+		}
+	}
+
+	if len(problems) != 0 {
+		return nil, validationPhaseError{
+			phase:  validationPhaseFileLoad,
+			errors: problems,
+		}
+	}
+
+	return allReadmeFiles, nil
 }

cmd/readmevalidation/github.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+const actionsActorKey = "CI_ACTOR"
+
+const (
+	githubAPIBaseURLKey = "GITHUB_API_URL"
+	githubAPITokenKey   = "GITHUB_API_TOKEN"
+)
+
+// actionsActor returns the username of the GitHub user who triggered the
+// current CI run as part of GitHub Actions. It is expected that this value be
+// set using a local .env file in local development, and set via GitHub Actions
+// context during CI.
+func actionsActor() (string, error) {
+	username := os.Getenv(actionsActorKey)
+	if username == "" {
+		return "", fmt.Errorf("value for %q is not in env. If running from CI, please add value via ci.yaml file", actionsActorKey)
+	}
+	return username, nil
+}
+
+func githubAPIToken() (string, error) {
+	token := os.Getenv(githubAPITokenKey)
+	if token == "" {
+		return "", fmt.Errorf("value for %q is not in env. If running from CI, please add value via ci.yaml file", githubAPITokenKey)
+	}
+	return token, nil
+}

cmd/readmevalidation/main.go

@@ -13,30 +13,34 @@ import (
 	"sync"
 
 	"coder.com/coder-registry/cmd/github"
+	"github.com/go-git/go-git/v5"
 	"github.com/joho/godotenv"
 )
 
 func main() {
-	// Do basic setup
 	log.Println("Beginning README file validation")
+
+	// Do basic setup
 	err := godotenv.Load()
 	if err != nil {
 		log.Panic(err)
 	}
-	actorUsername, err := github.ActionsActor()
+	actorUsername, err := actionsActor()
 	if err != nil {
 		log.Panic(err)
 	}
-	baseRef, err := github.BaseRef()
+	ghAPIToken, err := githubAPIToken()
 	if err != nil {
 		log.Panic(err)
 	}
-	log.Printf("Using branch %q for validation comparison", baseRef)
 
 	// Retrieve data necessary from the GitHub API to help determine whether
 	// certain field changes are allowed
 	log.Printf("Using GitHub API to determine what fields can be set by user %q\n", actorUsername)
-	client, err := github.NewClient()
+	client, err := github.NewClient(github.ClientInit{
+		BaseURL:  os.Getenv(githubAPIBaseURLKey),
+		APIToken: ghAPIToken,
+	})
 	if err != nil {
 		log.Panic(err)
 	}
@@ -59,6 +63,7 @@ func main() {
 	}
 	fmt.Printf("Script GitHub actor %q has Coder organization status %q\n", actorUsername, actorOrgStatus.String())
 
+	// Start main validation
 	log.Println("Starting README validation")
 
 	// Validate file structure of main README directory
@@ -85,17 +90,20 @@ func main() {
 
 		allReadmeFiles, err := aggregateContributorReadmeFiles()
 		if err != nil {
-			log.Panic(err)
+			errChan <- err
+			return
 		}
 		log.Printf("Processing %d README files\n", len(allReadmeFiles))
 		contributors, err := parseContributorFiles(allReadmeFiles)
 		log.Printf("Processed %d README files as valid contributor profiles", len(contributors))
 		if err != nil {
-			log.Panic(err)
+			errChan <- err
+			return
 		}
 		err = validateContributorRelativeUrls(contributors)
 		if err != nil {
-			log.Panic(err)
+			errChan <- err
+			return
 		}
 		log.Println("All relative URLs for READMEs are valid")
 		log.Printf("Processed all READMEs in the %q directory\n", rootRegistryPath)
@@ -105,6 +113,30 @@ func main() {
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
+
+		baseRefReadmeFiles, err := aggregateCoderResourceReadmeFiles("modules")
+		if err != nil {
+			errChan <- err
+			return
+		}
+		fmt.Printf("------ got %d back\n", len(baseRefReadmeFiles))
+
+		repo, err := git.PlainOpenWithOptions(".", &git.PlainOpenOptions{
+			DetectDotGit:          false,
+			EnableDotGitCommonDir: false,
+		})
+		if err != nil {
+			errChan <- err
+			return
+		}
+
+		head, err := repo.Head()
+		if err != nil {
+			errChan <- err
+			return
+		}
+		activeBranchName := head.Name().Short()
+		fmt.Println("-----", activeBranchName)
 	}()
 
 	// Validate templates