grpc-rest 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94663645d0e0541b08ccb55ad65c05c1d41391d580793f4f70f5c16925e23f34
-  data.tar.gz: f7f3f7182934adcc2670b3a3d12a29bce8da5896284b4ee78aaa623fa4f2b163
+  metadata.gz: c3dc93105554c8c92a3229f693ab0c93ed5833796ef7b7f11e94cb8821f2c425
+  data.tar.gz: ac3ec407c674d16fb33e6bddccfa10b9e66859af3d5ecbad58d1ff2603e7c098
 SHA512:
-  metadata.gz: ba0669e7cc0343bdc944e5ccddd0adef5f98de23173eb507c964db9cf5394987feac7f11653ce380d4e0f82fa748380646ae7d6df757f86a9fd4de322538ec72
-  data.tar.gz: c4d29996a51dc172765a6c7489a730389d6c85d3bd3a05949cabdddbefa339b8f5166a5c2cdcb3ca263df1fc12221fe8d23873aa812cb50d26f594adec67dc89
+  metadata.gz: b1c05d823f083722774025bf8772d535b211b4ef01f3022baa92003a179ab2f3c1fcd6646c6b7eb5acf9ced1ff5abd3e962eea541ddfa7c0d9766bcc2649cb44
+  data.tar.gz: c4c40a55b73429c7716ed2e6164c546f8d1c2e53030d6b1182475b66ec430590c637c691bac7af21294a62b39782a4ecc2d332c4afa68879cef4b803a170beb1

data/.github/workflows/CI.yml

@@ -0,0 +1,50 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches:
+    - main
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: [ubuntu-latest]
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+    - name: Setup Go
+      uses: actions/setup-go@v2
+      with:
+        go-version: '1.21'
+    - name: Install Protoc
+      uses: arduino/setup-protoc@v2
+    - run: git reset --hard
+    - run: git clean -f -d
+    - run: cd protoc-gen-rails && go test ./...
+
+  build_and_deploy:
+    needs: test
+    runs-on: [ubuntu-latest]
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+    - name: Setup Go
+      uses: actions/setup-go@v2
+      with:
+        go-version: '1.21'
+    - run: git reset --hard
+    - run: git clean -f -d
+    - name: Run GoReleaser
+      uses: goreleaser/goreleaser-action@v3
+      with:
+        distribution: goreleaser
+        version: latest
+        workdir: ./protoc-gen-rails
+        args: release --clean
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

data/CHANGELOG

@@ -0,0 +1,12 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## UNRELEASED
+
+# 0.1.0 - 2024-03-01
+
+* Initial release.

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,77 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+  advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies within all project spaces, and it also applies when
+an individual is representing the project or its community in public spaces.
+Examples of representing a project or community include using an official
+project e-mail address, posting via an official social media account, or acting
+as an appointed representative at an online or offline event. Representation of
+a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at [INSERT EMAIL ADDRESS]. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq
+

data/README.md

