Fix docs and comments (#51)

- Typo fixes
- Formatting fixes
- Various small inaccuracies
- Code comments fixes

Author: infraredgirl

README.md

@@ -25,9 +25,9 @@ type githubRepositoriesService interface {
 
 // GithubClient is the data structure that is common between production code and test code. In production code,
 // go-github satisfies the PullRequests and Repositories service interfaces, whereas in test the concrete
-// implementations for these same services are mocks that return a static slice of pointers to github repositories,
-// or a single pointer to a github repository, as appropriate. This allows us to test the workflow of git-xargs
-// without actually making API calls to Github when running tests
+// implementations for these same services are mocks that return a static slice of pointers to GitHub repositories,
+// or a single pointer to a GitHub repository, as appropriate. This allows us to test the workflow of git-xargs
+// without actually making API calls to GitHub when running tests
 type GithubClient struct {
 	PullRequests githubPullRequestService
 	Repositories githubRepositoriesService
@@ -40,7 +40,7 @@ func NewClient(client *github.Client) GithubClient {
 	}
 }
 
-// configureGithubClient creates a Github API client using the user-supplied GITHUB_OAUTH_TOKEN and return the configured Github client
+// ConfigureGithubClient creates a GitHub API client using the user-supplied GITHUB_OAUTH_TOKEN and returns the configured GitHub client
 func ConfigureGithubClient() GithubClient {
 	// Ensure user provided a GITHUB_OAUTH_TOKEN
 	GithubOauthToken := os.Getenv("GITHUB_OAUTH_TOKEN")
@@ -57,7 +57,7 @@ func ConfigureGithubClient() GithubClient {
 	return client
 }
 
-// ensureGithubOauthTokenSet is a sanity check that a value is exported for GITHUB_OAUTH_TOKEN
+// EnsureGithubOauthTokenSet is a sanity check that a value is exported for GITHUB_OAUTH_TOKEN
 func EnsureGithubOauthTokenSet() error {
 	if os.Getenv("GITHUB_OAUTH_TOKEN") == "" {
 		return errors.WithStackTrace(types.NoGithubOauthTokenProvidedErr{})

auth/auth.go

@@ -7,7 +7,7 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-// TestConfigureGithubClient performs a sanity check that you can configure a production Github API client
+// TestConfigureGithubClient performs a sanity check that you can configure a production GitHub API client
 func TestConfigureGithubClient(t *testing.T) {
 	t.Parallel()
 
@@ -16,7 +16,7 @@ func TestConfigureGithubClient(t *testing.T) {
 }
 
 // TestNoGithubOauthTokenPassed temporarily drops the existing GITHUB_OAUTH_TOKEN env var to ensure that the validation
-// code throws an error when it is mising. It then replaces it. This is therefore the one test that cannot be run in
+// code throws an error when it is missing. It then replaces it. This is therefore the one test that cannot be run in
 // parallel.
 func TestNoGithubOAuthTokenPassed(t *testing.T) {
 	token := os.Getenv("GITHUB_OAUTH_TOKEN")

auth/auth_test.go

@@ -88,7 +88,7 @@ func parseSliceFromReader(reader io.Reader) ([]string, error) {
 // handleRepoProcessing encapsulates the main processing logic for the supplied repos and printing the run report that
 // is built up throughout the processing
 func handleRepoProcessing(config *config.GitXargsConfig) error {
-	// Track whether or not pull requests were skipped
+	// Track whether pull requests were skipped
 	config.Stats.SetSkipPullRequests(config.SkipPullRequests)
 
 	// Update raw command supplied
@@ -124,7 +124,7 @@ func sanityCheckInputs(config *config.GitXargsConfig) error {
 	return nil
 }
 
-// runGitXargs is the urfave cli app's Action that is called when the user executes the binary
+// RunGitXargs is the urfave cli app's Action that is called when the user executes the binary
 func RunGitXargs(c *cli.Context) error {
 	// If someone calls us with no args at all, show the help text and exit
 	if !c.Args().Present() {

cmd/git-xargs.go

@@ -30,7 +30,7 @@ type GitXargsConfig struct {
 	Stats                  *stats.RunStats
 }
 
-// NewGitXargsConfig sets reasonable defaults for a GitXargsConfig and returns a pointer to a the config
+// NewGitXargsConfig sets reasonable defaults for a GitXargsConfig and returns a pointer to the config
 func NewGitXargsConfig() *GitXargsConfig {
 	return &GitXargsConfig{
 		DryRun:                 false,

config/config.go

@@ -11,9 +11,9 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
-// This utility function accepts a path to the flatfile in which the user has defined their explicitly allowed repos
-// It expects repos to be defined one per line in the following format: `gruntwork-io/cloud-nuke` with optional commas
-// Stray single and double quotes are also handled and stripped out if they are encountered, and spacing is irrelevant
+// ProcessAllowedRepos accepts a path to the flat file in which the user has defined their explicitly allowed repos.
+// It expects repos to be defined one per line in the following format: `gruntwork-io/cloud-nuke` with optional commas.
+// Stray single and double quotes are also handled and stripped out if they are encountered, and spacing is irrelevant.
 func ProcessAllowedRepos(filepath string) ([]*types.AllowedRepo, error) {
 	logger := logging.GetLogger("git-xargs")
 

io/io.go

@@ -25,7 +25,7 @@ func TestProcessAllowedReposCorrectlyParsesValidReposFile(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, len(allowedRepos), 3)
 
-	// Test that repo names are correctly parsed from the flat file by initiallly setting a map of each repo name
+	// Test that repo names are correctly parsed from the flat file by initially setting a map of each repo name
 	// to false, and then updating each entry to true as we find them in the flat file. At the end, all map entries should be true / seen
 	mapOfExpectedRepoNames := make(map[string]bool)
 	mapOfExpectedRepoNames["fetch"] = false
@@ -56,7 +56,7 @@ func TestProcessAllowedReposCorrectlyFiltersMalformedInput(t *testing.T) {
 	// be returned by the function as valid repos to operate on
 	assert.Equal(t, len(allowedRepos), 3)
 
-	// Test that repo names are correctly parsed from the flat file by initiallly setting a map of each repo name
+	// Test that repo names are correctly parsed from the flat file by initially setting a map of each repo name
 	// to false, and then updating each entry to true as we find them in the flat file. At the end, all map entries should be true / seen
 	mapOfExpectedRepoNames := make(map[string]bool)
 	mapOfExpectedRepoNames["fetch"] = false

io/io_test.go

@@ -6,7 +6,7 @@ import (
 	"github.com/gruntwork-io/go-commons/errors"
 )
 
-// Sanity check that user has provided one valid method for selecting repos to operate on
+// EnsureValidOptionsPassed checks that user has provided one valid method for selecting repos to operate on
 func EnsureValidOptionsPassed(config *config.GitXargsConfig) error {
 	if len(config.RepoSlice) < 1 && config.ReposFile == "" && config.GithubOrg == "" && len(config.RepoFromStdIn) == 0 {
 		return errors.WithStackTrace(types.NoRepoSelectionsMadeErr{})

io/validate-input.go

@@ -10,7 +10,7 @@ import (
 	"github.com/urfave/cli"
 )
 
-// This variable is set at build time using -ldflags parameters. For example, we typically set this flag in circle.yml
+// VERSION is set at build time using -ldflags parameters. For example, we typically set this flag in circle.yml
 // to the latest Git tag when building our Go apps:
 //
 // build-go-binaries --app-name my-app --dest-path bin --ld-flags "-X main.VERSION=$CIRCLE_TAG"
@@ -42,7 +42,7 @@ func setupApp() *cli.App {
 	app := entrypoint.NewApp()
 	entrypoint.HelpTextLineWidth = 120
 
-	// Override the CLI FlagEnvHinter so it only returns the Usage text of the Flag and doesn't apend the envVar text. Original func https://github.com/urfave/cli/blob/master/flag.go#L652
+	// Override the CLI FlagEnvHinter, so it only returns the Usage text of the Flag and doesn't append the envVar text. Original func https://github.com/urfave/cli/blob/master/flag.go#L652
 	cli.FlagEnvHinter = func(envVar, str string) string {
 		return str
 	}

local/local_test.go

@@ -55,7 +55,7 @@ var MockGithubRepositories = []*github.Repository{
 	},
 }
 
-// This mocks the PullRequest service in go-github that is used in production to call the associated Github endpoint
+// This mocks the PullRequest service in go-github that is used in production to call the associated GitHub endpoint
 type mockGithubPullRequestService struct {
 	PullRequest *github.PullRequest
 	Response    *github.Response
@@ -69,7 +69,7 @@ func (m mockGithubPullRequestService) List(ctx context.Context, owner string, re
 	return []*github.PullRequest{m.PullRequest}, m.Response, nil
 }
 
-// This mocks the Repositories service in go-github that is used in production to call the associated Github endpoint
+// This mocks the Repositories service in go-github that is used in production to call the associated GitHub endpoint
 type mockGithubRepositoriesService struct {
 	Repository   *github.Repository
 	Repositories []*github.Repository
@@ -84,12 +84,12 @@ func (m mockGithubRepositoriesService) ListByOrg(ctx context.Context, org string
 	return m.Repositories, m.Response, nil
 }
 
-// A convenience method to return a valid GithubClient configured for testing purposes, complete with the mocked services
+// ConfigureMockGithubClient returns a valid GithubClient configured for testing purposes, complete with the mocked services
 func ConfigureMockGithubClient() auth.GithubClient {
-	// Call the same NewClient method that is used by the actual CLI to obtain a Github client that calls the
-	// Github API. In testing, however, we just implement the mock services above to satisfy the interfaces required
+	// Call the same NewClient method that is used by the actual CLI to obtain a GitHub client that calls the
+	// GitHub API. In testing, however, we just implement the mock services above to satisfy the interfaces required
 	// by the GithubClient. GithubClient is used uniformly between production and test code, with the only difference
-	// being that in test we do not actually execute API calls to Github
+	// being that in test we do not actually execute API calls to GitHub
 	client := auth.NewClient(github.NewClient(nil))
 
 	testHTMLUrl := "https://github.com/gruntwork-io/test/pull/1"

main.go

@@ -40,7 +40,7 @@ func PrintRepoReport(allEvents []types.AnnotatedEvent, runReport *types.RunRepor
 	fmt.Println(runReport.Command)
 	fmt.Println()
 
-	// If the user selected repos via flatfile, print a table showing which repos they were
+	// If the user selected repos via a flat file, print a table showing which repos they were
 	if len(runReport.FileProvidedRepos) > 0 {
 		fmt.Println(" REPOS SUPPLIED VIA --repos FILE FLAG")
 		fileProvidedReposPrinter.Print(runReport.FileProvidedRepos)

mocks/mocks.go

@@ -15,7 +15,7 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
-// getFileDefinedRepos converts user-supplied repositories to Github API response objects that can be further processed
+// getFileDefinedRepos converts user-supplied repositories to GitHub API response objects that can be further processed
 func getFileDefinedRepos(GithubClient auth.GithubClient, allowedRepos []*types.AllowedRepo, tracker *stats.RunStats) ([]*github.Repository, error) {
 	logger := logging.GetLogger("git-xargs")
 
@@ -41,7 +41,7 @@ func getFileDefinedRepos(GithubClient auth.GithubClient, allowedRepos []*types.A
 			if resp.StatusCode == 404 {
 				// This repo does not exist / could not be fetched as named, so we won't include it in the list of repos to process
 
-				// create an empty github repo object to satisfy the stats tracking interface
+				// create an empty GitHub repo object to satisfy the stats tracking interface
 				missingRepo := &github.Repository{
 					Owner: &github.User{Login: github.String(allowedRepo.Organization)},
 					Name:  github.String(allowedRepo.Name),
@@ -65,7 +65,7 @@ func getFileDefinedRepos(GithubClient auth.GithubClient, allowedRepos []*types.A
 	return allRepos, nil
 }
 
-// getReposByOrg takes the string name of a Github organization and pages through the API to fetch all of its repositories
+// getReposByOrg takes the string name of a GitHub organization and pages through the API to fetch all of its repositories
 func getReposByOrg(config *config.GitXargsConfig) ([]*github.Repository, error) {
 
 	logger := logging.GetLogger("git-xargs")

printer/printer.go

@@ -38,7 +38,7 @@ func TestGetFileDefinedRepos(t *testing.T) {
 	assert.NoError(t, reposLookupErr)
 }
 
-// TestGetReposByOrg ensures that you can pass a configuration specifying repo look up by Github Org to getReposByOrg
+// TestGetReposByOrg ensures that you can pass a configuration specifying repo look up by GitHub Org to getReposByOrg
 func TestGetReposByOrg(t *testing.T) {
 	t.Parallel()
 

repository/fetch-repos.go

@@ -8,20 +8,20 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
-// Loop through every repo we've selected and use a WaitGroup so that the processing can happen in parallel
+// ProcessRepos loops through every repo we've selected and use a WaitGroup so that the processing can happen in parallel
 func ProcessRepos(gitxargsConfig *config.GitXargsConfig, repos []*github.Repository) error {
 	logger := logging.GetLogger("git-xargs")
 
 	// Limit the number of concurrent goroutines using the MaxConcurrentRepos config value
-	// MaxConcurrentRepos == 0 will fallback to unlimited (previous default behavior)
+	// MaxConcurrentRepos == 0 will fall back to unlimited (previous default behavior)
 	wg := sizedwaitgroup.New(gitxargsConfig.MaxConcurrentRepos)
 
 	for _, repo := range repos {
 		wg.Add()
 		go func(gitxargsConfig *config.GitXargsConfig, repo *github.Repository) error {
 			defer wg.Done()
 			// For each repo, run the supplied command against it and, if it succeeds without error,
-			// commit the changes, push the local branch to remote and use the Github API to open a pr
+			// commit the changes, push the local branch to remote and use the GitHub API to open a pr
 			processErr := processRepo(gitxargsConfig, repo)
 			if processErr != nil {
 				logger.WithFields(logrus.Fields{
@@ -43,7 +43,7 @@ func ProcessRepos(gitxargsConfig *config.GitXargsConfig, repos []*github.Reposit
 // 4. Look up any worktree changes (deleted files, modified files, new and untracked files) and ADD THEM ALL to the git stage
 // 5. Commit these changes with the optionally configurable git commit message, or fall back to the default if it was not provided by the user
 // 6. Push the branch containing the new commit to the remote origin
-// 7. Via the Github API, open a pull request of the newly pushed branch against the main branch of the repo
+// 7. Via the GitHub API, open a pull request of the newly pushed branch against the main branch of the repo
 // 8. Track all successfully opened pull requests via the stats tracker so that we can print them out as part of our final
 // run report that is displayed in table format to the operator following each run
 func processRepo(config *config.GitXargsConfig, repo *github.Repository) error {
@@ -63,7 +63,7 @@ func processRepo(config *config.GitXargsConfig, repo *github.Repository) error {
 		return headRefErr
 	}
 
-	// Get the worktree for the given local repository so we can examine any changes made by script operations
+	// Get the worktree for the given local repository, so we can examine any changes made by script operations
 	worktree, worktreeErr := getLocalWorkTree(repositoryDir, localRepository, repo)
 
 	if worktreeErr != nil {

repository/fetch-repos_test.go

@@ -49,6 +49,6 @@ func cleanupLocalTestRepoChanges(t *testing.T, config *config.GitXargsConfig) {
 	if err != nil {
 		t.Logf("cleanupLocalTestRepoChanges error deleting test branches: %+v\n", err)
 	} else {
-		t.Log("cleanupLocalTestRepoChanges succesfully deleted branches in local test repo")
+		t.Log("cleanupLocalTestRepoChanges successfully deleted branches in local test repo")
 	}
 }

repository/process.go

@@ -23,7 +23,7 @@ import (
 	"github.com/gruntwork-io/go-commons/logging"
 )
 
-// cloneLocalRepository clones a remote Github repo via SSH to a local temporary directory so that the supplied command
+// cloneLocalRepository clones a remote GitHub repo via SSH to a local temporary directory so that the supplied command
 // can be run against the repo locally and any git changes handled thereafter. The local directory has
 // git-xargs-<repo-name> appended to it to make it easier to find when you are looking for it while debugging
 func cloneLocalRepository(config *config.GitXargsConfig, repo *github.Repository) (string, *git.Repository, error) {
@@ -204,7 +204,7 @@ func checkoutLocalBranch(config *config.GitXargsConfig, ref *plumbing.Reference,
 	if pullErr != nil {
 
 		if pullErr == plumbing.ErrReferenceNotFound {
-			// The suppled branch just doesn't exist yet on the remote - this is not a fatal error and will
+			// The supplied branch just doesn't exist yet on the remote - this is not a fatal error and will
 			// allow the new branch to be pushed in pushLocalBranch
 			config.Stats.TrackSingle(stats.BranchRemoteDidntExistYet, remoteRepository)
 			return branchName, nil
@@ -263,7 +263,7 @@ func updateRepo(config *config.GitXargsConfig, repositoryDir string, worktree *g
 		return pushBranchErr
 	}
 
-	// Open a pull request on Github, of the recently pushed branch against the repository default branch
+	// Open a pull request on GitHub, of the recently pushed branch against the repository default branch
 	openPullRequestErr := openPullRequest(config, remoteRepository, branchName)
 	if openPullRequestErr != nil {
 		return openPullRequestErr
@@ -333,8 +333,8 @@ func commitLocalChanges(status git.Status, config *config.GitXargsConfig, reposi
 	return nil
 }
 
-// pushLocalBranch pushes the branch in the local clone of the /tmp/ directory repository to the Github remote origin
-// so that a pull request can be opened against it via the Github API
+// pushLocalBranch pushes the branch in the local clone of the /tmp/ directory repository to the GitHub remote origin
+// so that a pull request can be opened against it via the GitHub API
 func pushLocalBranch(config *config.GitXargsConfig, remoteRepository *github.Repository, localRepository *git.Repository) error {
 	logger := logging.GetLogger("git-xargs")
 
@@ -379,7 +379,7 @@ func pushLocalBranch(config *config.GitXargsConfig, remoteRepository *github.Rep
 	return nil
 }
 
-// Attempt to open a pull request via the Github API, of the supplied branch specific to this tool, against the main
+// Attempt to open a pull request via the GitHub API, of the supplied branch specific to this tool, against the main
 // branch for the remote origin
 func openPullRequest(config *config.GitXargsConfig, repo *github.Repository, branch string) error {
 	logger := logging.GetLogger("git-xargs")
@@ -435,7 +435,7 @@ func openPullRequest(config *config.GitXargsConfig, repo *github.Repository, bra
 		}
 	}
 
-	// Configure pull request options that the Github client accepts when making calls to open new pull requests
+	// Configure pull request options that the GitHub client accepts when making calls to open new pull requests
 	newPR := &github.NewPullRequest{
 		Title:               github.String(titleToUse),
 		Head:                github.String(branch),
@@ -444,7 +444,7 @@ func openPullRequest(config *config.GitXargsConfig, repo *github.Repository, bra
 		MaintainerCanModify: github.Bool(true),
 	}
 
-	// Make a pull request via the Github API
+	// Make a pull request via the GitHub API
 	pr, _, err := config.GithubClient.PullRequests.Create(context.Background(), *repo.GetOwner().Login, repo.GetName(), newPR)
 
 	if err != nil {