grpc-web 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1e933d5fb31c8a64203e667339b03fe89a5b1bcfb8ddecd66c0271bef8d60f0e
+  data.tar.gz: af6dca14b9a5ba0ada4c91f1c8cf534f408cf8be77180b2553d5418491b38908
+SHA512:
+  metadata.gz: 1e06359b9f0097781bf63e28b87e0c12746ab6c3e1a80b1d02a971420931f2f62d5d49b78b1629b70ae204e7ed9c5502346176661c4eff5fabcaec724665c602
+  data.tar.gz: 18cd177d9f793d9006ee23f1a28be8879971db60a1e970d7d77e90bb193ed324279d8de3f1bdd7c58a13e31359e9b95596a54a94f57fe7a2ca18b82930ae3141

data/lib/grpc-web.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'grpc_web'

data/lib/grpc_web.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'grpc_web/version'
+require 'grpc_web/rack_app'
+
+module GRPCWeb
+  class << self
+    def rack_app
+      @rack_app ||= ::GRPCWeb::RackApp.new
+    end
+
+    def handle(service_or_class, &lazy_init_block)
+      rack_app.handle(service_or_class, &lazy_init_block)
+    end
+  end
+end

data/lib/grpc_web/client.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'grpc_web/client_executor'
+
+module GRPCWeb
+  class Client
+    attr_reader :base_url, :service_interface
+
+    def initialize(base_url, service_interface)
+      self.base_url = base_url
+      self.service_interface = service_interface
+
+      service_interface.rpc_descs.each do |rpc_method, rpc_desc|
+        define_rpc_method(rpc_method, rpc_desc)
+      end
+    end
+
+    private
+
+    attr_writer :base_url, :service_interface
+
+    def define_rpc_method(rpc_method, rpc_desc)
+      ruby_method = ::GRPC::GenericService.underscore(rpc_method.to_s).to_sym
+      define_singleton_method(ruby_method) do |params = {}|
+        uri = endpoint_uri(rpc_desc)
+        ::GRPCWeb::ClientExecutor.request(uri, rpc_desc, params)
+      end
+    end
+
+    def endpoint_uri(rpc_desc)
+      URI(File.join(base_url, service_interface.service_name, rpc_desc.name.to_s))
+    end
+  end
+end

data/lib/grpc_web/client_executor.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+
+require 'grpc/errors'
+require 'grpc_web/content_types'
+require 'grpc_web/message_framing'
+
+module GRPCWeb::ClientExecutor
+  class << self
+    include ::GRPCWeb::ContentTypes
+
+    GRPC_STATUS_HEADER = 'grpc-status'
+    GRPC_MESSAGE_HEADER = 'grpc-message'
+
+    def request(uri, rpc_desc, params = {})
+      req_proto = rpc_desc.input.new(params)
+      request_body = ::GRPCWeb::MessageFraming.frame_content(req_proto.to_proto)
+
+      resp = post_request(uri, request_body)
+      resp_body = handle_response(resp)
+      rpc_desc.output.decode(resp_body)
+    end
+
+    private
+
+    def request_headers
+      {
+        'Accept' => PROTO_CONTENT_TYPE,
+        'Content-Type' => PROTO_CONTENT_TYPE,
+      }
+    end
+
+    def post_request(uri, request_body)
+      request = Net::HTTP::Post.new(uri, request_headers)
+      request.body = request_body
+      if uri.userinfo
+        request.basic_auth uri.user, uri.password
+      end
+
+      Net::HTTP.start(uri.hostname, uri.port) do |http|
+        http.use_ssl = (uri.scheme == 'https')
+        http.request(request)
+      end
+    end
+
+    def handle_response(resp)
+      unless resp.is_a?(Net::HTTPSuccess)
+        raise "Received #{resp.code} #{resp.message} response: #{resp.body}"
+      end
+
+      frames = ::GRPCWeb::MessageFraming.unframe_content(resp.body)
+      header_frame = frames.find(&:header?)
+      headers = parse_headers(header_frame.body) if header_frame
+      raise_on_error(headers)
+      frames.find(&:payload?).body
+    end
+
+    def parse_headers(header_str)
+      headers = {}
+      lines = header_str.split(/\r?\n/)
+      lines.each do |line|
+        key, value = line.split(':', 2)
+        headers[key] = value
+      end
+      headers
+    end
+
+    def raise_on_error(headers)
+      return unless headers
+
+      status_str = headers[GRPC_STATUS_HEADER]
+      status_code = status_str.to_i if status_str && status_str == status_str.to_i.to_s
+
+      if status_code && status_code != 0
+        raise ::GRPC::BadStatus.new_status_exception(status_code, headers[GRPC_MESSAGE_HEADER])
+      end
+    end
+  end
+end

