grpc-rest 0.1.24 → 0.2.0

data/protoc-gen-rails/internal/output.go

@@ -1,165 +0,0 @@
-package internal
-
-import (
-	"bytes"
-	"fmt"
-	"strings"
-	"text/template"
-
-	"github.com/iancoleman/strcase"
-	"google.golang.org/protobuf/types/descriptorpb"
-)
-
-type FileResult struct {
-	Name    string
-	Content string
-}
-
-type controller struct {
-	ControllerName  string
-	Methods         []method
-	ServiceName     string
-	FullServiceName string
-	MethodName      string
-}
-
-type method struct {
-	Name        string
-	RequestType string
-	Path        string
-	PathInfo    []PathInfo
-	Body        string
-	HttpMethod  string
-	RestOptions string
-}
-
-func rubyRestOptions(restOptions map[string]bool) string {
-	var opts []string
-	for opt, val := range restOptions {
-		if val {
-			opts = append(opts, fmt.Sprintf("%v: true", opt))
-		}
-	}
-	return "{" + strings.Join(opts, ", ") + "}"
-}
-
-type Route struct {
-	MethodName string
-	Path       string
-	Controller string
-	HttpMethod string
-}
-
-var controllerTemplate = `
-####### THIS FILE IS AUTOMATICALLY GENERATED BY protoc-gen-rails. DO NOT MODIFY. #######
-
-require 'grpc_rest'
-class {{.ControllerName}}Controller < ActionController::Base
-  protect_from_forgery with: :null_session
-
-	rescue_from StandardError do |e|
-		render json: GrpcRest.error_msg(e), status: :internal_server_error
-	end
-  rescue_from GRPC::BadStatus do |e|
-		render json: GrpcRest.error_msg(e), status: GrpcRest.grpc_http_status(e.code)
-  end
-  rescue_from ActionDispatch::Http::Parameters::ParseError, Google::Protobuf::TypeError do |e|
-    render json: GrpcRest.error_msg(e), status: :bad_request
-  end
-  METHOD_PARAM_MAP = {
-{{range .Methods }}
-    "{{.Name}}" => [
-       {{range .PathInfo -}}
-			   {name: "{{.Name}}", val: {{if .HasValPattern}}"{{.ValPattern}}"{{else}}nil{{end}}, split_name:{{.SplitName}}},
-			 {{end -}}
-    ],
-{{end -}}
-  }.freeze
-{{$fullServiceName := .FullServiceName -}}
-{{range .Methods }}
-	def {{.Name}}
-    fields = {{.RequestType}}.descriptor.to_a.map(&:name)
-    parameters = request.parameters.to_h.deep_transform_keys(&:underscore)
-    grpc_request = GrpcRest.init_request({{.RequestType}}, parameters.slice(*fields))
-    GrpcRest.assign_params(grpc_request, METHOD_PARAM_MAP["{{.Name}}"], "{{.Body}}", request.parameters)
-    render json: GrpcRest.send_request("{{$fullServiceName}}", "{{.Name}}", grpc_request, {{.RestOptions}})
-  end
-{{end}}
-end
-`
-
-func ProcessService(service *descriptorpb.ServiceDescriptorProto, pkg string) (FileResult, []Route, error) {
-	var routes []Route
-	data := controller{
-		Methods:         []method{},
-		ServiceName:     Classify(service.GetName()),
-		ControllerName:  Demodulize(service.GetName()),
-		FullServiceName: Classify(pkg + "." + service.GetName()),
-	}
-	for _, m := range service.GetMethod() {
-		opts, err := ExtractAPIOptions(m)
-		if err != nil {
-			return FileResult{}, routes, err
-		}
-		restOpts, err := ExtractRestOptions(m)
-		if err != nil {
-			return FileResult{}, routes, err
-		}
-		httpMethod, path, err := MethodAndPath(opts.Pattern)
-		pathInfo, err := ParsedPath(path)
-		if err != nil {
-			return FileResult{}, routes, err
-		}
-		controllerMethod := method{
-			Name:        strcase.ToSnake(m.GetName()),
-			RequestType: Classify(m.GetInputType()),
-			Path:        path,
-			RestOptions: rubyRestOptions(restOpts),
-			HttpMethod:  httpMethod,
-			Body:        opts.Body,
-			PathInfo:    pathInfo,
-		}
-		data.Methods = append(data.Methods, controllerMethod)
-		routes = append(routes, Route{
-			HttpMethod: strings.ToLower(httpMethod),
-			Path:       SanitizePath(path),
-			Controller: strcase.ToSnake(data.ControllerName),
-			MethodName: strcase.ToSnake(m.GetName()),
-		})
-	}
-	resultTemplate, err := template.New("controller").Parse(controllerTemplate)
-	if err != nil {
-		return FileResult{}, routes, fmt.Errorf("can't parse controller template: %w", err)
-	}
-	var resultContent bytes.Buffer
-	err = resultTemplate.Execute(&resultContent, data)
-	if err != nil {
-		return FileResult{}, routes, fmt.Errorf("can't execute controller template: %w", err)
-	}
-	return FileResult{
-		Content: resultContent.String(),
-		Name:    fmt.Sprintf("app/controllers/%s_controller.rb", strcase.ToSnake(data.ControllerName)),
-	}, routes, nil
-}
-
-var routeTemplate = `# frozen_string_literal: true
-
-####### THIS FILE IS AUTOMATICALLY GENERATED BY protoc-gen-rails. DO NOT MODIFY. #######
-
-{{range . -}}
-{{.HttpMethod}} '{{.Path}}' => '{{.Controller}}#{{.MethodName}}'
-{{end -}}
-`
-
-func OutputRoutes(routes []Route) (string, error) {
-	resultTemplate, err := template.New("routes").Parse(routeTemplate)
-	if err != nil {
-		return "", err
-	}
-	var resultContent bytes.Buffer
-	err = resultTemplate.Execute(&resultContent, routes)
-	if err != nil {
-		return "", err
-	}
-	return resultContent.String(), nil
-}

