Merge pull request #29 from speakeasy-api/ad/init-cmd-build-from-config

Ad/init cmd build from config

Author: alexadrake

cmd/speakeasy/build.go

@@ -0,0 +1,175 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"regexp"
+
+	"github.com/speakeasy-api/parser/apipackage"
+	"github.com/speakeasy-api/parser/services/parser"
+	"github.com/urfave/cli/v2"
+	"gopkg.in/yaml.v2"
+)
+
+type SpeakeasyConfig struct {
+	Name string
+	Spec struct {
+		Version string
+		Schemas struct {
+			Type    string
+			Version string
+			Output  string
+		}
+	}
+	Root string
+}
+
+const configOutputRegexp = "(yaml|json)"
+
+var buildFlags = []cli.Flag{
+	&cli.StringFlag{
+		Name:    searchDirFlag,
+		Aliases: []string{"d"},
+		Value:   "./",
+		Usage:   "Directories you want to parse,comma separated and general-info file must be in the first one",
+	},
+	&cli.StringFlag{
+		Name:  excludeFlag,
+		Usage: "Exclude directories and files when searching, comma separated",
+	},
+	&cli.StringFlag{
+		Name:    propertyStrategyFlag,
+		Aliases: []string{"p"},
+		Value:   parser.CamelCase,
+		Usage:   "Property Naming Strategy like " + parser.SnakeCase + "," + parser.CamelCase + "," + parser.PascalCase,
+	},
+	&cli.StringFlag{
+		Name:    outputFlag,
+		Aliases: []string{"o"},
+		Value:   "./docs",
+		Usage:   "Output directory for all the generated files(opeanapi.json, opeanapi.yaml)",
+	},
+	&cli.StringFlag{
+		Name:    configFileFlag,
+		Aliases: []string{"c"},
+		Value:   speakeasyConfigFileName,
+		Usage:   "Yaml file to load speakeasy configuration from",
+	},
+	&cli.BoolFlag{
+		Name:  parseVendorFlag,
+		Usage: "Parse go files in 'vendor' folder, disabled by default",
+	},
+	&cli.BoolFlag{
+		Name:    parseDependencyFlag,
+		Aliases: []string{"pd"},
+		Usage:   "Parse go files inside dependency folder, disabled by default",
+	},
+	&cli.StringFlag{
+		Name:    markdownFilesFlag,
+		Aliases: []string{"md"},
+		Value:   "",
+		Usage:   "Parse folder containing markdown files to use as description, disabled by default",
+	},
+	&cli.StringFlag{
+		Name:    codeExampleFilesFlag,
+		Aliases: []string{"cef"},
+		Value:   "",
+		Usage:   "Parse folder containing code example files to use for the x-codeSamples extension, disabled by default",
+	},
+	&cli.BoolFlag{
+		Name:  parseInternalFlag,
+		Usage: "Parse go files in internal packages, disabled by default",
+	},
+	&cli.BoolFlag{
+		Name:  generatedTimeFlag,
+		Usage: "Generate timestamp at the top of docs.go, disabled by default",
+	},
+	&cli.IntFlag{
+		Name:  parseDepthFlag,
+		Value: 100,
+		Usage: "Dependency parse depth",
+	},
+	&cli.StringFlag{
+		Name:  instanceNameFlag,
+		Value: "",
+		Usage: "This parameter can be used to name different schema(openapi) document instances. It is optional.",
+	},
+	&cli.StringFlag{
+		Name:  overridesFileFlag,
+		Value: apipackage.DefaultOverridesFile,
+		Usage: "File to read global type overrides from.",
+	},
+}
+
+func readConfig(fileName string) ([]SpeakeasyConfig, error) {
+	content, err := os.ReadFile(fileName)
+	if err != nil {
+		return []SpeakeasyConfig{}, err
+	}
+
+	reader := bytes.NewReader(content)
+	decoder := yaml.NewDecoder(reader)
+
+	var configs []SpeakeasyConfig
+	config := SpeakeasyConfig{}
+	for decoder.Decode(&config) == nil {
+		configs = append(configs, config)
+	}
+	return configs, nil
+}
+
+func buildAction(c *cli.Context) error {
+	strategy := c.String(propertyStrategyFlag)
+
+	switch strategy {
+	case parser.CamelCase, parser.SnakeCase, parser.PascalCase:
+	default:
+		return fmt.Errorf("not supported %s propertyStrategy", strategy)
+	}
+
+	var configs, err = readConfig(c.String(configFileFlag))
+	if err != nil {
+		return err
+	}
+
+	if len(configs) == 0 {
+		return fmt.Errorf("no valid configurations found")
+	}
+
+	for _, config := range configs {
+		r, err := regexp.Compile(configOutputRegexp)
+		if err != nil {
+			return err
+		}
+
+		outputTypes := r.FindAllString(config.Spec.Schemas.Output, -1)
+		if len(outputTypes) == 0 {
+			return fmt.Errorf("no valid output types specified")
+		}
+
+		err = apipackage.New().Build(&apipackage.Config{
+			SearchDir:          c.String(searchDirFlag),
+			Excludes:           c.String(excludeFlag),
+			MainAPIFile:        config.Root,
+			PropNamingStrategy: strategy,
+			// TODO: use the -o flag for the output dir and add property "OutputFile" to
+			// parser config to determine the output-file name.
+			OutputDir:           fmt.Sprintf("schemas/%s", config.Name),
+			OutputTypes:         outputTypes,
+			ParseVendor:         c.Bool(parseVendorFlag),
+			ParseDependency:     c.Bool(parseDependencyFlag),
+			MarkdownFilesDir:    c.String(markdownFilesFlag),
+			ParseInternal:       c.Bool(parseInternalFlag),
+			GeneratedTime:       c.Bool(generatedTimeFlag),
+			CodeExampleFilesDir: c.String(codeExampleFilesFlag),
+			ParseDepth:          c.Int(parseDepthFlag),
+			InstanceName:        c.String(instanceNameFlag),
+			OverridesFile:       c.String(overridesFileFlag),
+		})
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

cmd/speakeasy/build_test.go

@@ -0,0 +1,68 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/speakeasy-api/parser/services/parser"
+	"github.com/urfave/cli/v2"
+)
+
+const testOutputDirectory = ".buildTestOutput"
+
+func TestBuild(t *testing.T) {
+	defer func() {
+		// Clean up temporary output directories.
+		err := os.RemoveAll("schemas")
+		if err != nil {
+			panic(err)
+		}
+	}()
+
+	validConfigFile := "test_fixtures/speakeasy.yaml"
+	invalidConfigFile := "test_fixtures/invalidConfigFile.yaml"
+
+	tests := []struct {
+		configFile, strategy string
+		expected             string
+	}{
+		{validConfigFile, parser.CamelCase, ""},
+		{validConfigFile, parser.SnakeCase, ""},
+		{validConfigFile, parser.PascalCase, ""},
+		{validConfigFile, parser.PascalCase, ""},
+		{validConfigFile, "invalidStrategy", "not supported invalidStrategy propertyStrategy"},
+		{invalidConfigFile, parser.PascalCase, fmt.Sprintf("open %s: no such file or directory", invalidConfigFile)},
+		{"test_fixtures/speakeasy_with_invalid_output.yaml", parser.PascalCase, "no valid output types specified"},
+	}
+
+	for _, test := range tests {
+
+		// Create temporary output directory.
+		if _, err := os.Stat(testOutputDirectory); os.IsNotExist(err) {
+			err := os.Mkdir(testOutputDirectory, os.ModePerm)
+			if err != nil {
+				panic(err)
+			}
+		}
+
+		t.Run(fmt.Sprintf("%s, %s", test.configFile, test.strategy), func(t *testing.T) {
+			set := flag.NewFlagSet("test", 0)
+			set.String(configFileFlag, test.configFile, "yaml")
+			set.String(propertyStrategyFlag, test.strategy, "strategy")
+			set.String(searchDirFlag, "test_fixtures", "search")
+			set.String(generalInfoFlag, "fixture.go", "generalInfo")
+
+			actual := buildAction(cli.NewContext(nil, set, nil))
+
+			if actual == nil {
+				if test.expected != "" {
+					t.Errorf("Got nil, expected error with message '%s'", test.expected)
+				}
+			} else if actual.Error() != test.expected {
+				t.Errorf("Got error with message %s, expected message %s", actual.Error(), test.expected)
+			}
+		})
+	}
+}

cmd/speakeasy/init.go

@@ -0,0 +1,86 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/urfave/cli/v2"
+)
+
+var initFlags = []cli.Flag{
+	&cli.StringFlag{
+		Name:    generalInfoFlag,
+		Aliases: []string{"g"},
+		Value:   "main.go",
+		Usage:   "Go file path in which 'OpenAPI general API Info' is written",
+	},
+	&cli.StringFlag{
+		Name:    apiNameFlag,
+		Aliases: []string{"n"},
+		Value:   "main_api",
+		Usage:   "Name of the api",
+	},
+}
+
+const (
+	actionFileName  = ".github/workflows/speakeasy.yaml"
+	apiNameVariable = "SPEAKEASY_API_NAME"
+	apiRootVariable = "SPEAKEASY_API_ROOT"
+)
+
+func writeSliceToFile(stringsToWrite []string, fileName string) error {
+	file, err := os.Create(fileName)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	for _, s := range stringsToWrite {
+		_, err = file.WriteString(fmt.Sprintf("%s\n", s))
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func buildConfigStrings(c *cli.Context) []string {
+	nameString := fmt.Sprintf("name: %s", c.String(apiNameFlag))
+	versionString := "\tversion: v1"
+	openApiString := "\t\tOpenAPI3.0\n\t\tversion: 1.0.0"
+	rootString := fmt.Sprintf("\troot: %s", c.String(generalInfoFlag))
+	return []string{nameString, versionString, openApiString, rootString}
+}
+
+func buildActionStrings() []string {
+	// \n adds line of white-space
+	nameString := "name: Run Speakeasy CLI\n"
+	jobsString := "jobs:\n\tsetup_and_run_speakeasy:\n"
+	containerString := "\t\truns-on: ubuntu-latest\n\n\t\tpermissions:\n\t\t\tcontents: 'read'\n\t\t\tid-token: 'write'\n"
+	stepsString := "\t\tsteps:"
+	checkoutString := "\t\t\t- name: Checkout\n\t\t\t\tuses: actions/checkout@v3\n\t\t\t\twith:\n\t\t\t\t\tref: ${{ github.head_ref }}\n"
+	downloadString := "\t\t\t- name: Download Speakeasy\n\t\t\t\tuses: speakeasy-api/speakeasy-github-action\n"
+
+	// This builds and executes the speakeasy build command
+	runString := "\t\t- name: Setup and Update API state\n\t\t\trun: speakeasy build"
+
+	// The changes should be committed
+	commitString := "\t\t- name: Commit API state\n\t\t\trun: git add schemas; git commit -m \"[no ci]Add schema files\"; git push\n"
+
+	return []string{nameString, jobsString, containerString, stepsString, checkoutString, downloadString, runString, commitString}
+}
+
+func initAction(c *cli.Context) error {
+	configStrings := buildConfigStrings(c)
+	err := writeSliceToFile(configStrings, speakeasyConfigFileName)
+	if err != nil {
+		return err
+	}
+
+	buildActionStrings := buildActionStrings()
+	err = writeSliceToFile(buildActionStrings, actionFileName)
+	if err != nil {
+		return err
+	}
+	return nil
+}

cmd/speakeasy/init_test.go

@@ -0,0 +1,52 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"testing"
+
+	"github.com/urfave/cli/v2"
+)
+
+func TestBuildConfigStrings(t *testing.T) {
+	var tests = []struct {
+		name, generalInfo string
+		expected          []string
+	}{
+		{"api_name", "main.go", []string{"name: api_name", "\troot: main.go"}},
+		{"other_api", "controller.go", []string{"name: other_api", "\troot: controller.go"}},
+	}
+	expectedLength := 4
+
+	for _, test := range tests {
+
+		t.Run(fmt.Sprintf("%s, %s", test.name, test.generalInfo), func(t *testing.T) {
+			set := flag.NewFlagSet("test", 0)
+			set.String(apiNameFlag, test.name, "name")
+			set.String(generalInfoFlag, test.generalInfo, "generalInfo")
+
+			actual := buildConfigStrings(cli.NewContext(nil, set, nil))
+
+			if len(actual) != expectedLength {
+				t.Errorf("Receieved %d strings, expected %d", len(actual), expectedLength)
+			}
+			if actual[0] != test.expected[0] {
+				t.Errorf("Received %s, expected %s", actual[0], test.expected[0])
+			}
+			if actual[3] != test.expected[1] {
+				t.Errorf("Received %s, expected %s", actual[3], test.expected[1])
+			}
+		})
+	}
+}
+
+func TestBuildActionStrings(t *testing.T) {
+	expectedCount := 8
+	t.Run("action string count", func(t *testing.T) {
+		actual := buildActionStrings()
+
+		if len(actual) != expectedCount {
+			t.Errorf("Received %d strings, expected %d", len(actual), expectedCount)
+		}
+	})
+}