added targetted message logic, updated tests and docs (#35)

* added targetted message logic, updated tests and docs

* reversed make fmt

Co-authored-by: Steve High <[email protected]>

Author: schigh

Makefile

@@ -1,18 +1,27 @@
 default: build
 
+.PHONY: build
 build:
 	@echo "Generating binary (protoc-gen-jsonschema) ..."
 	@mkdir -p bin
 	@go build -o bin/protoc-gen-jsonschema cmd/protoc-gen-jsonschema/main.go
 
+.PHONY: fmt
+fmt:
+	@gofmt -s -w .
+	@goimports -w -local github.com/chrusty/protoc-gen-jsonschema .
+
+.PHONY: install
 install:
 	@GO111MODULE=on go get github.com/chrusty/protoc-gen-jsonschema/cmd/protoc-gen-jsonschema && go install github.com/chrusty/protoc-gen-jsonschema/cmd/protoc-gen-jsonschema
 
+.PHONY: build_linux
 build_linux:
 	@echo "Generating Linux-amd64 binary (protoc-gen-jsonschema.linux-amd64) ..."
 	@GOOS=linux GOARCH=amd64 go build -o protoc-gen-jsonschema.linux-amd64
 
 PROTO_PATH ?= "internal/converter/testdata/proto"
+.PHONY: samples
 samples:
 	@echo "Generating sample JSON-Schemas ..."
 	@mkdir -p jsonschemas
@@ -37,6 +46,8 @@ samples:
 	@PATH=./bin:$$PATH; protoc --jsonschema_out=all_fields_required:jsonschemas --proto_path=${PROTO_PATH} ${PROTO_PATH}/Proto2NestedObject.proto || echo "No messages found (Proto2NestedObject.proto)"
 	@PATH=./bin:$$PATH; protoc -I /usr/include --jsonschema_out=jsonschemas --proto_path=${PROTO_PATH} ${PROTO_PATH}/WellKnown.proto || echo "No messages found (WellKnown.proto)"
 	@PATH=./bin:$$PATH; protoc --jsonschema_out=jsonschemas --proto_path=${PROTO_PATH} ${PROTO_PATH}/NoPackage.proto
+	@PATH=./bin:$$PATH; protoc --jsonschema_out=messages=[MessageKind10+MessageKind11+MessageKind12]:jsonschemas --proto_path=${PROTO_PATH} ${PROTO_PATH}/TwelveMessages.proto || echo "No messages found (TwelveMessages.proto)"
 
+.PHONY: test
 test:
 	@go test ./... -cover -v

README.md

@@ -24,18 +24,49 @@ Usage
 protoc-gen-jsonschema is designed to run like any other proto generator. The following examples show how to use options flags to enable different generator behaviours (more examples in the Makefile too).
 
 * Allow NULL values (by default, JSONSchemas will reject NULL values unless we explicitly allow them):
-    `protoc --jsonschema_out=allow_null_values:. --proto_path=testdata/proto testdata/proto/ArrayOfPrimitives.proto`
+
+```shell script
+protoc --jsonschema_out=allow_null_values:. --proto_path=testdata/proto testdata/proto/ArrayOfPrimitives.proto
+```
+
 * Disallow additional properties (JSONSchemas won't validate JSON containing extra parameters):
-    `protoc --jsonschema_out=disallow_additional_properties:. --proto_path=testdata/proto testdata/proto/ArrayOfPrimitives.proto`
+    
+```shell script
+protoc --jsonschema_out=disallow_additional_properties:. --proto_path=testdata/proto testdata/proto/ArrayOfPrimitives.proto
+```
+
 * Disallow permissive validation of big-integers as strings (eg scientific notation):
-    `protoc --jsonschema_out=disallow_bigints_as_strings:. --proto_path=testdata/proto testdata/proto/ArrayOfPrimitives.proto`
+
+```shell script
+protoc --jsonschema_out=disallow_bigints_as_strings:. --proto_path=testdata/proto testdata/proto/ArrayOfPrimitives.proto
+```
+
 * Prefix generated schema files with their package name (as a directory):
-    `protoc --jsonschema_out=prefix_schema_files_with_package:. --proto_path=testdata/proto testdata/proto/ArrayOfPrimitives.proto`
+
+```shell script
+protoc --jsonschema_out=prefix_schema_files_with_package:. --proto_path=testdata/proto testdata/proto/ArrayOfPrimitives.proto
+```
+
 * Require all fields (because proto3 doesn't accommodate this):
-     `protoc --jsonschema_out=all_fields_required:. --proto_path=testdata/proto testdata/proto/ArrayOfPrimitives.proto`
+
+```shell script
+protoc --jsonschema_out=all_fields_required:. --proto_path=testdata/proto testdata/proto/ArrayOfPrimitives.proto
+```
+
 * Enable debug logging:
-    `protoc --jsonschema_out=debug:. --proto_path=testdata/proto testdata/proto/ArrayOfPrimitives.proto`
 
+```shell script
+protoc --jsonschema_out=debug:. --proto_path=testdata/proto testdata/proto/ArrayOfPrimitives.proto
+```
+
+* Target _specific_ messages within a proto file:
+
+```shell script
+# Generates MessageKind10.jsonschema and MessageKind11.jsonschema
+# Use this to generate json schema from proto files with multiple messages
+# Separate schema names with '+'
+protoc --jsonschema_out=messages=[MessageKind10+MessageKind11]:. --proto_path=testdata/proto testdata/proto/TwelveMessages.proto
+```
 
 Sample protos (for testing)
 ---------------------------
@@ -49,3 +80,4 @@ Sample protos (for testing)
 * Proto containing a stand-alone enum: [samples.ImportedEnum](internal/converter/testdata/proto/ImportedEnum.proto)
 * Proto containing 2 stand-alone enums: [samples.FirstEnum, samples.SecondEnum](internal/converter/testdata/proto/SeveralEnums.proto)
 * Proto containing 2 messages: [samples.FirstMessage, samples.SecondMessage](internal/converter/testdata/proto/SeveralMessages.proto)
+* Proto containing 12 messages: [samples.MessageKind1 - samples.MessageKind12](internal/converter/testdata/proto/TwelveMessages.proto)

internal/converter/converter.go

@@ -6,6 +6,7 @@ import (
 	"io"
 	"io/ioutil"
 	"path"
+	"regexp"
 	"strings"
 
 	"github.com/alecthomas/jsonschema"
@@ -15,6 +16,10 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
+const (
+	messageDelimiter = "+"
+)
+
 // Converter is everything you need to convert protos to JSONSchemas:
 type Converter struct {
 	AllFieldsRequired            bool
@@ -25,6 +30,7 @@ type Converter struct {
 	UseProtoAndJSONFieldnames    bool
 	logger                       *logrus.Logger
 	sourceInfo                   *sourceCodeInfo
+	messageTargets               []string
 }
 
 // New returns a configured *Converter:
@@ -50,11 +56,8 @@ func (c *Converter) ConvertFrom(rd io.Reader) (*plugin.CodeGeneratorResponse, er
 		return nil, err
 	}
 
-	c.parseGeneratorParameters(req.GetParameter())
-
 	c.logger.Debug("Converting input")
 	return c.convert(req)
-	// return c.debugger(req)
 }
 
 func (c *Converter) parseGeneratorParameters(parameters string) {
@@ -75,6 +78,16 @@ func (c *Converter) parseGeneratorParameters(parameters string) {
 		case "proto_and_json_fieldnames":
 			c.UseProtoAndJSONFieldnames = true
 		}
+
+		// look for specific message targets
+		// message types are separated by messageDelimiter "+"
+		// examples:
+		// 		messages=[foo+bar]
+		// 		messages=[foo]
+		rx := regexp.MustCompile(`messages=\[([^\]]+)\]`)
+		if matches := rx.FindStringSubmatch(parameter); len(matches) == 2 {
+			c.messageTargets = strings.Split(matches[1], messageDelimiter)
+		}
 	}
 }
 
@@ -106,15 +119,17 @@ func (c *Converter) convertEnumType(enum *descriptor.EnumDescriptorProto) (jsons
 
 // Converts a proto file into a JSON-Schema:
 func (c *Converter) convertFile(file *descriptor.FileDescriptorProto) ([]*plugin.CodeGeneratorResponse_File, error) {
-
 	// Input filename:
 	protoFileName := path.Base(file.GetName())
 
 	// Prepare a list of responses:
-	response := []*plugin.CodeGeneratorResponse_File{}
+	var response []*plugin.CodeGeneratorResponse_File
+
+	// user wants specific messages
+	genSpecificMessages := len(c.messageTargets) > 0
 
 	// Warn about multiple messages / enums in files:
-	if len(file.GetMessageType()) > 1 {
+	if !genSpecificMessages && len(file.GetMessageType()) > 1 {
 		c.logger.WithField("schemas", len(file.GetMessageType())).WithField("proto_filename", protoFileName).Warn("protoc-gen-jsonschema will create multiple MESSAGE schemas from one proto file")
 	}
 	if len(file.GetEnumType()) > 1 {
@@ -155,6 +170,12 @@ func (c *Converter) convertFile(file *descriptor.FileDescriptorProto) ([]*plugin
 			return nil, fmt.Errorf("no such package found: %s", file.GetPackage())
 		}
 		for _, msg := range file.GetMessageType() {
+
+			// skip if we are only generating schema for specific messages
+			if genSpecificMessages && !contains(c.messageTargets, msg.GetName()) {
+				continue
+			}
+
 			jsonSchemaFileName := c.generateSchemaFilename(file, msg.GetName())
 			c.logger.WithField("proto_filename", protoFileName).WithField("msg_name", msg.GetName()).WithField("jsonschema_filename", jsonSchemaFileName).Info("Generating JSON-schema for MESSAGE")
 
@@ -185,6 +206,8 @@ func (c *Converter) convertFile(file *descriptor.FileDescriptorProto) ([]*plugin
 }
 
 func (c *Converter) convert(req *plugin.CodeGeneratorRequest) (*plugin.CodeGeneratorResponse, error) {
+	c.parseGeneratorParameters(req.GetParameter())
+
 	generateTargets := make(map[string]bool)
 	for _, file := range req.GetFileToGenerate() {
 		generateTargets[file] = true
@@ -197,16 +220,12 @@ func (c *Converter) convert(req *plugin.CodeGeneratorRequest) (*plugin.CodeGener
 			c.logger.WithField("filename", file.GetName()).Warn("Proto file doesn't specify a package")
 			continue
 		}
+
 		for _, msg := range file.GetMessageType() {
 			c.logger.WithField("msg_name", msg.GetName()).WithField("package_name", file.GetPackage()).Debug("Loading a message")
 			c.registerType(file.Package, msg)
 		}
-	}
-	for _, file := range req.GetProtoFile() {
-		if file.GetPackage() == "" {
-			c.logger.WithField("filename", file.GetName()).Warn("Proto file doesn't specify a package")
-			continue
-		}
+
 		if _, ok := generateTargets[file.GetName()]; ok {
 			c.logger.WithField("filename", file.GetName()).Debug("Converting file")
 			converted, err := c.convertFile(file)
@@ -222,7 +241,17 @@ func (c *Converter) convert(req *plugin.CodeGeneratorRequest) (*plugin.CodeGener
 
 func (c *Converter) generateSchemaFilename(file *descriptor.FileDescriptorProto, protoName string) string {
 	if c.PrefixSchemaFilesWithPackage {
-		return (fmt.Sprintf("%s/%s.jsonschema", file.GetPackage(), protoName))
+		return fmt.Sprintf("%s/%s.jsonschema", file.GetPackage(), protoName)
+	}
+	return fmt.Sprintf("%s.jsonschema", protoName)
+}
+
+func contains(haystack []string, needle string) bool {
+	for i := 0; i < len(haystack); i++ {
+		if haystack[i] == needle {
+			return true
+		}
 	}
-	return (fmt.Sprintf("%s.jsonschema", protoName))
+
+	return false
 }

internal/converter/converter_test.go

@@ -28,6 +28,7 @@ type sampleProto struct {
 	PrefixSchemaFilesWithPackage bool
 	ProtoFileName                string
 	UseProtoAndJSONFieldNames    bool
+	TargetedMessages             []string
 }
 
 func TestGenerateJsonSchema(t *testing.T) {
@@ -65,6 +66,11 @@ func testConvertSampleProto(t *testing.T, sampleProto sampleProto) {
 		ProtoFile:      fileDescriptorSet.GetFile(),
 	}
 
+	if len(sampleProto.TargetedMessages) > 0 {
+		arg := fmt.Sprintf("messages=[%s]", strings.Join(sampleProto.TargetedMessages, messageDelimiter))
+		codeGeneratorRequest.Parameter = &arg
+	}
+
 	// Perform the conversion:
 	response, err := protoConverter.convert(&codeGeneratorRequest)
 	assert.NoError(t, err, "Unable to convert sample proto file (%v)", sampleProtoFileName)
@@ -73,7 +79,7 @@ func testConvertSampleProto(t *testing.T, sampleProto sampleProto) {
 		t.Fail()
 	} else {
 		for responseFileIndex, responseFile := range response.File {
-			assert.Equal(t, sampleProto.ExpectedJSONSchema[responseFileIndex], *responseFile.Content, "Incorrect JSON-Schema returned for sample proto file (%v)", sampleProtoFileName)
+			assert.Equal(t, strings.TrimSpace(sampleProto.ExpectedJSONSchema[responseFileIndex]), *responseFile.Content, "Incorrect JSON-Schema returned for sample proto file (%v)", sampleProtoFileName)
 		}
 	}
 
@@ -233,6 +239,12 @@ func configureSampleProtos() map[string]sampleProto {
 			FilesToGenerate:    []string{"Proto2NestedObject.proto"},
 			ProtoFileName:      "Proto2NestedObject.proto",
 		},
+		"TargetedMessages": {
+			TargetedMessages:   []string{"MessageKind10", "MessageKind11", "MessageKind12"},
+			ExpectedJSONSchema: []string{testdata.MessageKind10, testdata.MessageKind11, testdata.MessageKind12},
+			FilesToGenerate:    []string{"TwelveMessages.proto"},
+			ProtoFileName:      "TwelveMessages.proto",
+		},
 		"GoogleValue": {
 			ExpectedJSONSchema: []string{testdata.GoogleValue},
 			FilesToGenerate:    []string{"GoogleValue.proto"},

internal/converter/proto_package.go

@@ -16,7 +16,7 @@ type ProtoPackage struct {
 
 func (c *Converter) lookupType(pkg *ProtoPackage, name string) (*descriptor.DescriptorProto, string, bool) {
 	if strings.HasPrefix(name, ".") {
-		return c.relativelyLookupType(globalPkg, name[1:len(name)])
+		return c.relativelyLookupType(globalPkg, name[1:])
 	}
 
 	for ; pkg != nil; pkg = pkg.parent {

internal/converter/testdata/array_of_primitives.go

@@ -101,7 +101,6 @@ const ArrayOfPrimitives = `{
     ]
 }`
 
-
 const ArrayOfPrimitivesDouble = `{
     "$schema": "http://json-schema.org/draft-04/schema#",
     "properties": {
@@ -215,4 +214,3 @@ const ArrayOfPrimitivesDouble = `{
         }
     ]
 }`
-

internal/converter/testdata/message_kind_10.go

@@ -0,0 +1,25 @@
+package testdata
+
+const MessageKind10 = `{
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "properties": {
+        "name": {
+            "type": "string"
+        },
+        "timestamp": {
+            "type": "string"
+        },
+        "id": {
+            "type": "integer"
+        },
+        "rating": {
+            "type": "number"
+        },
+        "complete": {
+            "type": "boolean"
+        }
+    },
+    "additionalProperties": true,
+    "type": "object"
+}
+`