data/protoc-gen-rails/internal/parse.go

@@ -1,101 +0,0 @@
-package internal
-
-import (
-	"encoding/json"
-	"fmt"
-  options "google.golang.org/genproto/googleapis/api/annotations"
-	options2 "github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-openapiv2/options"
-  "google.golang.org/protobuf/proto"
-  "google.golang.org/protobuf/types/descriptorpb"
-	"regexp"
-	"strings"
-)
-
-func MethodAndPath(pattern any) (string, string, error) {
-
-	switch typedPattern := pattern.(type) {
-	case *options.HttpRule_Get:
-		return "GET", typedPattern.Get, nil
-	case *options.HttpRule_Post:
-		return "POST", typedPattern.Post, nil
-	case *options.HttpRule_Put:
-		return "PUT", typedPattern.Put, nil
-	case *options.HttpRule_Delete:
-		return "DELETE", typedPattern.Delete, nil
-	case *options.HttpRule_Patch:
-		return "PATCH", typedPattern.Patch, nil
-	case *options.HttpRule_Custom:
-		return typedPattern.Custom.Kind, typedPattern.Custom.Path, nil
-	default:
-		return "", "", fmt.Errorf("unknown pattern type %T", pattern)
-	}
-}
-
-type PathInfo struct {
-	Name string
-	ValPattern string
-	SplitName string
-	HasValPattern bool
-}
-
-func ParsedPath(path string) ([]PathInfo, error) {
-	var infos []PathInfo
-	re := regexp.MustCompile("\\{(.*?)}")
-	matches := re.FindAllString(path, -1)
-	for _, match := range matches {
-		name := match[1:len(match)-1]
-		val := ""
-		equal := strings.Index(match, "=")
-		if equal != -1 {
-			val = name[equal:]
-			name = name[0:equal-1]
-		}
-		splitName := strings.Split(name, ".")
-		jsonSplit, err := json.Marshal(splitName)
-		if err != nil {
-			return nil, fmt.Errorf("error marshalling splitName: %w", err)
-		}
-		infos = append(infos, PathInfo{
-			Name: name,
-			ValPattern: val,
-			SplitName: string(jsonSplit),
-			HasValPattern: val != "",
-		})
-	}
-	return infos, nil
-}
-
-func ExtractAPIOptions(meth *descriptorpb.MethodDescriptorProto) (*options.HttpRule, error) {
-	if meth.Options == nil {
-		return nil, nil
-	}
-	if !proto.HasExtension(meth.Options, options.E_Http) {
-		return nil, nil
-	}
-	ext := proto.GetExtension(meth.Options, options.E_Http)
-	opts, ok := ext.(*options.HttpRule)
-	if !ok {
-		return nil, fmt.Errorf("extension is %T; want an HttpRule", ext)
-	}
-	return opts, nil
-}
-
-func ExtractRestOptions(meth *descriptorpb.MethodDescriptorProto) (map[string]bool, error) {
-	if meth.Options == nil {
-		return nil, nil
-	}
-	if !proto.HasExtension(meth.Options, options2.E_Openapiv2Operation) {
-		return nil, nil
-	}
-	ext := proto.GetExtension(meth.Options, options2.E_Openapiv2Operation)
-	operation, ok := ext.(*options2.Operation)
-	if !ok {
-		return nil, fmt.Errorf("extension is %T; want an Operation", ext)
-	}
-	operationExt := operation.GetExtensions()
-	emitDefaults := operationExt["x-grpc-rest-emit-defaults"].GetBoolValue()
-	return map[string]bool{
-		"emit_defaults": emitDefaults,
-	}, nil
-}
-