data/lib/grpc_web/content_types.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module GRPCWeb::ContentTypes
+  DEFAULT_CONTENT_TYPE = 'application/grpc-web'
+  PROTO_CONTENT_TYPE = 'application/grpc-web+proto'
+  JSON_CONTENT_TYPE = 'application/grpc-web+json'
+  TEXT_CONTENT_TYPE = 'application/grpc-web-text'
+  TEXT_PROTO_CONTENT_TYPE = 'application/grpc-web-text+proto'
+
+  BASE64_CONTENT_TYPES = [TEXT_CONTENT_TYPE, TEXT_PROTO_CONTENT_TYPE].freeze
+  ALL_CONTENT_TYPES = [
+    DEFAULT_CONTENT_TYPE,
+    PROTO_CONTENT_TYPE,
+    JSON_CONTENT_TYPE,
+    TEXT_CONTENT_TYPE,
+    TEXT_PROTO_CONTENT_TYPE,
+  ].freeze
+  ANY_CONTENT_TYPES = ['*/*', ''].freeze
+end

data/lib/grpc_web/error_callback.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module GRPCWeb
+  class << self
+    NOOP_ON_ERROR = proc { |ex, service, service_method| }
+
+    def on_error(&block)
+      if block_given?
+
+        unless block.parameters.length == 3
+          raise ArgumentError, 'callback must accept (exception, service, service_method)'
+        end
+
+        self.on_error_callback = block
+      else
+        on_error_callback || NOOP_ON_ERROR
+      end
+    end
+
+    private
+
+    attr_accessor :on_error_callback
+  end
+end

data/lib/grpc_web/grpc_request_processor.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'grpc_web/content_types'
+require 'grpc_web/error_callback'
+require 'grpc_web/grpc_web_response'
+require 'grpc_web/message_framing'
+require 'grpc_web/message_serialization'
+require 'grpc_web/text_coder'
+
+module GRPCWeb::GRPCRequestProcessor
+  class << self
+    include ::GRPCWeb::ContentTypes
+
+    def process(grpc_web_request)
+      text_coder = ::GRPCWeb::TextCoder
+      framing = ::GRPCWeb::MessageFraming
+      serialization = ::GRPCWeb::MessageSerialization
+
+      grpc_web_request = text_coder.decode_request(grpc_web_request)
+      grpc_web_request = framing.unframe_request(grpc_web_request)
+      grpc_web_request = serialization.deserialize_request(grpc_web_request)
+      grpc_web_response = execute_request(grpc_web_request)
+      grpc_web_response = serialization.serialize_response(grpc_web_response)
+      grpc_web_response = framing.frame_response(grpc_web_response)
+      text_coder.encode_response(grpc_web_response)
+    end
+
+    private
+
+    def execute_request(request)
+      service_method = ::GRPC::GenericService.underscore(request.service_method.to_s)
+
+      begin
+        response = request.service.send(service_method, request.body)
+      rescue StandardError => e
+        ::GRPCWeb.on_error.call(e, request.service, request.service_method)
+        response = e # Return exception as body if one is raised
+      end
+      ::GRPCWeb::GRPCWebResponse.new(response_content_type(request), response)
+    end
+
+    # Use Accept header value if specified, otherwise use request content type
+    def response_content_type(request)
+      if request.accept.nil? || ANY_CONTENT_TYPES.include?(request.accept)
+        request.content_type
+      else
+        request.accept
+      end
+    end
+  end
+end

data/lib/grpc_web/grpc_web_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module GRPCWeb
+  GRPCWebRequest = Struct.new(
+    :service,
+    :service_method,
+    :content_type,
+    :accept,
+    :body,
+  )
+end

