Merge pull request #35 from Kristina-Pianykh/add-cli-arg-for-output-file

Add cli arg for output file

Author: corylanou

.github/workflows/hype.yml

@@ -1,5 +1,8 @@
 name: Generate README with Hype
-on: [pull_request]
+on:
+  push:
+    branches:
+      - main
 jobs:
   build:
     runs-on: ubuntu-latest
@@ -16,7 +19,7 @@ jobs:
       - name: Install hype
         run: go install github.com/gopherguides/hype/cmd/hype@latest
       - name: Run hype
-        run: hype export -format=markdown -f hype.md > README.md
+        run: hype export -format=markdown -f hype.md -o README.md
       - name: Commit README back to the repo
         run: |-
           git rev-parse --abbrev-ref HEAD

.github/workflows/tests.yml

@@ -1,5 +1,9 @@
 name: Go Test and Lint
-on: [push]
+on:
+  push:
+    branches:
+      - main
+  pull_request:
 jobs:
   tests-on:
     name: ${{matrix.go-version}} ${{matrix.os}}
@@ -19,11 +23,10 @@ jobs:
       - name: Verify Go Modules
         run: go mod verify
       - name: Build
-        run: go build -v ./cmd/hype/
+        run: make build
       - name: Run tests with Race Detector
         run: |
-          go_dirs=$(go list ./... | grep -v '/docs')
-          go test -race -vet=off $go_dirs
+          make test
       - name: Install staticcheck
         run: go install honnef.co/go/tools/cmd/staticcheck@latest
       - name: Run staticcheck

Makefile

@@ -1,7 +1,7 @@
 default: test install hype
 
 test:
-	go test -timeout 10s -count 1 -race -cover $$(go list ./... | grep -v /docs/)
+	go test -count 1 -race -vet=off -cover $$(go list ./... | grep -v /docs/)
 
 cov:
 	go test -coverprofile=coverage.out ./...
@@ -15,4 +15,11 @@ install:
 	go install -v ./cmd/hype
 
 hype:
-	hype export -format=markdown -f hype.md > ./README.md
+	hype export -format=markdown -f hype.md -o ./README.md
+
+.PHONY: build docs
+build:
+	go build -o hype ./cmd/hype/
+
+docs: build
+	./hype export -f hype.md -format markdown -o README.md

cli_errors_test.go renamed to cli_integration_test.go

