Merge pull request #85 from SasSwart/development

V0.0.17

Author: alexthemayers

Makefile

@@ -1,4 +1,4 @@
-VERSION := v0.0.0
+VERSION := 0.0.0
 
 all: linux_amd64.zip
 
@@ -8,7 +8,7 @@ linux_amd64.zip: build/linux_amd64 LICENSE
 build/linux_amd64: build/linux_amd64/can build/linux_amd64/templates
 
 build/linux_amd64/can:
-	echo '${VERSION}' > ./config/version.txt
+	echo -n '${VERSION}' > ./config/version.txt
 	go build -o ./build/linux_amd64/ ./...
 
 build/linux_amd64/templates:
@@ -24,3 +24,6 @@ test:
 test_coverage:
 	go test ./openapi -coverprofile=coverage.out
 	go tool cover -html=coverage.out
+
+install: build/linux_amd64
+	cp build/linux_amd64/can ~/bin/can

cmd/can/main.go

@@ -1,44 +1,197 @@
 package main
 
 import (
+	"bytes"
 	"fmt"
 	"github.com/sasswart/gin-in-a-can/config"
 	"github.com/sasswart/gin-in-a-can/openapi"
 	"github.com/sasswart/gin-in-a-can/render"
 	golang "github.com/sasswart/gin-in-a-can/render/go"
 	"github.com/sasswart/gin-in-a-can/tree"
+	"io"
 	"os"
+	"path/filepath"
+	"sync"
+
+	"github.com/spf13/cobra"
 )
 
