Fix ignore and add cmd

Author: technicallyjosh

.gitignore

@@ -21,9 +21,6 @@
 # Go workspace file
 go.work
 
-# executable
-protoc-gen-openapi
-
 .idea/
 
 test/openapi.yaml

cmd/protoc-gen-openapi/main.go

@@ -0,0 +1,34 @@
+package main
+
+import (
+	"flag"
+
+	"github.com/technicallyjosh/protoc-gen-openapi/internal/generator"
+	"google.golang.org/protobuf/compiler/protogen"
+)
+
+func main() {
+	var flags flag.FlagSet
+
+	conf := generator.Config{
+		ContentType:     flags.String("content_type", "application/json", "Default content-type for all paths."),
+		DefaultResponse: flags.String("default_response", "", "Default response message to use for API responses not defined."),
+		Description:     flags.String("description", "", "Description of the API."),
+		Filename:        flags.String("filename", "openapi", "Name of the file generated without the extension."),
+		Host:            flags.String("host", "", "Host to be used for all routes."),
+		Ignore:          flags.String("ignore", "", "Packages to ignore."),
+		Include:         flags.String("include", "", "Packages to include. Ignore overrides this."),
+		JSONOutput:      flags.Bool("json_out", false, "Generate a JSON file instead of YAML."),
+		Title:           flags.String("title", "", "Title of the API"),
+		UseJSONNames:    flags.Bool("json_names", false, "Use JSON names instead of the proto names of fields."),
+		Version:         flags.String("version", "0.0.1", "Version of the API."),
+	}
+
+	opts := protogen.Options{
+		ParamFunc: flags.Set,
+	}
+
+	opts.Run(func(plugin *protogen.Plugin) error {
+		return generator.New(plugin, conf).Run()
+	})
+}

cmd/protoc-gen-openapi/main_test.go

@@ -0,0 +1,152 @@
+package main_test
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"testing"
+
+	jd "github.com/josephburnett/jd/lib"
+	"github.com/stretchr/testify/suite"
+	"gopkg.in/yaml.v3"
+)
+
+type TestOptions struct {
+	defaultResponse string
+	description     string
+	testProto       string
+	title           string
+	version         string
+	include         string
+	ignore          string
+}
+
+type TestSuite struct {
+	suite.Suite
+	rawDoc  []byte
+	options TestOptions
+}
+
+func (s *TestSuite) YAMLEqual(expected any, actual any, msgAndArgs ...any) {
+	var expectedYAML, actualYAML string
+
+	switch v := expected.(type) {
+	case string:
+		expectedYAML = v
+	case []byte:
+		expectedYAML = string(v)
+	default:
+		expectedBytes, err := yaml.Marshal(v)
+		if err != nil {
+			s.FailNow(fmt.Sprintf("failed to marshal expected: %#v", v), msgAndArgs...)
+		}
+		expectedYAML = string(expectedBytes)
+	}
+
+	switch v := actual.(type) {
+	case string:
+		actualYAML = v
+	case []byte:
+		actualYAML = string(v)
+	default:
+		actualBytes, err := yaml.Marshal(v)
+		if err != nil {
+			s.FailNow(fmt.Sprintf("failed to marshal actual: %#v", v), msgAndArgs...)
+		}
+		actualYAML = string(actualBytes)
+	}
+
+	expectedNode, _ := jd.ReadYamlString(expectedYAML)
+	actualNode, _ := jd.ReadYamlString(actualYAML)
+
+	diff := expectedNode.Diff(actualNode, jd.SET).Render(jd.COLOR)
+
+	if diff != "" {
+		s.Fail(fmt.Sprintf("Not Equal:\nexpected:\n%s\nactual:\n%s\n\n%s", expectedYAML, actualYAML, diff), msgAndArgs...)
+	}
+}
+
+func (s *TestSuite) SetupSuite() {
+	s.options = TestOptions{
+		defaultResponse: "test.api.Error",
+		description:     "test description",
+		testProto:       "basic_test.proto",
+		title:           "test title",
+		version:         "1.1.0",
+	}
+}
+
+func (s *TestSuite) BeforeTest(suite, name string) {
+	var filename string
+
+	switch name {
+	case "TestBasic":
+		filename = "basic_test.proto"
+	case "TestFile":
+		filename = "file_test.proto"
+	case "TestService":
+		filename = "service_test.proto"
+	case "TestMethod":
+		filename = "method_test.proto"
+	case "TestField":
+		filename = "field_test.proto"
+	default:
+		s.FailNow("invalid test name")
+	}
+
+	err := exec.Command("rm", "-f", "../../test/openapi.yaml").Run()
+	if err != nil {
+		s.FailNow(err.Error())
+	}
+
+	out, err := exec.Command("protoc",
+		"-I=../../proto/technicallyjosh/oapi",
+		"-I=../../test",
+		"--openapi_out=../../test",
+		"--openapi_opt=version="+s.options.version,
+		"--openapi_opt=title="+s.options.title,
+		"--openapi_opt=description="+s.options.description,
+		"--openapi_opt=default_response="+s.options.defaultResponse,
+		"--openapi_opt=include="+s.options.include,
+		"--openapi_opt=ignore="+s.options.ignore,
+		"../../test/"+filename,
+	).CombinedOutput()
+	if err != nil {
+		s.FailNow(err.Error(), string(out))
+	}
+
+	s.rawDoc, err = os.ReadFile("../../test/openapi.yaml")
+	if err != nil {
+		s.FailNow(err.Error())
+	}
+}
+
+func (s *TestSuite) TestBasic() {
+	s.YAMLEqual(readFile("basic_test_openapi.yaml"), string(s.rawDoc))
+}
+
+func (s *TestSuite) TestFile() {
+	s.YAMLEqual(readFile("file_test_openapi.yaml"), string(s.rawDoc))
+}
+
+func (s *TestSuite) TestService() {
+	s.YAMLEqual(readFile("service_test_openapi.yaml"), string(s.rawDoc))
+}
+
+func (s *TestSuite) TestMethod() {
+	s.YAMLEqual(readFile("method_test_openapi.yaml"), string(s.rawDoc))
+}
+
+func (s *TestSuite) TestField() {
+	s.YAMLEqual(readFile("field_test_openapi.yaml"), string(s.rawDoc))
+}
+
+func TestSuites(t *testing.T) {
+	suite.Run(t, new(TestSuite))
+}
+
+func readFile(name string) string {
+	data, _ := os.ReadFile("../../test/" + name)
+
+	return string(data)
+}