Allow reading repo names via stdin (#16)

Thanks for reviewing! Going to merge this in now.

Author: brikis98

.gitignore

@@ -1,2 +1,4 @@
 git-xargs
 test-repo/
+.idea
+*.iml

README.md

@@ -30,7 +30,7 @@ You can handle these use cases and many more with a single `git-xargs` command.
 As an example, let's use `git-xargs` to create a new file in every repo:
 
 ```
-./git-xargs \
+git-xargs \
   --branch-name test-branch \
   --github-org <your-github-org> \
   --commit-message "Create hello-world.txt" \
@@ -129,68 +129,71 @@ COMMAND SUPPLIED
 
 ## Getting started
 
-### 1. Export a valid Github token
-
-See the guide on [Github personal access tokens](https://docs.github.com/en/free-pro-team@latest/github/authenticating-to-github/creating-a-personal-access-token) for information on how to generate one.
-
-```
-export GITHUB_OAUTH_TOKEN=<your-secret-github-oauth-token>
-```
+1. **Export a valid Github token**. See the guide on [Github personal access 
+   tokens](https://docs.github.com/en/free-pro-team@latest/github/authenticating-to-github/creating-a-personal-access-token) 
+   for information on how to generate one. For example, on Linux or Mac, you'd run:
 
-### 2. Download the correct binary for your platform
+    ```bash
+    export GITHUB_OAUTH_TOKEN=<your-secret-github-oauth-token>
+    ```
 
-Visit [the releases page](https://github.com/gruntwork-io/git-xargs/releases) and download the correct binary depending on your system. For example, you might opt to save it to `/usr/local/bin/git-xargs`. 
+1. **Download the correct binary for your platform**. Visit [the releases 
+   page](https://github.com/gruntwork-io/git-xargs/releases) and download the correct binary depending on your system.
+   Save it to somewhere on your `PATH`, such as `/usr/local/bin/git-xargs`. 
 
-### 3. Set the correct permissions
+1. **Set execute permissions**. For example, on Linux or Mac, you'd run:
 
-`chmod u+x /usr/local/bin/git-xargs`
+    ```bash
+    chmod u+x /usr/local/bin/git-xargs
+    ```
 
-### 4. Run the version command to ensure everything is working properly
+1. **Check it's working**. Run the version command to ensure everything is working properly:
 
-```
-git-xargs --version
-```
+    ```bash
+    git-xargs --version
+    ```
 
-### 5. Provide a script or command and target some repos
+1. **Provide a script or command and target some repos**. Here's a simple example of running the `touch` command in 
+   every repo in your Github organization. Follow the same pattern to start running your own scripts and commands 
+   against your own repos!
 
-Here's a simple example of running a touch commnand in every repo in your Github organization. Follow the same pattern to start running your own scripts and commands against your own repos!
+    ```bash
+    git-xargs \
+      --branch-name "test-branch" \
+      --commit-message "Testing git-xargs" \
+      --github-org <enter-your-github-org-name> \
+      touch git-xargs-is-awesome.txt
+    ```
 
-```
-git-xargs \
-  --branch-name "test-branch" \
-  --commit-message "Testing git-xargs" \
-  --github-org <enter-your-github-org-name> \
-  touch git-xargs-is-awesome.txt
-```
 # Reference
 
 ## How to supply commands or scripts to run
 
 The API for `git-xargs` is:
 
 ```
-./git-xargs [-flags] <CMD>
+git-xargs [-flags] <CMD>
 ```
 
 Where `CMD` is either the full path to a (Bash, Python, Ruby) etc script on your local system or a binary. Note that, because the tool supports Bash scripts, Ruby scripts, Python scripts, etc, you must include the full filename for any given script, including its file extension.
 
 In other words, all the following usages are valid:
 
 ```
-./git-xargs --repo --repo gruntwork-io/cloud-nuke \
+git-xargs --repo --repo gruntwork-io/cloud-nuke \
    --repo gruntwork-io/terraform-aws-eks \
    --branch-name my-branch \
    /usr/local/bin/my-bash-script.sh
 ```
 
 ```
-./git-xargs --repos ./my-repos.txt \
+git-xargs --repos ./my-repos.txt \
   --branch-name my-other-branch \
   touch file1.txt file2.txt
 ```
 
 ```
-./git-xargs --github-org my-github-org \ 
+git-xargs --github-org my-github-org \ 
   --branch-name my-new-branch \
   "$(pwd)/scripts/my-ruby-script.rb"
 ```
@@ -208,7 +211,7 @@ Currently, `git-xargs` will find and add any and all new files, as well as any e
 Scripts may be placed anywhere on your system, but you are responsible for providing absolute paths to your scripts when invoking `git-xargs`:
 
 ```
-./git-xargs \
+git-xargs \
   --branch-name upgrade-tf-14 \
   --commit-message "Update modules to Terraform 0.14" \
   --repos data/batch3.txt \
@@ -217,7 +220,7 @@ Scripts may be placed anywhere on your system, but you are responsible for provi
 or
 
 ```
-./git-xargs \
+git-xargs \
   --branch-name upgrade-tf-14 \
   --commit-message "Update modules to Terraform 0.14" \
   --repos data/batch3.txt \
@@ -228,13 +231,14 @@ If you need to compose more complex behavior into a single pull request, write a
 
 ## How to target repos to run your scripts against
 
-`git-xargs` supports **two** methods of targeting repos to run your selected scripts against. Note that you **must** select one or the other option when running `git-xargs`, meaning you must either pass `--repos` or `--github-org` as demonstrated below:
+`git-xargs` supports **four** methods of targeting repos to run your selected scripts against. They are processed in
+the order listed below, with whichever option is found first being used, and all others after it being ignored.
 
 ### Option #1: Github organization lookup
 If you want the tool to find and select every repo in your Github organization, you can pass the name of your organization via the `--github-org` flag:
 
 ```
-./git-xargs \
+git-xargs \
   --commit-message "Update copyright year" \
   --github-org <your-github-org> \ 
   "$(pwd)/scripts/update-copyright-year.sh"
@@ -247,7 +251,7 @@ This will signal the tool to look up, and page through, every repository in your
 Oftentimes, you want finer-grained control over the exact repos you are going to run your script against. In this case, you can use the `--repos` flag and supply the path to a file defining the exact repos you want the tool to run your selected scripts against, like so:
 
 ```
-./git-xargs \
+git-xargs \
   --commit-mesage "Update copyright year" \
   --repos data/batch2.txt \
   "$(pwd)/scripts/update-copyright-year.sh"
@@ -264,9 +268,34 @@ gruntwork-io/infrastructure-modules-multi-account-acme
 
 Flat files contain one repo per line, each repository in the format of `<github-organization>/<repo-name>`. Commas, trailing or preceding spaces, and quotes are all filtered out at runtime. This is done in case you end up copying your repo list from a JSON list or CSV file.
 
+### Option #3: Pass in repos via command line args
+
+Another way to get fine-grained control is to pass in the individual repos you want to use via one or more `--repo` 
+arguments:
+
+```
+git-xargs \
+  --commit-mesage "Update copyright year" \
+  --repo gruntwork-io/terragrunt \
+  --repo gruntwork-io/terratest \
+  --repo gruntwork-io/cloud-nuke \
+  "$(pwd)/scripts/update-copyright-year.sh"
+```
+
+### Option #4: Pass in repos via stdin
+
+And one more (Unix-philosophy friendly) way to get fine-grained control is to pass in the individual repos you want to 
+use by piping them in via `stdin`, separating repo names with whitespace or newlines:
+
+```
+echo "gruntwork-io/terragrunt gruntwork-io/terratest" | git-xargs \
+  --commit-mesage "Update copyright year" \
+  "$(pwd)/scripts/update-copyright-year.sh"
+```
+
 ## Notable flags
 
-`git-xargs` exposes several flags that allow you to customize its behavior to better suit your needs. For the latest info on flags, you should run `./git-xargs --help`. However, a couple of the flags are worth explaining more in depth here:
+`git-xargs` exposes several flags that allow you to customize its behavior to better suit your needs. For the latest info on flags, you should run `git-xargs --help`. However, a couple of the flags are worth explaining more in depth here:
 
 |Flag|Description|Type|Required|
 |---|---|---|---|

cmd/common.go

@@ -41,7 +41,6 @@ var (
 	genericBranchFlag = cli.StringFlag{
 		Name:     BranchFlagName,
 		Usage:    "The name of the branch on which changes will be made",
-		Required: true,
 	}
 	genericCommitMessageFlag = cli.StringFlag{
 		Name:  CommitMessageFlagName,

cmd/git-xargs.go

@@ -1,9 +1,13 @@
 package main
 
 import (
+	"bufio"
 	"github.com/gruntwork-io/go-commons/errors"
 	"github.com/gruntwork-io/go-commons/logging"
 	"github.com/urfave/cli"
+	"io"
+	"os"
+	"strings"
 )
 
 // GitXargsConfig is the internal representation of a given git-xargs run as specified by the user
@@ -17,6 +21,7 @@ type GitXargsConfig struct {
 	ReposFile              string
 	GithubOrg              string
 	RepoSlice              []string
+	RepoFromStdIn          []string
 	Args                   []string
 	GithubClient           GithubClient
 	GitClient              GitClient
@@ -35,6 +40,7 @@ func NewGitXargsConfig() *GitXargsConfig {
 		ReposFile:              "",
 		GithubOrg:              "",
 		RepoSlice:              []string{},
+		RepoFromStdIn:          []string{},
 		Args:                   []string{},
 		GithubClient:           configureGithubClient(),
 		GitClient:              NewGitClient(GitProductionProvider{}),
@@ -44,7 +50,7 @@ func NewGitXargsConfig() *GitXargsConfig {
 
 // parseGitXargsConfig accepts a urfave cli context and binds its values
 // to an internal representation of the data supplied by the user
-func parseGitXargsConfig(c *cli.Context) *GitXargsConfig {
+func parseGitXargsConfig(c *cli.Context) (*GitXargsConfig, error) {
 	config := NewGitXargsConfig()
 	config.DryRun = c.Bool("dry-run")
 	config.SkipPullRequests = c.Bool("skip-pull-requests")
@@ -57,7 +63,56 @@ func parseGitXargsConfig(c *cli.Context) *GitXargsConfig {
 	config.RepoSlice = c.StringSlice("repo")
 	config.Args = c.Args()
 
-	return config
+	shouldReadStdIn, err := dataBeingPipedToStdIn()
+	if err != nil {
+		return nil, err
+	}
+	if shouldReadStdIn {
+		repos, err := parseSliceFromStdIn()
+		if err != nil {
+			return nil, err
+		}
+		config.RepoFromStdIn = repos
+	}
+
+	return config, nil
+}
+
+// Return true if there is data being piped to stdin and false otherwise
+// Based on https://stackoverflow.com/a/26567513/483528.
+func dataBeingPipedToStdIn() (bool, error) {
+	stat, err := os.Stdin.Stat()
+	if err != nil {
+		return false, err
+	}
+
+	return stat.Mode()&os.ModeCharDevice == 0, nil
+}
+
+// Read the data being passed to stdin and parse it as a slice of strings, where we assume strings are separated by
+// whitespace or newlines. All extra whitespace and empty lines are ignored.
+func parseSliceFromStdIn() ([]string, error) {
+	return parseSliceFromReader(os.Stdin)
+}
+
+// Read the data from the given reader and parse it as a slice of strings, where we assume strings are separated by
+// whitespace or newlines. All extra whitespace and empty lines are ignored.
+func parseSliceFromReader(reader io.Reader) ([]string, error) {
+	out := []string{}
+
+	scanner := bufio.NewScanner(reader)
+	for scanner.Scan() {
+		words := strings.Fields(scanner.Text())
+		for _, word := range words {
+			text := strings.TrimSpace(word)
+			if text != "" {
+				out = append(out, text)
+			}
+		}
+	}
+
+	err := scanner.Err()
+	return out, errors.WithStackTrace(err)
 }
 
 // handleRepoProcessing encapsulates the main processing logic for the supplied repos and printing the run report that
@@ -101,11 +156,19 @@ func sanityCheckInputs(config *GitXargsConfig) error {
 
 // 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() {
+		return cli.ShowAppHelp(c)
+	}
+
 	logger := logging.GetLogger("git-xargs")
 
 	logger.Info("git-xargs running...")
 
-	config := parseGitXargsConfig(c)
+	config, err := parseGitXargsConfig(c)
+	if err != nil {
+		return err
+	}
 
 	if err := sanityCheckInputs(config); err != nil {
 		return err

cmd/git-xargs_test.go

@@ -1,6 +1,8 @@
 package main
 
 import (
+	"github.com/stretchr/testify/require"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -21,3 +23,34 @@ func TestHandleRepoProcessing(t *testing.T) {
 
 	assert.NoError(t, err)
 }
+
+func TestParseSliceFromReader(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name     string
+		input    string
+		expected []string
+	}{
+		{"empty string", "", []string{}},
+		{"one string", "foo", []string{"foo"}},
+		{"one string with whitespace", "    foo\t\t\t", []string{"foo"}},
+		{"multiple strings separated by whitespace", "foo bar     baz\t\tblah", []string{"foo", "bar", "baz", "blah"}},
+		{"multiple strings separated by newlines", "foo\nbar\nbaz\nblah", []string{"foo", "bar", "baz", "blah"}},
+		{"multiple strings separated by newlines, with extra newlines", "\n\nfoo\nbar\n\nbaz\nblah\n\n\n", []string{"foo", "bar", "baz", "blah"}},
+	}
+
+	for _, testCase := range testCases {
+		// The following is necessary to make sure testCase's values don't
+		// get updated due to concurrency within the scope of t.Run(..) below
+		testCase := testCase
+
+		t.Run(testCase.name, func(t *testing.T) {
+			t.Parallel()
+
+			actual, err := parseSliceFromReader(strings.NewReader(testCase.input))
+			require.NoError(t, err)
+			require.Equal(t, testCase.expected, actual)
+		})
+	}
+}

cmd/main_test.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"flag"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -13,13 +14,19 @@ func TestSetupApp(t *testing.T) {
 	assert.NotNil(t, app)
 }
 
-func TestGitXargsRejectsEmptyArgs(t *testing.T) {
+func TestGitXargsShowsHelpTextForEmptyArgs(t *testing.T) {
 	app := setupApp()
 
+	// Capture the app's stdout
+	var stdout strings.Builder
+	app.Writer = &stdout
+
 	emptyFlagSet := flag.NewFlagSet("git-xargs-test", flag.ContinueOnError)
 	emptyTestContext := cli.NewContext(app, emptyFlagSet, nil)
 
 	err := runGitXargs(emptyTestContext)
 
-	assert.Error(t, err)
+	// Make sure we see the help text
+	assert.NoError(t, err)
+	assert.Contains(t, stdout.String(), app.Description)
 }