+var canCmd = &cobra.Command{
+	Use:   "can",
+	Short: "Generate code based on OpenAPI specifications",
+}
+
+var generateCmd = &cobra.Command{
+	Use:   "generate",
+	Short: "Generate files",
+	Run: func(cmd *cobra.Command, args []string) {
+		absCfgPath, err := filepath.Abs(config.ConfigFilePath)
+		if err != nil {
+			fmt.Printf("could not resolve relative config path: %v\n", err)
+			return
+		}
+		config.ConfigFilePath = absCfgPath
+
+		configFileReader, err := os.Open(absCfgPath)
+		if err != nil {
+			fmt.Printf("failed to open config file: %v", err)
+			os.Exit(1)
+		}
+
+		configs := config.ReadConfigs(configFileReader)
+
+		generate(configs)
+	},
+}
+
+var cleanCmd = &cobra.Command{
+	Use:   "clean",
+	Short: "Remove generated files",
+	Run: func(cmd *cobra.Command, args []string) {
+		absCfgPath, err := filepath.Abs(config.ConfigFilePath)
+		if err != nil {
+			fmt.Printf("could not resolve relative config path: %v\n", err)
+			return
+		}
+		config.ConfigFilePath = absCfgPath
+
+		configFileReader, err := os.Open(absCfgPath)
+		if err != nil {
+			fmt.Printf("failed to open config file: %v", err)
+			os.Exit(1)
+		}
+
+		configs := config.ReadConfigs(configFileReader)
+
+		clean(configs)
+	},
+}
+
+var versionCmd = &cobra.Command{
+	Use:   "version",
+	Short: "Print the version number",
+	Run: func(cmd *cobra.Command, args []string) {
+		fmt.Printf("Can: v%s\n", config.SemVer)
+	},
+}
+
 func main() {
-	fmt.Printf("can %s\n", config.SemVer)
-	cfg := mustLoadConfig()
+	canCmd.PersistentFlags().StringVarP(
+		&config.ConfigFilePath,
+		"configFile",
+		"c",
+		"./can.yml",
+		"config file (default is ./can.yml)")
+
+	canCmd.PersistentFlags().BoolVarP(
+		&config.Debug,
+		"debug",
+		"d",
+		false,
+		"Enable Debug logging")
+
+	canCmd.PersistentFlags().BoolVarP(
+		&config.Dryrun,
+		"dry-run",
+		"r",
+		false,
+		"Print actions instead of applying them to disk")
+
+	canCmd.AddCommand(generateCmd)
+	canCmd.AddCommand(cleanCmd)
+	canCmd.AddCommand(versionCmd)
+
+	if err := canCmd.Execute(); err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+}
+
+func clean(configs <-chan []byte) {
+	wg := sync.WaitGroup{}
+	for configBytes := range configs {
+
+		wg.Add(1)
+
+		go func(configBytes []byte) {
+			defer wg.Done()
+
+			if len(configBytes) == 0 {
+				if config.Debug {
+					fmt.Println("Skipping empty config")
+				}
+				return
+			}
+
+			configReader := bytes.NewReader(configBytes)
+			cfg := mustLoadConfig(configReader)
+
+			if config.Dryrun {
+				fmt.Printf("Would delete %s\n", cfg.GetOutputDir())
+				return
+			}
+
+			err := os.RemoveAll(cfg.GetOutputDir())
+			if err != nil {
+				fmt.Println(err)
+			}
+
+		}(configBytes)
+	}
+	wg.Wait()
+}
+
+func generate(configs <-chan []byte) {
+	wg := sync.WaitGroup{}
+	for configBytes := range configs {
+
+		wg.Add(1)
+
+		go func(configBytes []byte) {
+			defer wg.Done()
+
+			if len(configBytes) == 0 {
+				if config.Debug {
+					fmt.Println("Skipping empty config")
+				}
+				return
+			}
+
+			configReader := bytes.NewReader(configBytes)
+			cfg := mustLoadConfig(configReader)
+
+			err := executeJobForConfig(cfg)
+			if err != nil {
+				fmt.Println(err)
+			}
+		}(configBytes)
+	}
+	wg.Wait()
+}
+
+func executeJobForConfig(cfg config.Data) error {
+	fmt.Printf("Executing job: %s\n", cfg.Name)
+
 	if config.Debug {
 		fmt.Printf("Reading API specification from \"%s\"\n", cfg.GetOpenAPIFilepath())
 	}
 	apiSpec := mustLoadOpenApiFile(cfg.GetOpenAPIFilepath())
 
 	engine := render.NewEngine(cfg)
 
-	// Setup appropriate renderer via the `strategy` design pattern
-	mustSetStrategy(&engine, cfg.Template.Strategy)
+	err := setStrategy(&engine, cfg.Template.Strategy)
+	if err != nil {
+		return err
+	}
 
 	apiSpec.SetMetadata(tree.Metadata{
 		"package": cfg.Template.BasePackageName,
 	})
 
 	if _, err := tree.Traverse(apiSpec, engine.Render); err != nil {
-		fmt.Println(err.Error())
-		os.Exit(1)
-	}
-}
-
-func mustSetStrategy(engine *render.Engine, strategy string) {
-	err := setStrategy(engine, strategy)
-	if err != nil {
-		fmt.Println(err.Error())
-		os.Exit(1)
+		return err
 	}
+	return nil
 }
 
 func mustLoadOpenApiFile(path string) *openapi.OpenAPI {
@@ -52,6 +205,8 @@ func mustLoadOpenApiFile(path string) *openapi.OpenAPI {
 }
 
 // setStrategy creates and applies the renderer for the given strategy. An error is returned if the strategy is invalid
+// TODO: A "strategy" is really just a renderer. This function should be a factory that returns a renderer, which then
+// gets applied to the engine where this is called.
 func setStrategy(e *render.Engine, strategy string) error {
 	var r render.Renderer
 	switch strategy {
@@ -64,9 +219,9 @@ func setStrategy(e *render.Engine, strategy string) error {
 	return fmt.Errorf("%s render strategy not implemented yet", strategy)
 }
 
-func mustLoadConfig() config.Data {
+func mustLoadConfig(reader io.Reader) config.Data {
 	cfg := config.Data{}
-	err := cfg.Load()
+	err := cfg.Load(reader)
 	if err != nil {
 		fmt.Println(err.Error())
 		os.Exit(1)