twirp 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cd5d364eb9a55aa4f9f80a217d0c25a9a3b5377d
+  data.tar.gz: add09813fd7965e1c510b5774a30445e66859b3e
+SHA512:
+  metadata.gz: 1a0e61629575ec564449543c16b6c4842541abaea0c97e944318aea5ed385941b155371cbe2926faf2fe0c50824d46d1eb44302bed983749859599b6906d9063
+  data.tar.gz: f4113090daee32f775653c563fdb2ba60bad0d34ccc0b2287e8636b820288411933d20e41988d43ae17035db737e3e7cdce4079ad888fd16a4fc14a4eb8ee608

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,20 @@
+PATH
+  remote: .
+  specs:
+    twirp (0.0.1)
+      google-protobuf (>= 3.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    google-protobuf (3.5.1.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 1)
+  twirp!
+
+BUNDLED WITH
+   1.14.6

data/README.md

@@ -0,0 +1,3 @@
+# Ruby Twirp
+
+Twirp services and clients in Ruby.

data/lib/twirp.rb

@@ -0,0 +1,2 @@
+require_relative 'twirp/version'
+require_relative 'twirp/error'

data/lib/twirp/error.rb

@@ -0,0 +1,86 @@
+module Twirp
+
+  # Valid Twirp error codes and their mapping to related HTTP status.
+  # This can also be used to check if a code is valid (check if not nil).
+  ERROR_CODES_TO_HTTP_STATUS = {
+    canceled:             408, # RequestTimeout
+    invalid_argument:     400, # BadRequest
+    deadline_exceeded:    408, # RequestTimeout
+    not_found:            404, # Not Found
+    bad_route:            404, # Not Found
+    already_exists:       409, # Conflict
+    permission_denied:    403, # Forbidden
+    unauthenticated:      401, # Unauthorized
+    resource_exhausted:   403, # Forbidden
+    failed_precondition:  412, # Precondition Failed
+    aborted:              409, # Conflict
+    out_of_range:         400, # Bad Request
+
+    internal:             500, # Internal Server Error
+    unknown:              500, # Internal Server Error
+    unimplemented:        501, # Not Implemented
+    unavailable:          503, # Service Unavailable
+    data_loss:            500, # Internal Server Error
+  }
+
+  # List of all valid error codes in Twirp
+  ERROR_CODES = ERROR_CODES_TO_HTTP_STATUS.keys
+
+  # Twirp::Error represents a valid error from a Twirp service
+	class Error
+
+    # Initialize a Twirp::Error
+    # The code MUST be one of the valid ERROR_CODES Symbols (e.g. :internal, :not_found, :permission_denied ...).
+    # The msg is a String with the error message.
+    # The meta is optional error metadata, if included it MUST be a Hash with String keys and values.
+    def initialize(code, msg, meta=nil)
+      @code = validate_code(code)
+      @msg = msg.to_s
+      @meta = validate_meta(meta)
+    end
+
+    attr_reader :code
+    attr_reader :msg
+    def meta; @meta || {}; end
+
+    def as_json
+      h = {
+        code: @code,
+        msg: @msg,
+      }
+      h[:meta] = @meta if @meta
+      h
+    end
+
+    def to_json
+      JSON.encode(as_json)
+    end
+
+    private
+
+    def validate_code(code)
+      if !code.is_a? Symbol
+        raise ArgumentError.new("Twirp::Error code must be a Symbol, but it is a #{code.class.to_s}")
+      end
+      if !ERROR_CODES_TO_HTTP_STATUS.has_key? code
+        raise ArgumentError.new("Twirp::Error code :#{code} is invalid. Expected one of #{ERROR_CODES.inspect}")
+      end
+      code
+    end
+
+    def validate_meta(meta)
+      return nil if !meta
+      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
+      end
+      meta
+    end
+
+  end
+
+end

data/lib/twirp/server.rb

@@ -0,0 +1,66 @@
+module Twirp
+  class Server
+    @@rpcs = {}
+
+    def initialize(svc)
+      @svc = svc
+    end
+
+    def self.rpc(name, request_class, response_class)
+      @@rpcs[name] = {
+        request_class: request_class,
+        response_class: response_class
+      }
+    end
+
+    def route_request(req)
+      # Parse url to get method names
+      method_name = req.path_info[1..-1]
+
+      # Get req/res types from @@rpcs
+      rpc = @@rpcs[method_name.to_sym]
+      request_class = rpc[:request_class]
+      response_class = rpc[:response_class]
+
+      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"]}"))
+      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.underscore, params)
+      self.serve_success_json(response_class.encode_json(resp))
+    end
+
+    def serve_proto(req, method_name, request_class, response_class)
+      params = request_type.decode(req.body.read)
+      resp = @svc.send(method_name.underscore, params)
+      self.serve_success_proto(response_class.encode(resp))
+    end
+
+    def serve_success_proto(resp)
+      return ['200', {'Content-Type' => 'application/protobuf'}, [resp]]
+    end
+
+    def serve_success_json(resp)
+      return ['200', {'Content-Type' => 'application/json'}, [resp]]
+    end
+
+    def serve_error(twerr)
+      return ['500', {'Content-Type' => 'application/json'}, []]
+    end
+
+    def handler
+      return Proc.new do |env|
+        req = Rack::Request.new(env)
+        self.route_request(req)
+      end
+    end
+  end
+end

