twirp 0.0.2.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0beb3999bd9e3f24928e3177696919e1e48003c3
-  data.tar.gz: 0173e308fa7df470db82f6a5129972ab2c368679
+  metadata.gz: 76e48aace902f0cec12c1055dd664f659fb9dcf3
+  data.tar.gz: 792f3fcc5a62cbd2adfd9f3d714b246e96c63bca
 SHA512:
-  metadata.gz: ea168c51643ae809dd9998fb932bee65f4ee8b21472aff74107b5beef1afc0a34a8af4b6d2591c65a80aa64ce503b3094dc5fee6a2d9b3a0dcf24dfdbfa3ec23
-  data.tar.gz: cc0310f0f12b57c3fdfe938573769ba88c752d91ec8c220e261dda410105a61e89d1ca8204fae6f82fac16956a50ee6033122f2c7dc7a720c010bbaf3b269670
+  metadata.gz: ea48c85b317496979d87015964d714a95db49093d5a81183b50928fbcdb453f4469fdf819b907012b1094f692fc08d3892b89bf55d870791f8607eded50ca06b
+  data.tar.gz: bb59b2e6077814fa06b9b29fee4473155408eb0930ddb4ca00a2e088534e4a32b64450eda3721445c26634d5ed36ead624b35544c2c8988f070ffc066a7bf8ad

data/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

data/README.md

@@ -4,12 +4,12 @@ Twirp services and clients in Ruby.
 
 ### Installation
 Install the `twirp` gem:
-```
+```sh
 ➜ gem install twirp
 ```
 
 Use `go get` to install the ruby_twirp protoc plugin:
-```
+```sh
 ➜ go get github.com/cyrusaf/ruby-twirp/protoc-gen-twirp_ruby
 ```
 
@@ -18,13 +18,13 @@ You will also need:
    version 3+.
 
 ### Haberdasher Example
-See the `examples/` folder for the final product.
+See the `example/` folder for the final product.
 
 First create a basic `.proto` file:
-```
+```protobuf
 // haberdasher.proto
 syntax = "proto3";