@@ -23,7 +23,7 @@ The protobuf generator uses the same annotations as [grpc-gateway](https://githu
 
 ## Installation
 
-First, download `protoc-gen-rails` from the releases page on the right. Ensure it's somewhere in your PATH.
+First, download `protoc-gen-rails` from the releases page on the right and unzip it. Ensure the binary is somewhere in your PATH.
 
 Then, add the following to your `Gemfile`:
 
@@ -97,8 +97,15 @@ and the generated controller will look like this:
 require 'services/example/example_services_pb'
 class ExampleServiceController < ActionController::Base
   protect_from_forgery with: :null_session
+  
+  METHOD_PARAM_MAP = {
 
-	rescue_from Google::Protobuf::TypeError do |e|
+    "example" => [
+       {name: "name", val: nil, split_name:["name"]},
+			 ],
+  }.freeze
+
+	rescue_from StandardError do |e|
 		render json: GrpcRest.error_msg(e)
 	end
 
@@ -119,6 +126,36 @@ Rails.application.routes.draw do
 end
 ```
 
+### Hooking up Callbacks
+
+If you're using [gruf](https://github.com/bigcommerce/gruf), as long as your Gruf controllers are loaded on application load, you don't have to do anything else - grpc-rest will automatically hook the callbacks up. If you're not, you have to tell GrpcRest about your server. An example might look like this:
+
+```ruby
+# grpc_setup.rb, a shared library file somewhere in the app
+
+def grpc_server
+  s = GRPC::RpcServer.new
+  s.handle(MyImpl.new) # handler inheriting from your service class - see https://grpc.io/docs/languages/ruby/basics/
+  s
+end
+
+# startup script for gRPC
+
+require "grpc_setup"
+server = grpc_server
+server.run_till_terminated_or_interrupted([1, 'int', 'SIGQUIT'])
+
+# Rails initializer
+require "grpc_setup"
+server = grpc_server
+GrpcRest.register_server(server)
+```
+
+## To Do
+
+* Support repeated fields via comma-separation (matches grpc-gateway, but is it really useful?)
+* Install via homebrew and/or have the binary in the gem itself
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/flipp-oss/grpc-rest.

data/lib/grpc_rest/version.rb

@@ -1,3 +1,3 @@
 module GrpcRest
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

data/lib/grpc_rest.rb

@@ -1,6 +1,14 @@
 module GrpcRest
   class << self
 
+    def register_server(server)
+      @server = server
+    end
+
+    def underscore(s)
+      GRPC::GenericService.underscore(s)
+    end
+
     # Gets a sub record from a proto. If it doesn't exist, initialize it and set it to the proto,
     # then return it.
     def sub_field(proto, name)
@@ -8,6 +16,8 @@ module GrpcRest
       return existing if existing
 
       descriptor = proto.class.descriptor.to_a.find { |a| a.name == name }
+      return nil if descriptor.nil?
+
       klass = descriptor.submsg_name.split('.').map(&:camelize).join('::').constantize
       sub_record = klass.new
       proto.public_send(:"#{name}=", sub_record)
@@ -18,11 +28,12 @@ module GrpcRest
       tokens = path.split('.')
       tokens[0...-1].each do |path_seg|
         proto = sub_field(proto, path_seg)
+        return if proto.nil?
       end
-      proto.public_send(:"#{tokens.last}=", value)
+      proto.public_send(:"#{tokens.last}=", value) if proto.respond_to?(:"#{tokens.last}=")
     end
 
-    def assign_params(request, param_string, body_string, params)
+    def assign_params(request, param_hash, body_string, params)
       parameters = params.to_h.deep_dup
       # each instance of {variable} means that we set the corresponding param variable into the
       # Protobuf request
@@ -30,11 +41,13 @@ module GrpcRest
       # to set it - e.g. {subrecord.foo} means we need to set the value of `request.subrecord.foo` to `params[:foo].`
       # We can also do simple wildcard replacement if there's a * - for example, {name=something-*}
       # means we should set `request.name` to "something-#{params[:name]}".
-      param_string.scan(/\{(.*?)}/).each do |match|
-        name, val = match[0].split('=')
-        val = '*' if val.blank?
-        name_tokens = name.split('.')
-        assign_value(request, name, val.gsub('*', parameters.delete(name_tokens.last)))
+      param_hash.each do |entry|
+        name_tokens = entry[:split_name]
+        value_to_use = parameters.delete(name_tokens.last)
+        if entry[:val]
+          value_to_use = value_to_use.gsub('*', entry[:val])
+        end
+        assign_value(request, entry[:name], value_to_use)
       end
       if body_string.present? && body_string != '*'
         # we need to "splat" the body parameters into the given sub-record rather than into the top-level.
@@ -45,7 +58,7 @@ module GrpcRest
       end
 
       # assign remaining parameters
-      parameters.except('action', 'controller').each do |k, v|
+      parameters.each do |k, v|
         assign_value(request, k, v)
       end
     end
@@ -62,25 +75,37 @@ module GrpcRest
       }
     end
 
+    def send_gruf_request(klass, service_obj, method, request)
+      ref = service_obj.rpc_descs[method.classify.to_sym]
+      handler = klass.new(
+        method_key: method.to_sym,
+        service: service_obj,
+        rpc_desc: ref,
+        active_call: nil,
+        message: request
+      )
+      handler.send(method.to_sym)
+    end
+
+    def send_grpc_request(service, method, request)
+      server_parts = service.split('::')
+      service_name = (server_parts[..-2].map { |p| underscore(p)} + [server_parts[-1]]).join('.')
+      route = "/#{service_name}/#{method.classify}"
+      handler = @server.send(:rpc_handlers)[route.to_sym]
+      handler.call(request)
+    end
+
     def send_request(service, method, request)
-      service_obj = service.constantize::Service
-      response = if defined?(Gruf)
+      if defined?(Gruf)
+        service_obj = service.constantize::Service
         klass = ::Gruf::Controllers::Base.subclasses.find do |k|
           k.bound_service == service_obj
         end
-        ref = service_obj.rpc_descs[method.classify.to_sym]
-        handler = klass.new(
-          method_key: method.to_sym,
-          service: service_obj,
-          rpc_desc: ref,
-          active_call: nil,
-          message: request
-        )
-        handler.send(method.to_sym)
-                 else
-                   raise 'Non-gruf grpc not implemented yet!'
+        if klass
+          return send_gruf_request(klass, service_obj, method, request).to_h
+        end
       end
-      response.to_h
+      send_grpc_request(service, method, request).to_h
     end
   end
 

data/protoc-gen-rails/.goreleaser.yml

@@ -0,0 +1,27 @@
+project_name: protoc-gen-rails
+before:
+  hooks:
+    - go mod tidy
+builds:
+  - env:
+      - CGO_ENABLED=0
+    dir: .
+    goos:
+      - linux
+      - darwin
+    binary: protoc-gen-rails
+changelog:
+  sort: asc
+  filters:
+    exclude:
+      - '^docs:'
+      - '^test:'
+
+release:
+  github:
+    owner: flipp-oss
+    name: grpc-rest
+
+archives:
+  - id: protoc-gen-rails
+    name_template: "{{ .ProjectName }}_{{ .Os }}_{{ .Arch }}"

data/protoc-gen-rails/go.mod

@@ -5,7 +5,7 @@ go 1.22.0
 require (
 	github.com/iancoleman/strcase v0.3.0
 	github.com/stretchr/testify v1.8.4
-	google.golang.org/genproto/googleapis/api v0.0.0-20240125205218-1f4bbc51befe
+	google.golang.org/genproto/googleapis/api v0.0.0-20240228224816-df926f6c8641
 	google.golang.org/protobuf v1.32.0
 )
 

data/protoc-gen-rails/go.sum

@@ -24,6 +24,8 @@ google.golang.org/genproto v0.0.0-20240116215550-a9fa1716bcac h1:ZL/Teoy/ZGnzyrq
 google.golang.org/genproto v0.0.0-20240116215550-a9fa1716bcac/go.mod h1:+Rvu7ElI+aLzyDQhpHMFMMltsD6m7nqpuWDd2CwJw3k=
 google.golang.org/genproto/googleapis/api v0.0.0-20240125205218-1f4bbc51befe h1:0poefMBYvYbs7g5UkjS6HcxBPaTRAmznle9jnxYoAI8=
 google.golang.org/genproto/googleapis/api v0.0.0-20240125205218-1f4bbc51befe/go.mod h1:4jWUdICTdgc3Ibxmr8nAJiiLHwQBY0UI0XZcEMaFKaA=
+google.golang.org/genproto/googleapis/api v0.0.0-20240228224816-df926f6c8641 h1:SO1wX9btGFrwj9EzH3ocqfwiPVOxfv4ggAJajzlHA5s=
+google.golang.org/genproto/googleapis/api v0.0.0-20240228224816-df926f6c8641/go.mod h1:wLupoVsUfYPgOMwjzhYFbaVklw/INms+dqTp0tc1fv8=
 google.golang.org/protobuf v1.32.0 h1:pPC6BG5ex8PDFnkbrGU3EixyhKcQ2aDuBS36lqK/C7I=
 google.golang.org/protobuf v1.32.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

data/protoc-gen-rails/google-deps/google/api/annotations.proto

@@ -0,0 +1,31 @@
+// Copyright 2015 Google LLC
+//
+// 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.
+
+syntax = "proto3";
+
+package google.api;
+
+import "google/api/http.proto";
+import "google/protobuf/descriptor.proto";
+
+option go_package = "google.golang.org/genproto/googleapis/api/annotations;annotations";
+option java_multiple_files = true;
+option java_outer_classname = "AnnotationsProto";
+option java_package = "com.google.api";
+option objc_class_prefix = "GAPI";
+
+extend google.protobuf.MethodOptions {
+  // See `HttpRule`.
+  HttpRule http = 72295728;
+}

data/protoc-gen-rails/google-deps/google/api/http.proto

@@ -0,0 +1,275 @@
+// Copyright 2016 Google Inc.
+//
+// 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.
+syntax = "proto3";
+package google.api;
+option cc_enable_arenas = true;
+option go_package = "google.golang.org/genproto/googleapis/api/annotations;annotations";
+option java_multiple_files = true;
+option java_outer_classname = "HttpProto";
+option java_package = "com.google.api";
+option objc_class_prefix = "GAPI";
+// Defines the HTTP configuration for a service. It contains a list of
+// [HttpRule][google.api.HttpRule], each specifying the mapping of an RPC method
+// to one or more HTTP REST API methods.
+message Http {
+  // A list of HTTP configuration rules that apply to individual API methods.
+  //
+  // **NOTE:** All service configuration rules follow "last one wins" order.
+  repeated HttpRule rules = 1;
+}
+// `HttpRule` defines the mapping of an RPC method to one or more HTTP
+// REST APIs.  The mapping determines what portions of the request
+// message are populated from the path, query parameters, or body of
+// the HTTP request.  The mapping is typically specified as an
+// `google.api.http` annotation, see "google/api/annotations.proto"
+// for details.
+//
+// The mapping consists of a field specifying the path template and
+// method kind.  The path template can refer to fields in the request
+// message, as in the example below which describes a REST GET
+// operation on a resource collection of messages:
+//
+//
+//     service Messaging {
+//       rpc GetMessage(GetMessageRequest) returns (Message) {
+//         option (google.api.http).get = "/v1/messages/{message_id}/{sub.subfield}";
+//       }
+//     }
+//     message GetMessageRequest {
+//       message SubMessage {
+//         string subfield = 1;
+//       }
+//       string message_id = 1; // mapped to the URL
+//       SubMessage sub = 2;    // `sub.subfield` is url-mapped
+//     }
+//     message Message {
+//       string text = 1; // content of the resource
+//     }
+//
+// The same http annotation can alternatively be expressed inside the
+// `GRPC API Configuration` YAML file.
+//
+//     http:
+//       rules:
+//         - selector: <proto_package_name>.Messaging.GetMessage
+//           get: /v1/messages/{message_id}/{sub.subfield}
+//
+// This definition enables an automatic, bidrectional mapping of HTTP
+// JSON to RPC. Example:
+//
+// HTTP | RPC
+// -----|-----
+// `GET /v1/messages/123456/foo`  | `GetMessage(message_id: "123456" sub: SubMessage(subfield: "foo"))`
+//
+// In general, not only fields but also field paths can be referenced
+// from a path pattern. Fields mapped to the path pattern cannot be
+// repeated and must have a primitive (non-message) type.
+//
+// Any fields in the request message which are not bound by the path
+// pattern automatically become (optional) HTTP query
+// parameters. Assume the following definition of the request message:
+//
+//
+//     message GetMessageRequest {
+//       message SubMessage {
+//         string subfield = 1;
+//       }
+//       string message_id = 1; // mapped to the URL
+//       int64 revision = 2;    // becomes a parameter
+//       SubMessage sub = 3;    // `sub.subfield` becomes a parameter
+//     }
+//
+//
+// This enables a HTTP JSON to RPC mapping as below:
+//
+// HTTP | RPC
+// -----|-----
+// `GET /v1/messages/123456?revision=2&sub.subfield=foo` | `GetMessage(message_id: "123456" revision: 2 sub: SubMessage(subfield: "foo"))`
+//
+// Note that fields which are mapped to HTTP parameters must have a
+// primitive type or a repeated primitive type. Message types are not
+// allowed. In the case of a repeated type, the parameter can be
+// repeated in the URL, as in `...?param=A&param=B`.
+//
+// For HTTP method kinds which allow a request body, the `body` field
+// specifies the mapping. Consider a REST update method on the
+// message resource collection:
+//
+//
+//     service Messaging {
+//       rpc UpdateMessage(UpdateMessageRequest) returns (Message) {
+//         option (google.api.http) = {
+//           put: "/v1/messages/{message_id}"
+//           body: "message"
+//         };
+//       }
+//     }
+//     message UpdateMessageRequest {
+//       string message_id = 1; // mapped to the URL
+//       Message message = 2;   // mapped to the body
+//     }
+//
+//
+// The following HTTP JSON to RPC mapping is enabled, where the
+// representation of the JSON in the request body is determined by
+// protos JSON encoding:
+//
+// HTTP | RPC
+// -----|-----
+// `PUT /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: "123456" message { text: "Hi!" })`
+//
+// The special name `*` can be used in the body mapping to define that
+// every field not bound by the path template should be mapped to the
+// request body.  This enables the following alternative definition of
+// the update method:
+//
+//     service Messaging {
+//       rpc UpdateMessage(Message) returns (Message) {
+//         option (google.api.http) = {
+//           put: "/v1/messages/{message_id}"
+//           body: "*"
+//         };
+//       }
+//     }
+//     message Message {
+//       string message_id = 1;
+//       string text = 2;
+//     }
+//
+//
+// The following HTTP JSON to RPC mapping is enabled:
+//
+// HTTP | RPC
+// -----|-----
+// `PUT /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: "123456" text: "Hi!")`
+//
+// Note that when using `*` in the body mapping, it is not possible to
+// have HTTP parameters, as all fields not bound by the path end in
+// the body. This makes this option more rarely used in practice of
+// defining REST APIs. The common usage of `*` is in custom methods
+// which don't use the URL at all for transferring data.
+//
+// It is possible to define multiple HTTP methods for one RPC by using
+// the `additional_bindings` option. Example:
+//
+//     service Messaging {
+//       rpc GetMessage(GetMessageRequest) returns (Message) {
+//         option (google.api.http) = {
+//           get: "/v1/messages/{message_id}"
+//           additional_bindings {
+//             get: "/v1/users/{user_id}/messages/{message_id}"
+//           }
+//         };
+//       }
+//     }
+//     message GetMessageRequest {
+//       string message_id = 1;
+//       string user_id = 2;
+//     }
+//
+//
+// This enables the following two alternative HTTP JSON to RPC
+// mappings:
+//
+// HTTP | RPC
+// -----|-----
+// `GET /v1/messages/123456` | `GetMessage(message_id: "123456")`
+// `GET /v1/users/me/messages/123456` | `GetMessage(user_id: "me" message_id: "123456")`
+//
+// # Rules for HTTP mapping
+//
+// The rules for mapping HTTP path, query parameters, and body fields
+// to the request message are as follows:
+//
+// 1. The `body` field specifies either `*` or a field path, or is
+//    omitted. If omitted, it assumes there is no HTTP body.
+// 2. Leaf fields (recursive expansion of nested messages in the
+//    request) can be classified into three types:
+//     (a) Matched in the URL template.
+//     (b) Covered by body (if body is `*`, everything except (a) fields;
+//         else everything under the body field)
+//     (c) All other fields.
+// 3. URL query parameters found in the HTTP request are mapped to (c) fields.
+// 4. Any body sent with an HTTP request can contain only (b) fields.
+//
+// The syntax of the path template is as follows:
+//
+//     Template = "/" Segments [ Verb ] ;
+//     Segments = Segment { "/" Segment } ;
+//     Segment  = "*" | "**" | LITERAL | Variable ;
+//     Variable = "{" FieldPath [ "=" Segments ] "}" ;
+//     FieldPath = IDENT { "." IDENT } ;
+//     Verb     = ":" LITERAL ;
+//
+// The syntax `*` matches a single path segment. It follows the semantics of
+// [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.2 Simple String
+// Expansion.
+//
+// The syntax `**` matches zero or more path segments. It follows the semantics
+// of [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.3 Reserved
+// Expansion. NOTE: it must be the last segment in the path except the Verb.
+//
+// The syntax `LITERAL` matches literal text in the URL path.
+//
+// The syntax `Variable` matches the entire path as specified by its template;
+// this nested template must not contain further variables. If a variable
+// matches a single path segment, its template may be omitted, e.g. `{var}`
+// is equivalent to `{var=*}`.
+//
+// NOTE: the field paths in variables and in the `body` must not refer to
+// repeated fields or map fields.
+//
+// Use CustomHttpPattern to specify any HTTP method that is not included in the
+// `pattern` field, such as HEAD, or "*" to leave the HTTP method unspecified for
+// a given URL path rule. The wild-card rule is useful for services that provide
+// content to Web (HTML) clients.
+message HttpRule {
+  // Selects methods to which this rule applies.
+  //
+  // Refer to [selector][google.api.DocumentationRule.selector] for syntax details.
+  string selector = 1;
+  // Determines the URL pattern is matched by this rules. This pattern can be
+  // used with any of the {get|put|post|delete|patch} methods. A custom method
+  // can be defined using the 'custom' field.
+  oneof pattern {
+    // Used for listing and getting information about resources.
+    string get = 2;
+    // Used for updating a resource.
+    string put = 3;
+    // Used for creating a resource.
+    string post = 4;
+    // Used for deleting a resource.
+    string delete = 5;
+    // Used for updating a resource.
+    string patch = 6;
+    // Custom pattern is used for defining custom verbs.
+    CustomHttpPattern custom = 8;
+  }
+  // The name of the request field whose value is mapped to the HTTP body, or
+  // `*` for mapping all fields not captured by the path pattern to the HTTP
+  // body. NOTE: the referred field must not be a repeated field and must be
+  // present at the top-level of request message type.
+  string body = 7;
+  // Additional HTTP bindings for the selector. Nested bindings must
+  // not contain an `additional_bindings` field themselves (that is,
+  // the nesting may only be one level deep).
+  repeated HttpRule additional_bindings = 11;
+}
+// A custom pattern is used for defining custom HTTP verb.
+message CustomHttpPattern {
+  // The name of this custom HTTP verb.
+  string kind = 1;
+  // The path matched by this custom verb.
+  string path = 2;
+}

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

@@ -27,6 +27,7 @@ type method struct {
 	Name string
 	RequestType string
 	Path string
+	PathInfo []PathInfo
 	Body string
 	HttpMethod string
 }
@@ -39,18 +40,28 @@ type Route struct {
 }
 
 var controllerTemplate = `