data/protoc-gen-rails/internal/utils.go

@@ -1,57 +0,0 @@
-package internal
-
-import (
-  "fmt"
-  "github.com/iancoleman/strcase"
-  "os"
-  "regexp"
-  "strings"
-)
-
-func LogMsg(msg string, args ...any) {
-	fmt.Fprintf(os.Stderr, fmt.Sprintf(msg, args...))
-	fmt.Fprintln(os.Stderr)
-}
-
-func FilePathify(s string) string {
-	var result []string
-	s = strings.Trim(s, ".")
-	tokens := strings.Split(s, ".")
-	for _, token := range tokens {
-		result = append(result, strcase.ToSnake(token))
-	}
-	return strings.Join(result, "/")
-}
-
-func Classify(s string) string {
-	var result []string
-	s = strings.Trim(s, ".")
-	tokens := strings.Split(s, ".")
-	for _, token := range tokens {
-		result = append(result, strcase.ToCamel(token))
-	}
-	return strings.Join(result, "::")
-}
-
-func Demodulize(s string) string {
-	tokens := strings.Split(s, ".")
-	return tokens[len(tokens)-1]
-}
-
-func SanitizePath(s string) string {
-  re := regexp.MustCompile("\\{(.*?)}")
-	matches := re.FindAllStringSubmatch(s, -1)
-	for _, match := range matches {
-		repl := match[1]
-		equal := strings.Index(match[1], "=")
-		if equal != -1 {
-			repl = repl[0:equal]
-		}
-		dot := strings.Index(repl, ".")
-		if dot != -1 {
-			repl = repl[dot+1:]
-		}
-		s = strings.Replace(s, match[0], "*"+repl, 1)
-	}
-  return s
-}

data/protoc-gen-rails/main.go

