Move surface model generation from code generators up into gnostic.

Author: timburks

gnostic.go

@@ -49,35 +49,36 @@ import (
 	"github.com/googleapis/gnostic/discovery"
 	"github.com/googleapis/gnostic/jsonwriter"
 	plugins "github.com/googleapis/gnostic/plugins"
+	surface "github.com/googleapis/gnostic/surface"
 	"gopkg.in/yaml.v2"
 )
 
-const ( // OpenAPI Version
-	openAPIvUnknown = 0
-	openAPIv2       = 2
-	openAPIv3       = 3
-	discoveryFormat = 4
+const ( // Source Format
+	SourceFormatUnknown   = 0
+	SourceFormatOpenAPI2  = 2
+	SourceFormatOpenAPI3  = 3
+	SourceFormatDiscovery = 4
 )
 
 // Determine the version of an OpenAPI description read from JSON or YAML.
 func getOpenAPIVersionFromInfo(info interface{}) int {
 	m, ok := compiler.UnpackMap(info)
 	if !ok {
-		return openAPIvUnknown
+		return SourceFormatUnknown
 	}
 	swagger, ok := compiler.MapValueForKey(m, "swagger").(string)
 	if ok && strings.HasPrefix(swagger, "2.0") {
-		return openAPIv2
+		return SourceFormatOpenAPI2
 	}
 	openapi, ok := compiler.MapValueForKey(m, "openapi").(string)
 	if ok && strings.HasPrefix(openapi, "3.0") {
-		return openAPIv3
+		return SourceFormatOpenAPI3
 	}
 	kind, ok := compiler.MapValueForKey(m, "kind").(string)
 	if ok && kind == "discovery#restDescription" {
-		return discoveryFormat
+		return SourceFormatDiscovery
 	}
-	return openAPIvUnknown
+	return SourceFormatUnknown
 }
 
 const (
@@ -91,7 +92,7 @@ type pluginCall struct {
 }
 
 // Invokes a plugin.
-func (p *pluginCall) perform(document proto.Message, openAPIVersion int, sourceName string) error {
+func (p *pluginCall) perform(document proto.Message, sourceFormat int, sourceName string) error {
 	if p.Name != "" {
 		request := &plugins.Request{}
 
@@ -142,13 +143,16 @@ func (p *pluginCall) perform(document proto.Message, openAPIVersion int, sourceN
 		request.OutputPath = outputLocation
 
 		request.SourceName = sourceName
-		switch openAPIVersion {
-		case openAPIv2:
+		switch sourceFormat {
+		case SourceFormatOpenAPI2:
 			request.Openapi2 = document.(*openapi_v2.Document)
-		case openAPIv3:
+			request.Surface, _ = surface.NewModelFromOpenAPI2(request.Openapi2)
+		case SourceFormatOpenAPI3:
 			request.Openapi3 = document.(*openapi_v3.Document)
+			request.Surface, _ = surface.NewModelFromOpenAPI3(request.Openapi3)
 		default:
 		}
+
 		requestBytes, _ := proto.Marshal(request)
 
 		cmd := exec.Command(executableName, "-plugin")
@@ -232,7 +236,7 @@ type Gnostic struct {
 	resolveReferences bool
 	pluginCalls       []*pluginCall
 	extensionHandlers []compiler.ExtensionHandler
-	openAPIVersion    int
+	sourceFormat      int
 }
 
 // Initialize a structure to store global application state.
@@ -340,18 +344,18 @@ func (g *Gnostic) readOpenAPIText(bytes []byte) (message proto.Message, err erro
 		return nil, err
 	}
 	// Determine the OpenAPI version.
-	g.openAPIVersion = getOpenAPIVersionFromInfo(info)
-	if g.openAPIVersion == openAPIvUnknown {
+	g.sourceFormat = getOpenAPIVersionFromInfo(info)
+	if g.sourceFormat == SourceFormatUnknown {
 		return nil, errors.New("unable to identify OpenAPI version")
 	}
 	// Compile to the proto model.
-	if g.openAPIVersion == openAPIv2 {
+	if g.sourceFormat == SourceFormatOpenAPI2 {
 		document, err := openapi_v2.NewDocument(info, compiler.NewContextWithExtensions("$root", nil, &g.extensionHandlers))
 		if err != nil {
 			return nil, err
 		}
 		message = document
-	} else if g.openAPIVersion == openAPIv3 {
+	} else if g.sourceFormat == SourceFormatOpenAPI3 {
 		document, err := openapi_v3.NewDocument(info, compiler.NewContextWithExtensions("$root", nil, &g.extensionHandlers))
 		if err != nil {
 			return nil, err
@@ -373,21 +377,21 @@ func (g *Gnostic) readOpenAPIBinary(data []byte) (message proto.Message, err err
 	documentV3 := &openapi_v3.Document{}
 	err = proto.Unmarshal(data, documentV3)
 	if err == nil && strings.HasPrefix(documentV3.Openapi, "3.0") {
-		g.openAPIVersion = openAPIv3
+		g.sourceFormat = SourceFormatOpenAPI3
 		return documentV3, nil
 	}
 	// if that failed, try to read an OpenAPI v2 document
 	documentV2 := &openapi_v2.Document{}
 	err = proto.Unmarshal(data, documentV2)
 	if err == nil && strings.HasPrefix(documentV2.Swagger, "2.0") {
-		g.openAPIVersion = openAPIv2
+		g.sourceFormat = SourceFormatOpenAPI2
 		return documentV2, nil
 	}
 	// if that failed, try to read a Discovery Format document
 	discoveryDocument := &discovery_v1.Document{}
 	err = proto.Unmarshal(data, discoveryDocument)
 	if err == nil { // && strings.HasPrefix(documentV2.Swagger, "2.0") {
-		g.openAPIVersion = discoveryFormat
+		g.sourceFormat = SourceFormatDiscovery
 		return discoveryDocument, nil
 	}
 	return nil, err
@@ -416,19 +420,19 @@ func (g *Gnostic) writeJSONYAMLOutput(message proto.Message) {
 	var rawInfo yaml.MapSlice
 	var ok bool
 	var err error
-	if g.openAPIVersion == openAPIv2 {
+	if g.sourceFormat == SourceFormatOpenAPI2 {
 		document := message.(*openapi_v2.Document)
 		rawInfo, ok = document.ToRawInfo().(yaml.MapSlice)
 		if !ok {
 			rawInfo = nil
 		}
-	} else if g.openAPIVersion == openAPIv3 {
+	} else if g.sourceFormat == SourceFormatOpenAPI3 {
 		document := message.(*openapi_v3.Document)
 		rawInfo, ok = document.ToRawInfo().(yaml.MapSlice)
 		if !ok {
 			rawInfo = nil
 		}
-	} else if g.openAPIVersion == discoveryFormat {
+	} else if g.sourceFormat == SourceFormatDiscovery {
 		document := message.(*discovery_v1.Document)
 		rawInfo, ok = document.ToRawInfo().(yaml.MapSlice)
 		if !ok {
@@ -467,10 +471,10 @@ func (g *Gnostic) writeJSONYAMLOutput(message proto.Message) {
 func (g *Gnostic) performActions(message proto.Message) (err error) {
 	// Optionally resolve internal references.
 	if g.resolveReferences {
-		if g.openAPIVersion == openAPIv2 {
+		if g.sourceFormat == SourceFormatOpenAPI2 {
 			document := message.(*openapi_v2.Document)
 			_, err = document.ResolveReferences(g.sourceName)
-		} else if g.openAPIVersion == openAPIv3 {
+		} else if g.sourceFormat == SourceFormatOpenAPI3 {
 			document := message.(*openapi_v3.Document)
 			_, err = document.ResolveReferences(g.sourceName)
 		}
@@ -492,7 +496,7 @@ func (g *Gnostic) performActions(message proto.Message) (err error) {
 	}
 	// Call all specified plugins.
 	for _, p := range g.pluginCalls {
-		err := p.perform(message, g.openAPIVersion, g.sourceName)
+		err := p.perform(message, g.sourceFormat, g.sourceName)
 		if err != nil {
 			writeFile(g.errorOutputPath, g.errorBytes(err), g.sourceName, "errors")
 			defer os.Exit(-1) // run all plugins, even when some have errors

plugins/gnostic-go-generator/main.go

@@ -18,10 +18,10 @@ package main
 
 import (
 	"encoding/json"
+	"errors"
 	"strings"
 
 	plugins "github.com/googleapis/gnostic/plugins"
-	surface "github.com/googleapis/gnostic/surface"
 )
 
 // This is the main function for the code generation plugin.
@@ -42,15 +42,15 @@ func main() {
 		files = []string{"client.go", "server.go", "provider.go", "types.go", "constants.go"}
 	}
 
-	// Create the model.
-	var model *surface.Model
-	if env.Request.Openapi2 != nil {
-		model, err = surface.NewModelFromOpenAPI2(env.Request.Openapi2)
-	} else if env.Request.Openapi3 != nil {
-		model, err = surface.NewModelFromOpenAPI3(env.Request.Openapi3)
+	// Get the code surface model.
+	model := env.Request.Surface
+
+	if model == nil {
+		err = errors.New("No generated code surface model is available.")
+		env.RespondAndExitIfError(err)
 	}
-	env.RespondAndExitIfError(err)
 
+	// Customize the code surface model for Go
 	NewGoLanguageModel().Prepare(model)
 
 	modelJSON, _ := json.MarshalIndent(model, "", "  ")

plugins/plugin.pb.go

@@ -25,6 +25,7 @@ syntax = "proto3";
 import "github.com/googleapis/gnostic/OpenAPIv2/OpenAPIv2.proto";
 import "github.com/googleapis/gnostic/OpenAPIv3/OpenAPIv3.proto";
 import "github.com/googleapis/gnostic/discovery/discovery.proto";
+import "github.com/googleapis/gnostic/surface/surface.proto";
 
 package gnostic.plugin.v1;
 
@@ -92,6 +93,9 @@ message Request {
 
   // Discovery API representation
   discovery.v1.Document discovery = 7;
+  
+  // generated code surface representation
+  surface.v1.Model surface = 8;
 }
 
 // The plugin writes an encoded Response to stdout.