data/lib/grpc_web/grpc_web_response.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module GRPCWeb
+  GRPCWebResponse = Struct.new(:content_type, :body)
+end

data/lib/grpc_web/message_frame.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module GRPCWeb
+  class MessageFrame
+    PAYLOAD_FRAME_TYPE = 0 # String: "\x00"
+    HEADER_FRAME_TYPE = 128 # String: "\x80"
+
+    def self.payload_frame(body)
+      new(PAYLOAD_FRAME_TYPE, body)
+    end
+
+    def self.header_frame(body)
+      new(HEADER_FRAME_TYPE, body)
+    end
+
+    attr_accessor :frame_type, :body
+
+    def initialize(frame_type, body)
+      self.frame_type = frame_type
+      self.body = body
+    end
+
+    def payload?
+      frame_type == PAYLOAD_FRAME_TYPE
+    end
+
+    def header?
+      frame_type == HEADER_FRAME_TYPE
+    end
+  end
+end

data/lib/grpc_web/message_framing.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'grpc_web/grpc_web_response'
+require 'grpc_web/grpc_web_request'
+require 'grpc_web/message_frame'
+
+module GRPCWeb
+  # GRPC Web uses a simple 5 byte framing scheme. The first byte represents
+  # flags indicating what type of frame this is. The next 4 bytes indicate the
+  # byte length of the frame body.
+  module MessageFraming
+    class << self
+      def unframe_request(request)
+        frames = unframe_content(request.body)
+        ::GRPCWeb::GRPCWebRequest.new(
+          request.service, request.service_method, request.content_type, request.accept, frames,
+        )
+      end
+
+      def frame_response(response)
+        framed = response.body.map do |frame|
+          frame_content(frame.body, frame.frame_type)
+        end.join
+        ::GRPCWeb::GRPCWebResponse.new(response.content_type, framed)
+      end
+
+      def frame_content(content, frame_type = ::GRPCWeb::MessageFrame::PAYLOAD_FRAME_TYPE)
+        length_bytes = [content.bytesize].pack('N')
+        "#{frame_type.chr}#{length_bytes}#{content}"
+      end
+
+      def unframe_content(content)
+        frames = []
+        remaining_content = content
+        until remaining_content.empty?
+          msg_length = remaining_content[1..4].unpack1('N')
+          raise 'Invalid message length' if msg_length <= 0
+
+          frame_end = 5 + msg_length
+          frames << ::GRPCWeb::MessageFrame.new(
+            remaining_content[0].bytes[0],
+            remaining_content[5...frame_end],
+          )
+          remaining_content = remaining_content[frame_end..-1]
+        end
+        frames
+      end
+    end
+  end
+end

data/lib/grpc_web/message_serialization.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'grpc/core/status_codes'
+require 'grpc/errors'
+require 'grpc_web/content_types'
+require 'grpc_web/grpc_web_response'
+require 'grpc_web/grpc_web_request'
+require 'grpc_web/message_frame'
+
+module GRPCWeb::MessageSerialization
+  class << self
+    include ::GRPCWeb::ContentTypes
+
+    def deserialize_request(request)
+      service_class = request.service.class
+      request_proto_class = service_class.rpc_descs[request.service_method.to_sym].input
+      payload_frame = request.body.find(&:payload?)
+
+      if request.content_type == JSON_CONTENT_TYPE
+        request_proto = request_proto_class.decode_json(payload_frame.body)
+      else
+        request_proto = request_proto_class.decode(payload_frame.body)
+      end
+
+      ::GRPCWeb::GRPCWebRequest.new(
+        request.service,
+        request.service_method,
+        request.content_type,
+        request.accept,
+        request_proto,
+      )
+    end
+
+    def serialize_response(response)
+      if response.body.is_a?(Exception)
+        serialize_error_response(response)
+      else
+        serialize_success_response(response)
+      end
+    end
+
+    private
+
+    def serialize_success_response(response)
+      if response.content_type == JSON_CONTENT_TYPE
+        payload = response.body.to_json
+      else
+        payload = response.body.to_proto
+      end
+
+      header_str = generate_headers(::GRPC::Core::StatusCodes::OK, 'OK')
+      payload_frame = ::GRPCWeb::MessageFrame.payload_frame(payload)
+      header_frame = ::GRPCWeb::MessageFrame.header_frame(header_str)
+
+      ::GRPCWeb::GRPCWebResponse.new(response.content_type, [payload_frame, header_frame])
+    end
+
+    def serialize_error_response(response)
+      ex = response.body
+      if ex.is_a?(::GRPC::BadStatus)
+        header_str = generate_headers(ex.code, ex.details)
+      else
+        header_str = generate_headers(
+          ::GRPC::Core::StatusCodes::UNKNOWN,
+          "#{ex.class}: #{ex.message}",
+        )
+      end
+      header_frame = ::GRPCWeb::MessageFrame.header_frame(header_str)
+      ::GRPCWeb::GRPCWebResponse.new(response.content_type, [header_frame])
+    end
+
+    # If needed, trailers can be appended to the response as a 2nd
+    # base64 encoded string with independent framing.
+    def generate_headers(status, message)
+      header_str = [
+        "grpc-status:#{status}",
+        "grpc-message:#{message}",
+        'x-grpc-web:1',
+        nil, # for trailing newline
+      ].join("\r\n")
+    end
+  end
+end