@@ -1,104 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"github.com/flipp-oss/protoc-gen-rails/internal"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/types/descriptorpb"
-	"google.golang.org/protobuf/types/pluginpb"
-	"io"
-	"log"
-	"os"
-	"slices"
-)
-
-var routes = []internal.Route{}
-
-func processService(service *descriptorpb.ServiceDescriptorProto, pkg string) (internal.FileResult, error) {
-	result, serviceRoutes, err := internal.ProcessService(service, pkg)
-	if err != nil {
-		return internal.FileResult{}, err
-	}
-	routes = slices.Concat(routes, serviceRoutes)
-	return result, nil
-}
-
-func routeFile() (internal.FileResult, error) {
-	content, err := internal.OutputRoutes(routes)
-	if err != nil {
-		return internal.FileResult{}, err
-	}
-	return internal.FileResult{
-		Name:    "config/routes/grpc.rb",
-		Content: content,
-	}, nil
-}
-
-func main() {
-	req, err := ReadRequest()
-	if err != nil {
-		log.Fatalf("%s", fmt.Errorf("error reading request: %w", err))
-	}
-	files := []internal.FileResult{}
-	for _, file := range req.GetProtoFile() {
-		for _, service := range file.GetService() {
-			fileResult, err := processService(service, file.GetPackage())
-			if err != nil {
-				log.Fatalf("%s", fmt.Errorf("error processing service %v: %w", service.GetName(), err))
-			}
-			files = append(files, fileResult)
-		}
-	}
-	if len(files) > 0 {
-		routeOutput, err := routeFile()
-		if err != nil {
-			log.Fatalf("%s", fmt.Errorf("error processing routes: %w", err))
-		}
-		files = append(files, routeOutput)
-	}
-
-	// process registry
-	writeResponse(files)
-}
-
-func ReadRequest() (*pluginpb.CodeGeneratorRequest, error) {
-	in, err := io.ReadAll(os.Stdin)
-	if err != nil {
-		return nil, err
-	}
-	req := &pluginpb.CodeGeneratorRequest{}
-	err = proto.Unmarshal(in, req)
-	if err != nil {
-		return nil, err
-	}
-	return req, nil
-}
-
-func generateResponse(files []internal.FileResult) *pluginpb.CodeGeneratorResponse {
-	feature := uint64(pluginpb.CodeGeneratorResponse_FEATURE_PROTO3_OPTIONAL)
-	respFiles := make([]*pluginpb.CodeGeneratorResponse_File, len(files))
-	for i, file := range files {
-		respFiles[i] = &pluginpb.CodeGeneratorResponse_File{
-			Name:    &file.Name,
-			Content: &file.Content,
-		}
-
-	}
-	return &pluginpb.CodeGeneratorResponse{
-		SupportedFeatures: &feature,
-		File: respFiles,
-	}
-}
-
-func writeResponse(files []internal.FileResult) {
-	response := generateResponse(files)
-	out, err := proto.Marshal(response)
-	if err != nil {
-		log.Fatalf("%s", fmt.Errorf("error marshalling response: %w", err))
-	}
-	_, err = os.Stdout.Write(out)
-	if err != nil {
-		log.Fatalf("%s", fmt.Errorf("error writing response: %w", err))
-	}
-}
-

data/protoc-gen-rails/main_test.go