data/lib/twirp/version.rb

@@ -0,0 +1,3 @@
+module Twirp
+  VERSION = "0.0.1"
+end

data/protoc-gen-twirp_ruby/main.go

@@ -0,0 +1,185 @@
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"os"
+	"path"
+	"strings"
+	"unicode"
+
+	"github.com/golang/protobuf/proto"
+	"github.com/golang/protobuf/protoc-gen-go/descriptor"
+	plugin "github.com/golang/protobuf/protoc-gen-go/plugin"
+)
+
+const Version = "v5.2.0"
+
+func main() {
+	versionFlag := flag.Bool("version", false, "print version and exit")
+	flag.Parse()
+	if *versionFlag {
+		fmt.Println(Version)
+		os.Exit(0)
+	}
+
+	g := newGenerator()
+	Main(g)
+}
+
+type Generator interface {
+	Generate(in *plugin.CodeGeneratorRequest) *plugin.CodeGeneratorResponse
+}
+
+func Main(g Generator) {
+	req := readGenRequest(os.Stdin)
+	resp := g.Generate(req)
+	writeResponse(os.Stdout, resp)
+}
+
+type generator struct {
+	output *bytes.Buffer
+}
+
+func newGenerator() *generator {
+	return &generator{output: new(bytes.Buffer)}
+}
+
+func (g *generator) Generate(in *plugin.CodeGeneratorRequest) *plugin.CodeGeneratorResponse {
+
+	resp := new(plugin.CodeGeneratorResponse)
+	for _, name := range in.FileToGenerate {
+		for _, f := range in.ProtoFile {
+			if f.GetName() == name {
+				respFile := g.generateFile(f)
+				if respFile != nil {
+					resp.File = append(resp.File, respFile)
+				}
+				continue
+			}
+		}
+	}
+
+	return resp
+}
+
+func (g *generator) generateFile(file *descriptor.FileDescriptorProto) *plugin.CodeGeneratorResponse_File {
+	pkgName := pkgName(file)
+	g.P(`# Code generated by protoc-gen-twirp_ruby, DO NOT EDIT.`)
+	for _, service := range file.Service {
+		serviceName := serviceName(service)
+		g.P(``)
+		g.P(fmt.Sprintf("class %s < Twirp::Server", serviceName))
+		g.P(fmt.Sprintf(`PATH_PREFIX = "/twirp/%s.%s"`, pkgName, serviceName))
+		for _, method := range service.GetMethod() {
+			methName := methodName(method)
+			inputName := methodInputName(method)
+			outputName := methodOutputName(method)
+			g.P(fmt.Sprintf("  rpc :%s, %s, %s", methName, inputName, outputName))
+		}
+		g.P(`end`)
+	}
+
+	resp := new(plugin.CodeGeneratorResponse_File)
+	resp.Name = proto.String(rubyFileName(file))
+	resp.Content = proto.String(g.output.String())
+	g.output.Reset()
+
+	return resp
+}
+
+func (g *generator) P(args ...string) {
+	for _, v := range args {
+		g.output.WriteString(v)
+	}
+	g.output.WriteByte('\n')
+}
+
+func rubyFileName(f *descriptor.FileDescriptorProto) string {
+	name := *f.Name
+	if ext := path.Ext(name); ext == ".proto" || ext == ".protodevel" {
+		name = name[:len(name)-len(ext)]
+	}
+	name += "_twirp.rb"
+	return name
+}
+
+func pkgName(file *descriptor.FileDescriptorProto) string {
+	return file.GetPackage()
+}
+
+func serviceName(service *descriptor.ServiceDescriptorProto) string {
+	return service.GetName()
+}
+
+func methodName(method *descriptor.MethodDescriptorProto) string {
+	return method.GetName()
+}
+
+// methodInputName returns the basename of the input type of a method in snake
+// case.
+func methodInputName(meth *descriptor.MethodDescriptorProto) string {
+	fullName := meth.GetInputType()
+	split := strings.Split(fullName, ".")
+	return split[len(split)-1]
+}
+
+// methodInputName returns the basename of the input type of a method in snake
+// case.
+func methodOutputName(meth *descriptor.MethodDescriptorProto) string {
+	fullName := meth.GetOutputType()
+	split := strings.Split(fullName, ".")
+	return split[len(split)-1]
+}
+
+func Fail(msgs ...string) {
+	s := strings.Join(msgs, " ")
+	log.Print("error:", s)
+	os.Exit(1)
+}
+
+// SnakeCase converts a string from CamelCase to snake_case.
+func SnakeCase(s string) string {
+	var buf bytes.Buffer
+	for i, r := range s {
+		if unicode.IsUpper(r) && i > 0 {
+			fmt.Fprintf(&buf, "_")
+		}
+		r = unicode.ToLower(r)
+		fmt.Fprintf(&buf, "%c", r)
+	}
+	return buf.String()
+}
+
+func readGenRequest(r io.Reader) *plugin.CodeGeneratorRequest {
+	data, err := ioutil.ReadAll(os.Stdin)
+	if err != nil {
+		Fail(err.Error(), "reading input")
+	}
+
+	req := new(plugin.CodeGeneratorRequest)
+	if err = proto.Unmarshal(data, req); err != nil {
+		Fail(err.Error(), "parsing input proto")
+	}
+
+	if len(req.FileToGenerate) == 0 {
+		Fail("no files to generate")
+	}
+
+	return req
+}
+
+func writeResponse(w io.Writer, resp *plugin.CodeGeneratorResponse) {
+	data, err := proto.Marshal(resp)
+	if err != nil {
+		Fail(err.Error(), "marshaling response")
+	}
+	_, err = w.Write(data)
+	if err != nil {
+		Fail(err.Error(), "writing response")
+	}
+}