data/lib/grpc_web/rack_app.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'rack/builder'
+require 'grpc_web/rack_handler'
+
+module GRPCWeb
+  class RackApp < ::Rack::Builder
+    # Can be given a service class, an instance of a service class, or a
+    # service interface class with a block to lazily initialize the service.
+    #
+    # Example 1:
+    #   app.handle(TestHelloService)
+    #
+    # Example 2:
+    #   app.handle(TestHelloService.new)
+    #
+    # Example 3:
+    #   app.handle(HelloService::Service) do
+    #     require 'test_hello_service'
+    #     TestHelloService.new
+    #   end
+    #
+    def handle(service_or_class, &lazy_init_block)
+      service_class = service_or_class.is_a?(Class) ? service_or_class : service_or_class.class
+      validate_service_class(service_class)
+      service_config = lazy_init_block || service_or_class
+
+      service_class.rpc_descs.keys.each do |service_method|
+        add_service_method_to_app(service_class.service_name, service_config, service_method)
+      end
+    end
+
+    private
+
+    def validate_service_class(clazz)
+      unless clazz.include?(::GRPC::GenericService)
+        raise(ArgumentError, "#{clazz} must 'include GenericService'")
+      end
+      if clazz.rpc_descs.size.zero?
+        raise(ArgumentError, "#{clazz} should specify some rpc descriptions")
+      end
+    end
+
+    # Map a path with Rack::Builder corresponding to the service method
+    def add_service_method_to_app(service_name, service_config, service_method)
+      map("/#{service_name}/#{service_method}") do
+        run(RouteHandler.new(service_config, service_method))
+      end
+    end
+
+    class RouteHandler
+      def initialize(service_config, service_method)
+        self.service_config = service_config
+        self.service_method = service_method
+      end
+
+      def call(env)
+        ::GRPCWeb::RackHandler.call(service, service_method, env)
+      end
+
+      private
+
+      attr_accessor :service_config, :service_method
+
+      def service
+        case service_config
+        when Proc
+          service_config.call
+        when Class
+          service_config.new
+        else
+          service_config
+        end
+      end
+    end
+  end
+end