@@ -1,158 +0,0 @@
-package main
-
-import (
-    "fmt"
-    "github.com/stretchr/testify/assert"
-    "os"
-  "os/exec"
-    "path/filepath"
-    "strings"
-  "testing"
-)
-
-// Overall approach taken from https://github.com/mix-php/mix/blob/master/src/grpc/protoc-gen-mix/plugin_test.go
-
-// When the environment variable RUN_AS_PROTOC_GEN_RAILS is set, we skip running
-// tests and instead act as protoc-gen-rails. This allows the test binary to
-// pass itself to protoc.
-func init() {
-    if os.Getenv("RUN_AS_PROTOC_GEN_RAILS") != "" {
-        main()
-        os.Exit(0)
-    }
-}
-
-func fileNames(directory string, appendDirectory bool, extension string) ([]string, error) {
-    var files []os.FileInfo
-    var fullPaths []string
-    err := filepath.Walk(directory, func(path string, info os.FileInfo, err error) error {
-        if extension != "" && filepath.Ext(path) != extension {
-            return nil
-        }
-        if info.IsDir() {
-            return nil
-        }
-        files = append(files, info)
-        if info.Name() != ".keep" {
-            fullPaths = append(fullPaths, path)
-        }
-        if err != nil {
-            fmt.Println("ERROR:", err)
-        }
-        return nil
-    })
-    if err != nil {
-        return nil, fmt.Errorf("can't read %s directory: %w", directory, err)
-    }
-    if appendDirectory {
-        return fullPaths, nil
-    }
-    var names []string
-    for _, file := range fullPaths {
-      names = append(names, strings.Replace(file, directory, "", 1)[1:])
-    }
-    return names, nil
-}
-
-func runTest(t *testing.T, directory string, options map[string]string) {
-    workdir, _ := os.Getwd()
-    tmpdir, err := os.MkdirTemp(workdir, "proto-test.")
-    if err != nil {
-        t.Fatal(err)
-    }
-    defer os.RemoveAll(tmpdir)
-
-    args := []string{
-        "-I.",
-        "--rails_out=" + tmpdir,
-    }
-    names, err := fileNames(workdir + "/testdata", false, ".proto")
-    if err != nil {
-        t.Fatal(fmt.Errorf("testData fileNames %w", err))
-    }
-    for _, name := range names {
-        args = append(args, fmt.Sprintf("testdata/%v", name))
-    }
-    for k, v := range options {
-        args = append(args, "--rails_opt=" + k + "=" + v)
-    }
-    protoc(t, args)
-
-    testDir := workdir + "/testdata/" + directory
-    if os.Getenv("UPDATE_SNAPSHOTS") != "" {
-        cmd := exec.Command("/bin/sh", "-c", fmt.Sprintf("cp -R %v/* %v", tmpdir, testDir))
-        cmd.Run()
-    } else {
-        assertEqualFiles(t, testDir, tmpdir)
-    }
-}
-
-func Test_Base(t *testing.T) {
-    runTest(t, "base", map[string]string{})
-}
-
-func Test_NoServices(t *testing.T) {
-    workdir, _ := os.Getwd()
-    tmpdir, err := os.MkdirTemp(workdir, "proto-test.")
-    if err != nil {
-        t.Fatal(err)
-    }
-    defer os.RemoveAll(tmpdir)
-
-    args := []string{
-        "-I.",
-        "--rails_out=" + tmpdir,
-    }
-    args = append(args, fmt.Sprintf("testdata/test.proto"))
-    protoc(t, args)
-
-    testDir := workdir + "/testdata/no_service"
-    assertEqualFiles(t, testDir, tmpdir)
-}
-
-func assertEqualFiles(t *testing.T, original, generated string) {
-    names, err := fileNames(original, false, "")
-    if err != nil {
-        t.Fatal(fmt.Errorf("original fileNames %w", err))
-    }
-    generatedNames, err := fileNames(generated, false, "")
-    if err != nil {
-        t.Fatal(fmt.Errorf("generated fileNames %w", err))
-    }
-    assert.Equal(t, names, generatedNames)
-    // put back subdirectories
-    names, _ = fileNames(original, true, "")
-    generatedNames, _ = fileNames(generated, true, "")
-    for i, name := range names {
-        originalData, err := os.ReadFile(name)
-        if err != nil {
-            t.Fatal("Can't find original file for comparison")
-        }
-
-        generatedData, err := os.ReadFile(generatedNames[i])
-        if err != nil {
-            t.Fatal("Can't find generated file for comparison")
-        }
-        r := strings.NewReplacer("\r\n", "", "\n", "")
-        assert.Equal(t, r.Replace(string(originalData)), r.Replace(string(generatedData)))
-    }
-}
-
-func protoc(t *testing.T, args []string) {
-    cmd := exec.Command("protoc", "--proto_path=.", "--proto_path=./google-deps", "--plugin=protoc-gen-rails=" + os.Args[0])
-    cmd.Args = append(cmd.Args, args...)
-    cmd.Env = append(os.Environ(), "RUN_AS_PROTOC_GEN_RAILS=1")
-    out, err := cmd.CombinedOutput()
-
-    if len(out) > 0 || err != nil {
-        t.Log("RUNNING: ", strings.Join(cmd.Args, " "))
-    }
-
-    if len(out) > 0 {
-        t.Log(string(out))
-    }
-
-    if err != nil {
-        t.Fatalf("protoc: %v", err)
-    }
-}