data/test/error_test.rb

@@ -0,0 +1,83 @@
+require 'minitest/autorun'
+
+require_relative '../lib/twirp/error'
+
+class TestErrorCodes < Minitest::Test
+  
+  def test_error_codes
+    assert_equal 17, Twirp::ERROR_CODES.size
+
+    # all codes should be symbols
+    Twirp::ERROR_CODES.each do |code|
+      assert_instance_of Symbol, code
+    end
+
+    # check some codes
+    assert_includes Twirp::ERROR_CODES, :internal 
+    assert_includes Twirp::ERROR_CODES, :not_found
+    assert_includes Twirp::ERROR_CODES, :invalid_argument
+  end
+
+  def test_codes_to_http_status
+    assert_equal 17, Twirp::ERROR_CODES_TO_HTTP_STATUS.size
+
+    assert_equal 404, Twirp::ERROR_CODES_TO_HTTP_STATUS[:not_found]
+    assert_equal 500, Twirp::ERROR_CODES_TO_HTTP_STATUS[:internal]
+
+    # nil for invalid_codes
+    assert_nil Twirp::ERROR_CODES_TO_HTTP_STATUS[:invalid_fdsafda]
+    assert_nil Twirp::ERROR_CODES_TO_HTTP_STATUS[500]
+    assert_nil Twirp::ERROR_CODES_TO_HTTP_STATUS[nil]
+    assert_nil Twirp::ERROR_CODES_TO_HTTP_STATUS["not_found"] # string checks not supported, please use symbols
+  end
+end
+
+class TestTwirpError < Minitest::Test
+
+  def test_new_with_valid_code_and_a_message
+    err = Twirp::Error.new(:internal, "woops")
+    assert_equal :internal, err.code
+    assert_equal "woops", err.msg
+    assert_equal({}, err.meta) # empty
+  end
+
+  def test_new_with_valid_metadata
+    err = Twirp::Error.new(:internal, "woops", "meta" => "data", "for this" => "error")
+    assert_equal err.meta["meta"], "data"
+    assert_equal "error", err.meta["for this"] 
+    assert_nil err.meta["something else"]
+  end
+
+  def test_invalid_code
+    assert_raises ArgumentError do 
+      Twirp::Error.new(:invalid_code, "woops")
+    end
+  end
+
+  def test_invalid_metadata
+    Twirp::Error.new(:internal, "woops") # ensure the base case doesn't error
+
+    assert_raises ArgumentError do 
+      Twirp::Error.new(:internal, "woops", non_string: "metadata")
+    end
+
+    assert_raises ArgumentError do 
+      Twirp::Error.new(:internal, "woops", "string key" => :non_string_value)
+    end
+
+    assert_raises ArgumentError do 
+      Twirp::Error.new(:internal, "woops", "valid key" => "valid val", "bad_one" => 666)
+    end
+  end
+
+  def test_as_json
+    # returns a hash with attributes
+    err = Twirp::Error.new(:internal, "err msg", "key" => "val")
+    assert_equal({code: :internal, msg: "err msg", meta: {"key" => "val"}}, err.as_json)
+  
+    # skips meta if not included 
+    err = Twirp::Error.new(:internal, "err msg")
+    assert_equal({code: :internal, msg: "err msg"}, err.as_json)
+  end
+end
+