-package examples;
+package example;
 
 service Haberdasher {
     rpc HelloWorld(HelloWorldRequest) returns (HelloWorldResponse);
@@ -41,47 +41,46 @@ message HelloWorldResponse {
 ```
 
 Run the `protoc` binary to generate `gen/haberdasher_pb.rb` and `gen/haberdasher_twirp.rb`.
-```
+```sh
 ➜ protoc --proto_path=. ./haberdasher.proto --ruby_out=gen --twirp_ruby_out=gen
 ```
 
 Write an implementation of our haberdasher service and attach to a rack server:
-```
+```ruby
 # main.rb
 require 'rack'
 require_relative 'gen/haberdasher_pb.rb'
 require_relative 'gen/haberdasher_twirp.rb'
 
-class HaberdasherImplementation
-    def HelloWorld(req)
-        return Examples::HelloWorldResponse.new(message: "Hello #{req.name}")
+class HaberdasherHandler
+    def hello_world(req)
+        return Example::HelloWorldResponse.new(message: "Hello #{req.name}")
     end
 end
 
-svc = HaberdasherImplementation.new()
-url_map = Rack::URLMap.new HaberdasherService::PATH_PREFIX => HaberdasherService.new(svc).handler
-Rack::Handler::WEBrick.run url_map
+handler = HaberdasherHandler.new()
+Rack::Handler::WEBrick.run Example::HaberdasherService.new(handler)
 ```
 
 You can also mount onto a rails service:
-```
+```ruby
 App::Application.routes.draw do
-  svc = HaberdasherImplementation.new()
-  mount HaberdasherServer.new(svc).handler, at: HaberdasherServer::PATH_PREFIX
+  handler = HaberdasherHandler.new()
+  mount Example::HaberdasherService.new(handler), at: HaberdasherService::PATH_PREFIX
 end
 ```
 
 Run `ruby main.rb` to start the server on port 8080:
-```
+```sh
 ➜ ruby main.rb
 ```
 
 `curl` your server to get a response:
-```
+```sh
 ➜ curl --request POST \
   --url http://localhost:8080/twirp/examples.Haberdasher/HelloWorld \
   --header 'content-type: application/json' \
   --data '{
 	"name": "World"
-}'
+  }'
 ```

data/{examples → example}/Gemfile

@@ -3,5 +3,5 @@ source "https://rubygems.org"
 
 git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 
-gem 'twirp'
+gem "twirp"
 gem "rack"

data/{examples → example}/gen/haberdasher_pb.rb

@@ -4,15 +4,15 @@
 require 'google/protobuf'
 
 Google::Protobuf::DescriptorPool.generated_pool.build do
-  add_message "examples.HelloWorldRequest" do
+  add_message "example.HelloWorldRequest" do
     optional :name, :string, 1
   end
-  add_message "examples.HelloWorldResponse" do
+  add_message "example.HelloWorldResponse" do
     optional :message, :string, 1
   end
 end
 
-module Examples
-  HelloWorldRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("examples.HelloWorldRequest").msgclass
-  HelloWorldResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("examples.HelloWorldResponse").msgclass
+module Example
+  HelloWorldRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("example.HelloWorldRequest").msgclass
+  HelloWorldResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("example.HelloWorldResponse").msgclass
 end

data/example/gen/haberdasher_twirp.rb

@@ -0,0 +1,11 @@
+# Code generated by protoc-gen-twirp_ruby, DO NOT EDIT.
+require 'twirp'
+
+module Example
+  class HaberdasherService < Twirp::Service
+    PATH_PREFIX = "/twirp/example.Haberdasher"
+    package "example"
+    service "Haberdasher"
+    rpc :HelloWorld, HelloWorldRequest, HelloWorldResponse, handler_method: 'hello_world'
+  end
+end

data/{examples → example}/haberdasher.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package examples;
+package example;
 
 service Haberdasher {
     rpc HelloWorld(HelloWorldRequest) returns (HelloWorldResponse);

data/example/main.rb

@@ -0,0 +1,13 @@
+require 'rack'
+require_relative 'gen/haberdasher_pb.rb'
+require_relative 'gen/haberdasher_twirp.rb'
+
+class HaberdasherHandler
+    def hello_world(req)
+        return Example::HelloWorldResponse.new(message: "Hello #{req.name}")
+    end
+end
+
+handler = HaberdasherHandler.new()
+service = Example::HaberdasherService.new(handler)
+Rack::Handler::WEBrick.run service

data/lib/twirp/error.rb

@@ -41,7 +41,23 @@ module Twirp
 
     attr_reader :code
     attr_reader :msg
-    def meta; @meta || {}; end
+    
+    def meta(key)
+      @meta ||= {}
+      @meta[key]
+    end
+
+    def add_meta(key, value)
+      validate_meta_key_value(key, value)
+      @meta ||= {}
+      @meta[key] = value
+    end
+
+    def delete_meta(key)
+      @meta ||= {}
+      @meta.delete(key.to_s)
+      @meta = nil if @meta.size == 0
+    end
 
     def as_json
       h = {
@@ -73,14 +89,18 @@ module Twirp
       if !meta.is_a? Hash
         raise ArgumentError.new("Twirp::Error meta must be a Hash, but it is a #{meta.class.to_s}")
       end
-      meta.each do |k, v|
-        if !k.is_a?(String) || !v.is_a?(String)
-          raise ArgumentError.new("Twirp::Error meta must be a Hash with String keys and values")
-        end
+      meta.each do |key, value| 
+        validate_meta_key_value(key, value)        
       end
       meta
     end
 
+    def validate_meta_key_value(key, value)
+      if !key.is_a?(String) || !value.is_a?(String)
+        raise ArgumentError.new("Twirp::Error meta must be a Hash with String keys and values")
+      end
+    end
+
   end
 
 end

data/lib/twirp/service.rb

@@ -1,66 +1,164 @@
 module Twirp
+
   class Service
-    @@rpcs = {}
 
-    def initialize(svc)
-      @svc = svc
-    end
+    class << self
 
-    def self.rpc(name, request_class, response_class)
-      @@rpcs[name] = {
-        request_class: request_class,
-        response_class: response_class
-      }
-    end
+      # Configure service package name.
+      def package(package_name)
+        @package_name = package_name.to_s
+      end
 
-    def route_request(req)
-      # Parse url to get method names
-      method_name = req.fullpath[self.class::PATH_PREFIX.length+1..-1]
+      # Configure service name
+      def service(service_name)
+        @service_name = service_name.to_s
+      end
 
-      # Get req/res types from @@rpcs
-      rpc = @@rpcs[method_name.to_sym]
-      request_class = rpc[:request_class]
-      response_class = rpc[:response_class]
+      # Configure service routing to handle rpc calls.
+      def rpc(method_name, request_class, response_class, opts)
+        if !request_class.is_a?(Class)
+          raise ArgumentError.new("request_class must be a Protobuf Message class")
+        end 
+        if !response_class.is_a?(Class)
+          raise ArgumentError.new("response_class must be a Protobuf Message class")
+        end
+        if !opts || !opts[:handler_method]
+          raise ArgumentError.new("opts[:handler_method] is mandatory")
+        end
 
-      case req.env["CONTENT_TYPE"]
-      when "application/json"
-        return self.serve_json(req, method_name, request_class, response_class)
-      when "application/protobuf"
-        return self.serve_proto(req, method_name, request_class, response_class)
-      else
-        return self.serve_error(Twerr.NotFound("unexpected Content-Type: #{req.env["CONTENT_TYPE"]}"))
+        @rpcs ||= {}
+        @rpcs[method_name.to_s] = {
+          request_class: request_class,
+          response_class: response_class,
+          handler_method: opts[:handler_method],
+        }
+      end
+
+      # Get configured package name as String.
+      # And empty value means that there's no package
+      def package_name
+        @package_name.to_s
+      end
+
+      # Get configured service name as String.
+      # If not configured, it defaults to the class name
+      def service_name
+        sname = @service_name.to_s
+        sname.empty? ? self.name : sname
+      end
+
+      # Get configured metadata for rpc methods
+      def rpcs
+        @rpcs || {}
+      end
+
+      # Path prefix that should be used to route requests to this service.
+      # It is based on the package and service name, in the expected Twirp URL format.
+      # The full URL would be: {BaseURL}/path_prefix/{MethodName}
+      def path_prefix
+        if package_name.empty?
+          service_name # e.g. "Haberdasher"
+        else
+          "#{package_name}.#{service_name}" # e.g. "the.haberdasher.pkg.Haberdasher"
+        end
       end
     end
 
-    def serve_json(req, method_name, request_class, response_class)
-      params = request_class.decode_json(req.body.read)
-      resp = @svc.send(method_name, params)
-      self.serve_success_json(response_class.encode_json(resp))
+    # Instantiate a new service with a handler.
+    # A handler implements each rpc method as a regular object method call.
+    def initialize(handler)
+      # validate that the handler reponds to all expected methods
+      self.class.rpcs.each do |method_name, rpc|
+        if !handler.respond_to? rpc[:handler_method]
+          raise ArgumentError.new("Handler must respond to .#{rpc[:handler_method]}(req) in order to handle the message #{method_name}.")
+        end
+      end
+
+      @handler = handler
     end
 
-    def serve_proto(req, method_name, request_class, response_class)
-      params = request_type.decode(req.body.read)
-      resp = @svc.send(method_name, params)
-      self.serve_success_proto(response_class.encode(resp))
+    # Register a before hook (not implemented)
+    def before(&block)
+      # TODO... and also after hooks
     end
 
-    def serve_success_proto(resp)
-      return ['200', {'Content-Type' => 'application/protobuf'}, [resp]]
+    # A service instance is a Rack middleware block.
+    def call(env)
+      req = Rack::Request.new(env)
+
+      if req.request_method != "POST"
+        return error_response(bad_route_error("Only POST method is allowed", req))
+      end
+      
+      method_name = req.fullpath.split("/").last
+      rpc_method = self.class.rpcs[method_name]
+      if !rpc_method
+        return error_response(bad_route_error("rpc method not found: #{method_name.inspect}", req))
+      end
+
+      request_class = rpc_method[:request_class]
+      response_class = rpc_method[:response_class]
+
+      content_type = req.env["CONTENT_TYPE"]
+      req_msg = decode_request(rpc_method[:request_class], content_type, req.body.read)
+      if !req_msg
+        return error_response(bad_route_error("unexpected Content-Type: #{content_type.inspect}", req))
+      end
+
+      # Handle Twirp request
+      # TODO: wrap with begin-rescue block
+      resp_msg = @handler.send(rpc_method[:handler_method], req_msg)
+
+      if resp_msg.is_a? Twirp::Error
+        return error_response(resp_msg)
+      end
+
+      if resp_msg.is_a? Hash # allow handlers to respond with just the attributes
+        resp_msg = response_class.new(resp_msg)
+      end
+      encoded_resp = encode_response(response_class, content_type, resp_msg)
+
+      return [200, {'Content-Type' => content_type}, [encoded_resp]]
+
+      # TODO: add recue for any error in the method, wrap with Twith error
     end
 
-    def serve_success_json(resp)
-      return ['200', {'Content-Type' => 'application/json'}, [resp]]
+    # path prefix that can be used to mount this service
+    def path_prefix
+      self.class.path_prefix
     end
 
-    def serve_error(twerr)
-      return ['500', {'Content-Type' => 'application/json'}, []]
+  private
+
+    def decode_request(request_class, content_type, body)
+      case content_type
+      when "application/json"
+        request_class.decode_json(body)
+      when "application/protobuf"
+        request_type.decode(body)
+      end
     end
 
-    def handler
-      return Proc.new do |env|
-        req = Rack::Request.new(env)
-        self.route_request(req)
+    def encode_response(response_class, content_type, resp)
+      case content_type
+      when "application/json"
+        response_class.encode_json(resp)
+      when "application/protobuf"
+        response_class.encode(resp)
       end
     end
+
+    def error_response(twirp_error)
+      status = Twirp::ERROR_CODES_TO_HTTP_STATUS[twirp_error.code]
+      headers = {'Content-Type' => 'application/json'} 
+      resp_body = twirp_error.to_json
+      [status, headers, [resp_body]]
+    end
+
+    def bad_route_error(msg, req)
+      meta_invalid_route = "#{req.request_method} #{req.fullpath}"
+      Twirp::Error.new(:bad_route, msg, "twirp_invalid_route" => meta_invalid_route)
+    end
+
   end
 end

data/lib/twirp/version.rb

@@ -1,3 +1,3 @@
 module Twirp
-  VERSION = "0.0.2.1"
+  VERSION = "0.0.3"
 end

data/protoc-gen-twirp_ruby/main.go

@@ -68,20 +68,36 @@ func (g *generator) Generate(in *plugin.CodeGeneratorRequest) *plugin.CodeGenera
 }
 
 func (g *generator) generateFile(file *descriptor.FileDescriptorProto) *plugin.CodeGeneratorResponse_File {
+	indent := ""
 	pkgName := pkgName(file)
 	g.P(`# Code generated by protoc-gen-twirp_ruby, DO NOT EDIT.`)
-	for _, service := range file.Service {
+	g.P(`require 'twirp'`)
+	g.P(``)
+	if pkgName != "" {
+		g.P(fmt.Sprintf("module %s", CamelCase(pkgName)))
+		indent = indent + "  "
+	}
+	for i, service := range file.Service {
 		serviceName := serviceName(service)
-		g.P(`require 'twirp'`)
-		g.P(``)
-		g.P(fmt.Sprintf("class %sService < Twirp::Service", serviceName))
-		g.P(fmt.Sprintf(`  PATH_PREFIX = "/twirp/%s.%s"`, pkgName, serviceName))
+		g.P(fmt.Sprintf("%sclass %sService < Twirp::Service", indent, serviceName))
+		g.P(fmt.Sprintf(`%s  PATH_PREFIX = "/twirp/%s.%s"`, indent, pkgName, serviceName))
+		if pkgName != "" {
+			g.P(fmt.Sprintf(`%s  package "%s"`, indent, pkgName))
+		}
+		g.P(fmt.Sprintf(`%s  service "%s"`, indent, CamelCase(serviceName)))
 		for _, method := range service.GetMethod() {
 			methName := methodName(method)
 			inputName := methodInputName(method)
 			outputName := methodOutputName(method)
-			g.P(fmt.Sprintf("  rpc :%s, %s::%s, %s::%s", methName, CamelCase(pkgName), inputName, CamelCase(pkgName), outputName))
+			g.P(fmt.Sprintf(`%s  rpc :%s, %s, %s, handler_method: "%s"`,
+				indent, methName, inputName, outputName, SnakeCase(methName)))
 		}
+		g.P(fmt.Sprintf(`%send`, indent))
+		if i < len(file.Service)-1 {
+			g.P(``)
+		}
+	}
+	if pkgName != "" {
 		g.P(`end`)
 	}
 

data/test/service_test.rb

@@ -0,0 +1,105 @@
+require 'minitest/autorun'
+require 'rack/mock'
+
+require 'google/protobuf'
+require_relative '../lib/twirp'
+
+# Protobuf messages.
+# This is what the protoc code generator would produce.
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_message "foopkg.DoFooRequest" do
+    optional :foo, :string, 1
+  end
+  add_message "foopkg.DoFooResponse" do
+    optional :bar, :string, 1
+  end
+end
+module FooPkg
+  DoFooRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("foopkg.DoFooRequest").msgclass
+  DoFooResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("foopkg.DoFooResponse").msgclass
+end
+
+# Twirp Service.
+# This is wha the twirp_ruby protoc plugin code generator would produce.
+module FooPkg
+  class FooService < Twirp::Service
+    package "foopkg"
+    service "FooService"
+
+    rpc "DoFoo", DoFooRequest, DoFooResponse, handler_method: :do_foo
+  end
+end
+
+# Example service handler.
+# This would be provided by the developer as implementation for the service.
+class FooHandler
+  def do_foo(req)
+    {bar: "Hello #{req.foo}"}
+  end
+end
+
+# Twirp Service with no package and no rpc methods.
+class EmptyService < Twirp::Service
+end
+
+class ServiceTest < Minitest::Test
+
+  def test_rpc_methods
+    # make sure that rpcs have been properly setup by the `rpc` DSL constructor
+    assert_equal 1, FooPkg::FooService.rpcs.size
+    assert_equal({
+      request_class: FooPkg::DoFooRequest,
+      response_class: FooPkg::DoFooResponse,
+      handler_method: :do_foo,
+    }, FooPkg::FooService.rpcs["DoFoo"])
+  end
+
+  def test_package_service_getters
+    assert_equal "foopkg", FooPkg::FooService.package_name
+    assert_equal "FooService", FooPkg::FooService.service_name
+    assert_equal "foopkg.FooService", FooPkg::FooService.path_prefix
+
+    assert_equal "", EmptyService.package_name # defaults to empty string
+    assert_equal "EmptyService", EmptyService.service_name # defaults to class name
+    assert_equal "EmptyService", EmptyService.path_prefix # with no package is just the service name
+  end
+  
+  def test_initialize_service
+    # simple initialization
+    svc = FooPkg::FooService.new(FooHandler.new)
+    assert svc.respond_to?(:call) # so it is a Proc that can be used as Rack middleware
+
+    empty_svc = EmptyService.new(nil) # an empty service does not need a handler
+    assert svc.respond_to?(:call)
+  end
+
+  def test_path_prefix
+    svc = FooPkg::FooService.new(FooHandler.new)
+    assert_equal "foopkg.FooService", svc.path_prefix
+  end
+
+  def test_initialize_fails_on_invalid_handlers
+    assert_raises ArgumentError do 
+      FooPkg::FooService.new() # handler is mandatory
+    end
+
+    # verify that handler implements required methods
+    err = assert_raises ArgumentError do 
+      FooPkg::FooService.new("fake handler")
+    end
+    assert_equal "Handler must respond to .do_foo(req) in order to handle the message DoFoo.", err.message
+  end
+
+  def test_successful_simple_request
+    env = Rack::MockRequest.env_for("/twirp/foopkg.FooService/DoFoo", method: "POST", 
+      input: '{"foo": "World"}', "CONTENT_TYPE" => "application/json")
+
+    svc = FooPkg::FooService.new(FooHandler.new)
+    status, headers, body = svc.call(env)
+
+    assert_equal 200, status
+    assert_equal 'application/json', headers['Content-Type']
+    assert_equal body[0], '{"bar":"Hello World"}'
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: twirp
 version: !ruby/object:Gem::Version
-  version: 0.0.2.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Cyrus A. Forbes
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-06 00:00:00.000000000 Z
+date: 2018-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-protobuf
@@ -51,19 +51,21 @@ files:
 - ".gitignore"
 - Gemfile
 - Gemfile.lock
+- LICENSE
 - README.md
-- examples/Gemfile
-- examples/Gemfile.lock
-- examples/gen/haberdasher_pb.rb
-- examples/gen/haberdasher_twirp.rb
-- examples/haberdasher.proto
-- examples/main.rb
+- example/Gemfile
+- example/Gemfile.lock
+- example/gen/haberdasher_pb.rb
+- example/gen/haberdasher_twirp.rb
+- example/haberdasher.proto
+- example/main.rb
 - lib/twirp.rb
 - lib/twirp/error.rb
 - lib/twirp/service.rb
 - lib/twirp/version.rb
 - protoc-gen-twirp_ruby/main.go
 - test/error_test.rb
+- test/service_test.rb
 - twirp.gemspec
 homepage: https://github.com/cyrusaf/ruby-twirp
 licenses:
@@ -91,3 +93,4 @@ specification_version: 4
 summary: Twirp services in Ruby.
 test_files:
 - test/error_test.rb
+- test/service_test.rb

data/examples/gen/haberdasher_twirp.rb

@@ -1,7 +0,0 @@
-# Code generated by protoc-gen-twirp_ruby, DO NOT EDIT.
-require 'twirp'
-
-class HaberdasherService < Twirp::Service
-  PATH_PREFIX = "/twirp/examples.Haberdasher"
-  rpc :HelloWorld, Examples::HelloWorldRequest, Examples::HelloWorldResponse
-end

data/examples/main.rb

@@ -1,12 +0,0 @@
-require 'rack'
-require_relative 'gen/haberdasher_pb.rb'
-require_relative 'gen/haberdasher_twirp.rb'
-
-class HaberdasherImplementation
-    def HelloWorld(req)
-        return Examples::HelloWorldResponse.new(message: "Hello #{req.name}")
-    end
-end
-
-svc = HaberdasherImplementation.new()
-Rack::Handler::WEBrick.run HaberdasherService.new(svc).handler