+require 'grpc_rest'
 require 'services/geo_admin/v1/test_services_pb'
 class {{.ControllerName}}Controller < ActionController::Base
   protect_from_forgery with: :null_session
 
-	rescue_from Google::Protobuf::TypeError do |e|
+	rescue_from StandardError do |e|
 		render json: GrpcRest.error_msg(e)
 	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}}
 	  grpc_request = {{.RequestType}}.new
-	  GrpcRest.assign_params(grpc_request, "{{.Path}}", "{{.Body}}", request.parameters)
+	  GrpcRest.assign_params(grpc_request, METHOD_PARAM_MAP["{{.Name}}"], "{{.Body}}", request.parameters)
     render json: GrpcRest.send_request("{{$fullServiceName}}", "{{.Name}}", grpc_request)
   end
 {{end}}
@@ -72,12 +83,17 @@ func ProcessService(service *descriptorpb.ServiceDescriptorProto, pkg string) (F
 			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,
 			HttpMethod: httpMethod,
 			Body: opts.Body,
+			PathInfo: pathInfo,
 		}
 		data.Methods = append(data.Methods, controllerMethod)
 		routes = append(routes, Route{
@@ -89,12 +105,12 @@ func ProcessService(service *descriptorpb.ServiceDescriptorProto, pkg string) (F
 	}
 	resultTemplate, err := template.New("controller").Parse(controllerTemplate)
 	if err != nil {
-		return FileResult{}, routes, err
+		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, err
+		return FileResult{}, routes, fmt.Errorf("can't execute controller template: %w", err)
 	}
 	return FileResult{
 		Content: resultContent.String(),

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

@@ -1,10 +1,13 @@
 package internal
 
 import (
-  "fmt"
+	"encoding/json"
+	"fmt"
   options "google.golang.org/genproto/googleapis/api/annotations"
   "google.golang.org/protobuf/proto"
   "google.golang.org/protobuf/types/descriptorpb"
+	"regexp"
+	"strings"
 )
 
 func MethodAndPath(pattern any) (string, string, error) {
@@ -27,6 +30,40 @@ func MethodAndPath(pattern any) (string, string, error) {
 	}
 }
 
+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

data/protoc-gen-rails/main_test.go

@@ -12,31 +12,42 @@ import (
 
 // 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_AVRO is set, we skip running
-// tests and instead act as protoc-gen-avro. This allows the test binary to
+// 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_AVRO") != "" {
+    if os.Getenv("RUN_AS_PROTOC_GEN_RAILS") != "" {
         main()
         os.Exit(0)
     }
 }
 
-func fileNames(directory string, appendDirectory bool) ([]string, error) {
-    files, err := os.ReadDir(directory)
+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)
+        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 files {
-        if file.IsDir() {
-            continue
-        }
-        if appendDirectory {
-          names = append(names, filepath.Base(directory) + "/" + file.Name())
-        } else {
-            names = append(names, file.Name())
-        }
+    for _, file := range fullPaths {
+      names = append(names, strings.Replace(file, directory, "", 1)[1:])
     }
     return names, nil
 }
@@ -51,23 +62,23 @@ func runTest(t *testing.T, directory string, options map[string]string) {
 
     args := []string{
         "-I.",
-        "--avro_out=" + tmpdir,
+        "--rails_out=" + tmpdir,
     }
-    names, err := fileNames(workdir + "/testdata", true)
+    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, name)
+        args = append(args, fmt.Sprintf("testdata/%v", name))
     }
     for k, v := range options {
-        args = append(args, "--avro_opt=" + k + "=" + v)
+        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 %v/* %v", tmpdir, testDir))
+        cmd := exec.Command("/bin/sh", "-c", fmt.Sprintf("cp -R %v/* %v", tmpdir, testDir))
         cmd.Run()
     } else {
         assertEqualFiles(t, testDir, tmpdir)
@@ -78,39 +89,26 @@ func Test_Base(t *testing.T) {
     runTest(t, "base", map[string]string{})
 }
 
-func Test_CollapseFields(t *testing.T) {
-    runTest(t, "collapse_fields", map[string]string{"collapse_fields": "StringList"})
-}
-
-func Test_EmitOnly(t *testing.T) {
-    runTest(t, "emit_only", map[string]string{"emit_only": "Widget"})
-}
-
-func Test_NamespaceMap(t *testing.T) {
-    runTest(t, "namespace_map", map[string]string{"namespace_map": "testdata:mynamespace"})
-}
-
-func Test_PreserveNonStringMaps(t *testing.T) {
-    runTest(t, "preserve_non_string_maps", map[string]string{"preserve_non_string_maps": "true"})
-}
-
 func assertEqualFiles(t *testing.T, original, generated string) {
-    names, err := fileNames(original, false)
+    names, err := fileNames(original, false, "")
     if err != nil {
         t.Fatal(fmt.Errorf("original fileNames %w", err))
     }
-    generatedNames, err := fileNames(generated, false)
+    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(original + "/" + name)
+        originalData, err := os.ReadFile(name)
         if err != nil {
             t.Fatal("Can't find original file for comparison")
         }
 
-        generatedData, err := os.ReadFile(generated + "/" + generatedNames[i])
+        generatedData, err := os.ReadFile(generatedNames[i])
         if err != nil {
             t.Fatal("Can't find generated file for comparison")
         }
@@ -120,9 +118,9 @@ func assertEqualFiles(t *testing.T, original, generated string) {
 }
 
 func protoc(t *testing.T, args []string) {
-    cmd := exec.Command("protoc", "--plugin=protoc-gen-avro=" + os.Args[0])
+    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_AVRO=1")
+    cmd.Env = append(os.Environ(), "RUN_AS_PROTOC_GEN_RAILS=1")
     out, err := cmd.CombinedOutput()
 
     if len(out) > 0 || err != nil {

data/protoc-gen-rails/testdata/base/app/controllers/my_service_controller.rb

@@ -0,0 +1,43 @@
+
+require 'grpc_rest'
+require 'services/geo_admin/v1/test_services_pb'
+class MyServiceController < ActionController::Base
+  protect_from_forgery with: :null_session
+
+	rescue_from StandardError do |e|
+		render json: GrpcRest.error_msg(e)
+	end
+  METHOD_PARAM_MAP = {
+
+    "test" => [
+       {name: "blah", val: "foobar/*", split_name:["blah"]},
+			 {name: "repeated_string", val: nil, split_name:["repeated_string"]},
+			 ],
+
+    "test_2" => [
+       ],
+
+    "test_3" => [
+       {name: "sub_record.sub_id", val: nil, split_name:["sub_record","sub_id"]},
+			 ],
+}.freeze
+
+	def test
+	  grpc_request = Testdata::TestRequest.new
+	  GrpcRest.assign_params(grpc_request, METHOD_PARAM_MAP["test"], "*", request.parameters)
+    render json: GrpcRest.send_request("Testdata::MyService", "test", grpc_request)
+  end
+
+	def test_2
+	  grpc_request = Testdata::TestRequest.new
+	  GrpcRest.assign_params(grpc_request, METHOD_PARAM_MAP["test_2"], "second_record", request.parameters)
+    render json: GrpcRest.send_request("Testdata::MyService", "test_2", grpc_request)
+  end
+
+	def test_3
+	  grpc_request = Testdata::TestRequest.new
+	  GrpcRest.assign_params(grpc_request, METHOD_PARAM_MAP["test_3"], "", request.parameters)
+    render json: GrpcRest.send_request("Testdata::MyService", "test_3", grpc_request)
+  end
+
+end

data/protoc-gen-rails/testdata/base/config/routes/grpc.rb

@@ -0,0 +1,4 @@
+
+get "/test/:blah/:repeated_string" => "my_service#test"
+post "/test2" => "my_service#test_2"
+post "/test3/:sub_id" => "my_service#test_3"

data/protoc-gen-rails/testdata/test_service.proto

@@ -0,0 +1,46 @@
+syntax = "proto3";
+
+package testdata;
+
+import "google/api/annotations.proto";
+
+message TestRequest {
+  string test_id = 1;
+  string foobar = 2;
+  repeated string repeated_string = 3;
+  SubRecord sub_record = 4;
+  SubRecord second_record = 5;
+}
+
+message SubRecord {
+  string sub_id = 1;
+  string another_id = 2;
+}
+
+message TestResponse {
+  int32 some_int = 1;
+  string full_response = 2;
+}
+
+service MyService {
+  rpc Test(TestRequest) returns (TestResponse) {
+    option (google.api.http) = {
+      get: "/test/{blah=foobar/*}/{repeated_string}"
+      body: "*"
+    };
+  }
+
+  rpc Test2(TestRequest) returns (TestResponse) {
+    option (google.api.http) = {
+      post: "/test2"
+      body: "second_record"
+    };
+  }
+
+  rpc Test3(TestRequest) returns (TestResponse) {
+    option (google.api.http) = {
+      post: "/test3/{sub_record.sub_id}"
+    };
+  }
+
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grpc-rest
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Daniel Orner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-01 00:00:00.000000000 Z
+date: 2024-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: grpc
@@ -45,19 +45,28 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/CI.yml"
 - ".gitignore"
+- CHANGELOG
+- CODE_OF_CONDUCT.md
 - README.md
 - grpc-rest.gemspec
 - lib/grpc_rest.rb
 - lib/grpc_rest/version.rb
+- protoc-gen-rails/.goreleaser.yml
 - protoc-gen-rails/LICENSE
 - protoc-gen-rails/go.mod
 - protoc-gen-rails/go.sum
+- protoc-gen-rails/google-deps/google/api/annotations.proto
+- protoc-gen-rails/google-deps/google/api/http.proto
 - protoc-gen-rails/internal/output.go
 - protoc-gen-rails/internal/parse.go
 - protoc-gen-rails/internal/utils.go
 - protoc-gen-rails/main.go
 - protoc-gen-rails/main_test.go
+- protoc-gen-rails/testdata/base/app/controllers/my_service_controller.rb
+- protoc-gen-rails/testdata/base/config/routes/grpc.rb
+- protoc-gen-rails/testdata/test_service.proto
 homepage: ''
 licenses:
 - MIT