data/twirp.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'twirp/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "twirp"
+  spec.version       = Twirp::VERSION
+  spec.authors       = ["Cyrus A. Forbes", "Mario Izquierdo"]
+  spec.email         = ["forbescyrus@gmail.com", "tothemario@gmail.com"]
+  spec.summary       = %q{Twirp services in Ruby.}
+  spec.description   = %q{Twirp is a simple RPC framework with protobuf service definitions. The Twirp gem provides support for Ruby.}
+  spec.homepage      = "https://github.com/cyrusaf/ruby-twirp"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'google-protobuf', '>= 3.0.0'
+
+  spec.add_development_dependency 'bundler', '>= 1'
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: twirp
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Cyrus A. Forbes
+- Mario Izquierdo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-02-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: google-protobuf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+description: Twirp is a simple RPC framework with protobuf service definitions. The
+  Twirp gem provides support for Ruby.
+email:
+- forbescyrus@gmail.com
+- tothemario@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- lib/twirp.rb
+- lib/twirp/error.rb
+- lib/twirp/server.rb
+- lib/twirp/version.rb
+- protoc-gen-twirp_ruby/main.go
+- test/error_test.rb
+- twirp.gemspec
+homepage: https://github.com/cyrusaf/ruby-twirp
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Twirp services in Ruby.
+test_files:
+- test/error_test.rb