@@ -28,27 +28,20 @@ func getProjectWd() string {
 }
 
 func Test_Cli_Error(t *testing.T) {
-	t.Parallel()
 	r := require.New(t)
 
 	binPath := filepath.Join(t.TempDir(), "hype")
 	buildBin(binPath)
 
 	root := filepath.Join(getProjectWd(), "testdata", "to_md", "source_code", "broken")
-	err := os.Chdir(root)
-	r.NoError(err)
+	t.Chdir(root)
 
 	args := []string{"export", "-format=markdown", "-f", "hype.md"}
 
 	t.Logf("Running command: %s %s, root: %s", binPath, strings.Join(args, " "), root)
 
-	hypeCmd := exec.Command(binPath, args...)
-	var stderr bytes.Buffer
-	var stdout bytes.Buffer
-	hypeCmd.Stderr = &stderr
-	hypeCmd.Stdout = &stdout
-
-	err = hypeCmd.Run()
+	hypeCmd, stdout, _ := setupCmd(binPath, args)
+	err := hypeCmd.Run()
 	r.Error(err)
 
 	r.Equal(0, stdout.Len())
@@ -60,26 +53,31 @@ func Test_Cli_Error(t *testing.T) {
 	r.Equal(1, exitCode)
 }
 
+func setupCmd(binPath string, args []string) (*exec.Cmd, *bytes.Buffer, *bytes.Buffer) {
+	cmd := exec.Command(binPath, args...)
+	var stderr bytes.Buffer
+	var stdout bytes.Buffer
+	cmd.Stderr = &stderr
+	cmd.Stdout = &stdout
+
+	return cmd, &stdout, &stderr
+}
+
 func Test_Cli_Success(t *testing.T) {
-	t.Parallel()
 	r := require.New(t)
 
 	binPath := filepath.Join(t.TempDir(), "hype")
 	buildBin(binPath)
 
 	root := filepath.Join(getProjectWd(), "testdata", "to_md", "source_code", "full")
-	err := os.Chdir(root)
-	r.NoError(err)
+	t.Chdir(root)
 
 	args := []string{"export", "-format=markdown", "-f", "hype.md"}
+
 	t.Logf("Running command: %s %s", binPath, strings.Join(args, " "))
-	hypeCmd := exec.Command(binPath, args...)
-	var stderr bytes.Buffer
-	var stdout bytes.Buffer
-	hypeCmd.Stderr = &stderr
-	hypeCmd.Stdout = &stdout
 
-	err = hypeCmd.Run()
+	hypeCmd, stdout, stderr := setupCmd(binPath, args)
+	err := hypeCmd.Run()
 	if err != nil {
 		fmt.Printf("%s\n", stderr.String())
 	}
@@ -97,3 +95,58 @@ func Test_Cli_Success(t *testing.T) {
 
 	r.Equal(exp, act)
 }
+
+func Test_Output_Flag_Error(t *testing.T) {
+	r := require.New(t)
+
+	binPath := filepath.Join(t.TempDir(), "hype")
+	buildBin(binPath)
+
+	root := filepath.Join(getProjectWd(), "testdata", "to_md", "source_code", "broken")
+	t.Chdir(root)
+
+	inputFile := "hype.md"
+	outputFile := inputFile
+
+	args := []string{"export", "-format=markdown", "-f", inputFile, "-o", outputFile}
+	hypeCmd, _, _ := setupCmd(binPath, args)
+	err := hypeCmd.Run()
+	r.Error(err)
+
+	info, err := os.Stat(filepath.Join(root, inputFile))
+	r.NoError(err)
+
+	r.True(info.Size() > 0)
+}
+
+func Test_Output_Flag_Success(t *testing.T) {
+	r := require.New(t)
+
+	binPath := filepath.Join(t.TempDir(), "hype")
+	buildBin(binPath)
+
+	root := filepath.Join(getProjectWd(), "testdata", "to_md", "source_code", "full")
+	t.Chdir(root)
+
+	inputFile := "hype.md"
+	outputFile := filepath.Join(t.TempDir(), "output.md")
+
+	args := []string{"export", "-format=markdown", "-f", inputFile, "-o", outputFile}
+	hypeCmd, _, _ := setupCmd(binPath, args)
+	err := hypeCmd.Run()
+	r.NoError(err)
+
+	info, err := os.Stat(outputFile)
+	r.NoError(err)
+	r.True(info.Size() > 0)
+
+	bExp, err := os.ReadFile(filepath.Join(root, "hype.gold"))
+	r.NoError(err)
+	bAct, err := os.ReadFile(outputFile)
+	r.NoError(err)
+
+	exp := strings.TrimSpace(string(bExp))
+	act := strings.TrimSpace(string(bAct))
+
+	r.Equal(exp, act)
+}

cmd/hype/cli/export.go

@@ -1,6 +1,7 @@
 package cli
 
 import (
+	"bytes"
 	"context"
 	"flag"
 	"fmt"
@@ -23,6 +24,7 @@ type Export struct {
 
 	// a folder containing all chapters of a book, for example
 	File    string        // optional file name to preview
+	OutPath OutPath       // path to a file to write the output on success; default: nil
 	Timeout time.Duration // default: 30s
 	Parser  *hype.Parser  // If nil, a default parser is used.
 	Verbose bool          // default: false
@@ -91,6 +93,7 @@ Examples:
 	hype export -format html
 	hype export -f README.md -format html
 	hype export -f README.md -format markdown -timeout=10s
+	hype export -f input.md -format markdown -o README.md
 `
 
 	if err := cmd.validate(); err != nil {
@@ -110,6 +113,7 @@ Examples:
 	cmd.flags.StringVar(&cmd.File, "f", "hype.md", "optional file name to preview, if not provided, defaults to hype.md")
 	cmd.flags.BoolVar(&cmd.Verbose, "v", false, "enable verbose output for debugging")
 	cmd.flags.StringVar(&cmd.Format, "format", "markdown", "content type to export to: markdown, html")
+	cmd.flags.Var(&cmd.OutPath, "o", "path to the output file; if not provided, output is written to stdout")
 
 	cmd.flags.Usage = func() {
 		fmt.Fprintf(stderr, "Usage of %s:\n", os.Args[0])
@@ -145,6 +149,8 @@ func (cmd *Export) main(ctx context.Context, pwd string, args []string) error {
 		return err
 	}
 
+	cmd.initOutputFilePath()
+
 	flags, err := cmd.Flags(cmd.Stderr())
 	if err != nil {
 		return err
@@ -153,6 +159,10 @@ func (cmd *Export) main(ctx context.Context, pwd string, args []string) error {
 	if err := flags.Parse(args); err != nil {
 		return err
 	}
+
+	var stdoutBuffer bytes.Buffer
+	cmd.setOut(&stdoutBuffer)
+
 	if cmd.Verbose {
 		// enable debugging
 		slog.SetDefault(slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelDebug})))
@@ -173,9 +183,40 @@ func (cmd *Export) main(ctx context.Context, pwd string, args []string) error {
 		return err
 	}
 
+	if !cmd.OutPath.Exists() {
+		_, err := stdoutBuffer.WriteTo(os.Stdout)
+		if err != nil {
+			return fmt.Errorf("failed to write to os.Stdout: %s", err)
+		}
+	} else {
+		path := cmd.OutPath.Value()
+		file, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
+		if err != nil {
+			return err
+		}
+		defer file.Close()
+
+		_, err = stdoutBuffer.WriteTo(file)
+		if err != nil {
+			return fmt.Errorf("failed to write to %s: %v", path, err)
+		}
+	}
+
 	return nil
 }
 
+func (cmd *Export) initOutputFilePath() {
+	cmd.mu.Lock()
+	cmd.OutPath = OutPath{val: nil}
+	cmd.mu.Unlock()
+}
+
+func (cmd *Export) setOut(writer io.Writer) {
+	cmd.mu.Lock()
+	cmd.Out = writer
+	cmd.mu.Unlock()
+}
+
 func (cmd *Export) execute(ctx context.Context, pwd string) error {
 	err := cmd.validate()
 	if err != nil {

cmd/hype/cli/output.go

@@ -0,0 +1,83 @@
+package cli
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+type OutPath struct {
+	val *string
+}
+
+func (o *OutPath) String() string {
+	if o.val == nil {
+		return ""
+	}
+	return o.Value()
+}
+
+func (o *OutPath) Value() string {
+	return *o.val
+}
+
+func (o *OutPath) Exists() bool {
+	return o.val != nil
+}
+
+func dirExists(path string) error {
+	pInfo, err := os.Stat(path)
+
+	// path exists
+	if err == nil {
+		// path exists but it's a directory
+		if pInfo.IsDir() {
+			return fmt.Errorf("expected a file path but received path to a directory: %s. ", path)
+		}
+		return nil
+	}
+
+	// path doesn't exist, check if the dir exists
+	dir := filepath.Dir(path)
+	if _, err = os.Stat(dir); err != nil {
+		return err
+	}
+	return nil
+}
+
+func cleanPath(p string) (string, error) {
+	if filepath.IsAbs(p) {
+		return filepath.Clean(p), nil
+	}
+
+	pwd, err := os.Getwd()
+	if err != nil {
+		return "", fmt.Errorf("failed to identify current working directory: %s", err.Error())
+	}
+	filepath.Clean(p)
+	fullPath := filepath.Join(pwd, p)
+	return fullPath, nil
+}
+
+func (o *OutPath) Set(path string) error {
+	path = strings.TrimSpace(path)
+
+	// path not set
+	if len(path) == 0 {
+		return nil
+	}
+
+	fullPath, err := cleanPath(path)
+	if err != nil {
+		return err
+	}
+
+	err = dirExists(fullPath)
+	if err != nil {
+		return err
+	}
+
+	o.val = &fullPath
+	return nil
+}