Add vendor folder to git

vendor/github.com/googleapis/gnostic/generator/main.go

@@ -0,0 +1,235 @@
+// Copyright 2017 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// generator generates Protocol Buffer models and support code from
+// JSON Schemas. It is used to generate representations of the
+// OpenAPI Specification and vendor and specification extensions
+// that are added by third-party OpenAPI authors.
+package main
+
+import (
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path"
+	"runtime"
+	"strings"
+
+	"github.com/googleapis/gnostic/jsonschema"
+)
+
+const LICENSE = "" +
+	"// Copyright 2017 Google Inc. All Rights Reserved.\n" +
+	"//\n" +
+	"// Licensed under the Apache License, Version 2.0 (the \"License\");\n" +
+	"// you may not use this file except in compliance with the License.\n" +
+	"// You may obtain a copy of the License at\n" +
+	"//\n" +
+	"//    http://www.apache.org/licenses/LICENSE-2.0\n" +
+	"//\n" +
+	"// Unless required by applicable law or agreed to in writing, software\n" +
+	"// distributed under the License is distributed on an \"AS IS\" BASIS,\n" +
+	"// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n" +
+	"// See the License for the specific language governing permissions and\n" +
+	"// limitations under the License.\n"
+
+func proto_options(packageName string) []ProtoOption {
+	return []ProtoOption{
+		ProtoOption{
+			Name:  "java_multiple_files",
+			Value: "true",
+			Comment: "// This option lets the proto compiler generate Java code inside the package\n" +
+				"// name (see below) instead of inside an outer class. It creates a simpler\n" +
+				"// developer experience by reducing one-level of name nesting and be\n" +
+				"// consistent with most programming languages that don't support outer classes.",
+		},
+
+		ProtoOption{
+			Name:  "java_outer_classname",
+			Value: "OpenAPIProto",
+			Comment: "// The Java outer classname should be the filename in UpperCamelCase. This\n" +
+				"// class is only used to hold proto descriptor, so developers don't need to\n" +
+				"// work with it directly.",
+		},
+
+		ProtoOption{
+			Name:    "java_package",
+			Value:   "org." + packageName,
+			Comment: "// The Java package name must be proto package name with proper prefix.",
+		},
+
+		ProtoOption{
+			Name:  "objc_class_prefix",
+			Value: "OAS",
+			Comment: "// A reasonable prefix for the Objective-C symbols generated from the package.\n" +
+				"// It should at a minimum be 3 characters long, all uppercase, and convention\n" +
+				"// is to use an abbreviation of the package name. Something short, but\n" +
+				"// hopefully unique enough to not conflict with things that may come along in\n" +
+				"// the future. 'GPB' is reserved for the protocol buffer implementation itself.",
+		},
+	}
+}
+
+func GenerateOpenAPIModel(version string) error {
+	var input string
+	var filename string
+	var proto_packagename string
+	var extension_name string
+
+	switch version {
+	case "v2":
+		input = "openapi-2.0.json"
+		filename = "OpenAPIv2"
+		proto_packagename = "openapi.v2"
+		extension_name = "vendorExtension"
+	case "v3":
+		input = "openapi-3.0.json"
+		filename = "OpenAPIv3"
+		proto_packagename = "openapi.v3"
+		extension_name = "specificationExtension"
+	default:
+		return errors.New(fmt.Sprintf("Unknown OpenAPI version %s", version))
+	}
+
+	go_packagename := strings.Replace(proto_packagename, ".", "_", -1)
+
+	project_root := os.Getenv("GOPATH") + "/src/github.com/googleapis/gnostic/"
+
+	base_schema, err := jsonschema.NewSchemaFromFile(project_root + "jsonschema/schema.json")
+	if err != nil {
+		return err
+	}
+	base_schema.ResolveRefs()
+	base_schema.ResolveAllOfs()
+
+	openapi_schema, err := jsonschema.NewSchemaFromFile(project_root + filename + "/" + input)
+	if err != nil {
+		return err
+	}
+	openapi_schema.ResolveRefs()
+	openapi_schema.ResolveAllOfs()
+
+	// build a simplified model of the types described by the schema
+	cc := NewDomain(openapi_schema, version)
+	// generators will map these patterns to the associated property names
+	// these pattern names are a bit of a hack until we find a more automated way to obtain them
+	cc.PatternNames = map[string]string{
+		"^x-": extension_name,
+		// v2
+		"^/": "path",
+		"^([0-9]{3})$|^(default)$": "responseCode",
+		// v3
+		"^([0-9]{3})$": "responseCode",
+		"{property}":   "property",
+		"{name}":       "name",
+		"{expression}": "expression",
+		"/{path}":      "path",
+		"{media-type}": "mediaType",
+	}
+	err = cc.Build()
+	if err != nil {
+		return err
+	}
+
+	if true {
+		log.Printf("Type Model:\n%s", cc.Description())
+	}
+
+	// ensure that the target directory exists
+	err = os.MkdirAll(filename, 0755)
+	if err != nil {
+		return err
+	}
+
+	// generate the protocol buffer description
+	proto := cc.GenerateProto(proto_packagename, LICENSE,
+		proto_options(go_packagename), []string{"google/protobuf/any.proto"})
+	proto_filename := project_root + filename + "/" + filename + ".proto"
+	err = ioutil.WriteFile(proto_filename, []byte(proto), 0644)
+	if err != nil {
+		return err
+	}
+
+	// generate the compiler
+	compiler := cc.GenerateCompiler(go_packagename, LICENSE, []string{
+		"fmt",
+		"gopkg.in/yaml.v2",
+		"strings",
+		"github.com/googleapis/gnostic/compiler",
+	})
+	go_filename := project_root + filename + "/" + filename + ".go"
+	err = ioutil.WriteFile(go_filename, []byte(compiler), 0644)
+	if err != nil {
+		return err
+	}
+	// format the compiler
+	return exec.Command(runtime.GOROOT()+"/bin/gofmt", "-w", go_filename).Run()
+}
+
+func usage() string {
+	return fmt.Sprintf(`
+Usage: %s [OPTIONS]
+Options:
+  --v2
+    Generate Protocol Buffer representation and support code for OpenAPI v2.
+    Files are read from and written to appropriate locations in the gnostic project directory.
+  --v3  
+    Generate Protocol Buffer representation and support code for OpenAPI v3
+    Files are read from and written to appropriate locations in the gnostic project directory.
+  --extension EXTENSION_SCHEMA [EXTENSIONOPTIONS] 
+    Generate a gnostic extension that reads a set of OpenAPI extensions.
+    EXTENSION_SCHEMA is the json schema for the OpenAPI extensions to be supported.
+    EXTENSION_OPTIONS
+      --out_dir=PATH: Location for writing extension models and support code.
+`, path.Base(os.Args[0]))
+}
+
+func main() {
+	var openapi_version = ""
+	var generate_extensions = false
+
+	for i, arg := range os.Args {
+		if i == 0 {
+			continue // skip the tool name
+		}
+		if arg == "--v2" {
+			openapi_version = "v2"
+		} else if arg == "--v3" {
+			openapi_version = "v3"
+		} else if arg == "--extension" {
+			generate_extensions = true
+			break
+		} else {
+			fmt.Printf("Unknown option: %s.\n%s\n", arg, usage())
+			os.Exit(-1)
+		}
+	}
+
+	if openapi_version != "" {
+		err := GenerateOpenAPIModel(openapi_version)
+		if err != nil {
+			fmt.Printf("%+v\n", err)
+		}
+	} else if generate_extensions {
+		err := ProcessExtensionGenCommandline(usage())
+		if err != nil {
+			fmt.Printf("%+v\n", err)
+		}
+	} else {
+		fmt.Printf("%s\n", usage())
+	}
+}