cmds

Documentation

Index

• Variables
• func Execute()

Variables

var RootCMD = &cobra.Command{
	Use:   "snips",
	Short: "A code generator for QingCloud & QingStor SDKs.",
	Long: `A code generator for QingCloud & QingStor SDKs.
It is used to generate code from our public APIs currently.

For example:
  $ snips -m QingStor -n latest \
          -s ./specs -t ./templates/qingstor/go \
          -o ./publish/qingstor-sdk-go/service
  $ ...
  $ snips --service=QingStor \
          --service-api-version=latest \
          --spec=./specs \
          --template=./templates/qingstor/ruby \
          --output=./publish/qingstor-sdk-ruby/lib/qingstor/sdk/service
  $ ...

Copyright (C) 2016 Yunify, Inc.`,
	PreRunE: func(cmd *cobra.Command, args []string) error {
		if flagVersion {
			return nil
		}

		if codeSpecDirectory == "" {
			return errors.New("please specify spec files directory")
		}
		if _, err := os.Stat(codeSpecDirectory); err != nil {
			return errors.New("please make sure the specs directory exists")
		}

		if codeTemplateDirectory == "" {
			return errors.New("please specify templates directory")
		}
		if _, err := os.Stat(codeTemplateDirectory); err != nil {
			return errors.New("please make sure the templates directory exists")
		}

		if codeOutputDirectory == "" {
			return errors.New("please specify output files directory")
		}

		return nil
	},
	Run: func(cmd *cobra.Command, args []string) {
		if flagVersion {
			fmt.Println("snips version " + metadata.Version)
			return
		}

		loadedTemplates, _, err := templates.LoadTemplates(codeTemplateDirectory)
		utils.CheckErrorForExit(err)
		fmt.Println("Loaded templates from " + codeTemplateDirectory)
		fmt.Println(len(loadedTemplates), "template(s) detected.")

		service, err := specs.LoadServices(codeSpecDirectory, codeSpecFormat, codeServiceModule)
		utils.CheckErrorForExit(err)
		apiVersion := service.APIVersions[codeServiceAPIVersion]
		if apiVersion == nil {
			utils.CheckErrorForExit(fmt.Errorf(
				"API version \"%s\" of service \"%s\" not found",
				codeServiceAPIVersion,
				utils.SnakeCaseToCamelCase(service.Filename),
			))
		}

		fmt.Printf(
			"Loaded service %s (%s) from %s\n\n",
			utils.SnakeCaseToCamelCase(service.Filename),
			service.LatestAPIVersion.Filename,
			codeSpecDirectory)

		if spec := apiVersion.Spec; spec != nil {
			codeCapsule := &capsules.BaseCapsule{CapsulePowder: &capsules.CapsulePowder{}}
			codeGenerator := generator.New()

			codeCapsule.SetData(spec.Data)
			codeCapsule.SetVersioning(codeServiceAPIVersion != "latest")

			sharedTemplateContent := ""
			if template := loadedTemplates["shared"]; template != nil {
				sharedTemplateContent = template.FileContent
			}

			if template := loadedTemplates["service"]; template != nil {
				template.FileContent += sharedTemplateContent
				template.UpdateOutputFilename(spec.Data.Service.Name, template.OutputFileNaming.Style)
				template.UpdateOutputFilePath(codeOutputDirectory)
				codeCapsule.SetMode("", "")
				codeGenerator.Set(codeCapsule, template)
				err = codeGenerator.Run()
				utils.CheckErrorForExit(err)
			}

			if template := loadedTemplates["sub_service"]; template != nil {
				template.FileContent += sharedTemplateContent
				for _, subService := range spec.Data.SubServices {
					template.UpdateOutputFilename(subService.Name, template.OutputFileNaming.Style)
					template.UpdateOutputFilePath(codeOutputDirectory)
					codeCapsule.SetMode(template.ID, subService.ID)
					codeGenerator.Set(codeCapsule, template)
					err = codeGenerator.Run()
					utils.CheckErrorForExit(err)
				}
			}

			if template := loadedTemplates["types"]; template != nil {
				template.FileContent += sharedTemplateContent
				template.UpdateOutputFilename("types", template.OutputFileNaming.Style)
				template.UpdateOutputFilePath(codeOutputDirectory)
				codeCapsule.SetMode("", "")
				codeGenerator.Set(codeCapsule, template)
				err = codeGenerator.Run()
				utils.CheckErrorForExit(err)
			}
		}

		fmt.Println("\nEverything looks fine.")
	},
}

RootCMD represents the base command when called without any subcommands.

Functions

func Execute

func Execute()

Execute adds all child commands to the root command sets flags appropriately. This is called by entrance of the application. It only needs to happen once to the rootCMD.