data/lib/grpc_web/rack_handler.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'rack/request'
+require 'grpc_web/content_types'
+require 'grpc_web/error_callback'
+require 'grpc_web/grpc_request_processor'
+require 'grpc_web/grpc_web_request'
+
+module GRPCWeb
+  module RackHandler
+    NOT_FOUND = 404
+    UNSUPPORTED_MEDIA_TYPE = 415
+    INTERNAL_SERVER_ERROR = 500
+    POST = 'POST'
+    ACCEPT_HEADER = 'HTTP_ACCEPT'
+
+    class << self
+      include ::GRPCWeb::ContentTypes
+
+      def call(service, service_method, env)
+        rack_request = Rack::Request.new(env)
+        return not_found_response(rack_request.path) unless post?(rack_request)
+        return unsupported_media_type_response unless valid_content_types?(rack_request)
+
+        request_format = rack_request.content_type
+        accept = rack_request.get_header(ACCEPT_HEADER)
+        body = rack_request.body.read
+        request = GRPCWebRequest.new(service, service_method, request_format, accept, body)
+        response = GRPCRequestProcessor.process(request)
+
+        [200, { 'Content-Type' => response.content_type }, [response.body]]
+      rescue Google::Protobuf::ParseError => e
+        invalid_response(e.message)
+      rescue StandardError => e
+        ::GRPCWeb.on_error.call(e, service, service_method)
+        error_response
+      end
+
+      private
+
+      def post?(rack_request)
+        rack_request.request_method == POST
+      end
+
+      def valid_content_types?(rack_request)
+        return false unless ALL_CONTENT_TYPES.include?(rack_request.content_type)
+
+        accept = rack_request.get_header(ACCEPT_HEADER)
+        return true if ANY_CONTENT_TYPES.include?(accept)
+
+        ALL_CONTENT_TYPES.include?(accept)
+      end
+
+      def not_found_response(path)
+        [
+          NOT_FOUND,
+          { 'Content-Type' => 'text/plain', 'X-Cascade' => 'pass' },
+          ["Not Found: #{path}"],
+        ]
+      end
+
+      def unsupported_media_type_response
+        [
+          UNSUPPORTED_MEDIA_TYPE,
+          { 'Content-Type' => 'text/plain' },
+          ['Unsupported Media Type: Invalid Content-Type or Accept header'],
+        ]
+      end
+
+      def invalid_response(message)
+        [422, { 'Content-Type' => 'text/plain' }, ["Invalid request format: #{message}"]]
+      end
+
+      def error_response
+        [
+          INTERNAL_SERVER_ERROR,
+          { 'Content-Type' => 'text/plain' },
+          ['Request failed with an unexpected error.'],
+        ]
+      end
+    end
+  end
+end

data/lib/grpc_web/text_coder.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'grpc_web/content_types'
+require 'grpc_web/grpc_web_response'
+require 'grpc_web/grpc_web_request'
+
+module GRPCWeb::TextCoder
+  class << self
+    include ::GRPCWeb::ContentTypes
+
+    def decode_request(request)
+      return request unless BASE64_CONTENT_TYPES.include?(request.content_type)
+
+      # Body can be several base64 "chunks" concatenated together
+      base64_chunks = request.body.scan(%r{[a-zA-Z0-9+/]+={0,2}})
+      decoded = base64_chunks.map { |chunk| Base64.decode64(chunk) }.join
+      ::GRPCWeb::GRPCWebRequest.new(
+        request.service, request.service_method, request.content_type, request.accept, decoded,
+      )
+    end
+
+    def encode_response(response)
+      return response unless BASE64_CONTENT_TYPES.include?(response.content_type)
+
+      encoded = Base64.strict_encode64(response.body)
+      ::GRPCWeb::GRPCWebResponse.new(response.content_type, encoded)
+    end
+  end
+end

data/lib/grpc_web/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module GRPCWeb
+  VERSION = '1.0.0'
+end

metadata

@@ -0,0 +1,207 @@
+--- !ruby/object:Gem::Specification
+name: grpc-web
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- James Shkolnik
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-02-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: grpc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: apparition
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-cors
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.79.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.79.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Host gRPC-Web endpoints for Ruby gRPC services in a Rack or Rails app(over
+  HTTP/1.1). Client included.
+email:
+- js@gusto.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/grpc-web.rb
+- lib/grpc_web.rb
+- lib/grpc_web/client.rb
+- lib/grpc_web/client_executor.rb
+- lib/grpc_web/content_types.rb
+- lib/grpc_web/error_callback.rb
+- lib/grpc_web/grpc_request_processor.rb
+- lib/grpc_web/grpc_web_request.rb
+- lib/grpc_web/grpc_web_response.rb
+- lib/grpc_web/message_frame.rb
+- lib/grpc_web/message_framing.rb
+- lib/grpc_web/message_serialization.rb
+- lib/grpc_web/rack_app.rb
+- lib/grpc_web/rack_handler.rb
+- lib/grpc_web/text_coder.rb
+- lib/grpc_web/version.rb
+homepage: https://github.com/gusto/grpc-web-ruby
+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: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Host gRPC-Web endpoints for Ruby gRPC services in a Rack or Rails app(over
+  HTTP/1.1). Client included.
+test_files: []