twirp-on-rails 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1bb31fa12f51069d7d6e447901646dd1ebfdc657d59bc670fffc57f8f858b34e
+  data.tar.gz: 414f84e6b7b655fabad364721fc6ea31ee94300674303ff633b5bf49434610cd
+SHA512:
+  metadata.gz: 986ee79625c2cea727ebbb09b0efb0f110a5e64f3ce5d186dfd2786ceb35d48f88935a43335f4c6740144fa6023cc12107288554d2a3389f37bf3f6ad2b01f21
+  data.tar.gz: 68c86eb0918f123e6b96457944347893f96bdfbabe91c4c3f1bd8b0ae75c6eac3b590856f6156c3488ade4a58ebcc906dc566b8c255326da3eb89344796e4a5f

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.standard.yml

@@ -0,0 +1,4 @@
+ruby_version: 2.7
+plugins:
+  - standard-performance
+  - standard-rails

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2022-12-23
+
+- Initial release

data/Gemfile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in twirp-rails.gemspec
+gemspec
+
+gem "rake"
+
+gem "debug"
+gem "rspec-rails"
+gem "sqlite3", "~> 1.4"
+gem "standard"
+gem "standard-performance"
+gem "standard-rails"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022–2023 Collective Idea
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,173 @@
+[![CI](https://github.com/collectiveidea/twirp-rails/actions/workflows/ci.yml/badge.svg)](https://github.com/collectiveidea/twirp-rails/actions/workflows/ci.yml)
+[![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
+
+# Twirp on Rails (Twirp::Rails)
+
+## Motivation
+
+Make serving [Twirp](https://twitchtv.github.io/twirp/) RPC Services as easy and familiar as Rails controllers. Add a few helpful abstractions, but don't hide [Twirp](https://twitchtv.github.io/twirp/), [Protobufs](https://protobuf.dev), or make it seem too magical.
+
+Out of the box, the [`twirp` gem](http://github.com/github/twirp-ruby) makes it easy to add [Services](https://github.com/github/twirp-ruby/wiki/Service-Handlers), but it feels clunky coming from Rails REST-ful APIs. We make it simple to build full-featured APIs. Hook in authorization, use `before_action` and more.
+
+Extracted from a real, production application with many thousands of users.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add twirp-on-rails
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install twirp-on-rails
+
+## Usage
+
+Add to your `routes.rb`:
+
+```ruby
+mount Twirp::Rails::Engine, at: "/twirp"
+```
+
+### Configuration
+
+Twirp::Rails will automatically load any `*_twirp.rb` files in your app's `lib/` directory (and subdirectories). To modify the location, add this to an initializer: 
+
+```ruby 
+Rails.application.config.load_paths = ["lib", "app/twirp"]
+```
+
+## Features
+
+### Easy Routing
+
+Add one line to your `config/routes.rb` and routes are built automatically from your Twirp Services:
+
+```ruby
+mount Twirp::Rails::Engine, at: "/twirp"
+```
+
+`/twirp/twirp.example.haberdasher.HaberdasherService/MakeHat`
+
+These are routed to Handlers in `app/handlers/` based on expected naming conventions.
+
+For example if you have this service defined: 
+
+```protobuf
+package twirp.example.haberdasher;
+
+service HaberdasherService {
+   rpc MakeHat(Size) returns (Hat);
+ }
+```
+
+it will expect to find `app/handlers/haberdasher_service_handler.rb` with a `make_hat` method. 
+
+```ruby
+class HaberdasherServiceHandler < Twirp::Rails::Handler
+  def make_hat
+
+  end
+end
+```
+
+Each handler method should return the appropriate Protobuf, or a `Twirp::Error`.
+
+TODO: Give more examples of both
+
+### Familiar Callbacks
+
+Use `before_action`, `around_action`, and other callbacks you're used to, as we build on [AbstractController::Callbacks](https://api.rubyonrails.org/classes/AbstractController/Callbacks.html).
+
+### DRY Service Hooks
+
+Apply [Service Hooks](https://github.com/twitchtv/twirp-ruby/wiki/Service-Hooks) one time across multiple services.
+
+For example, we can add hooks in an initializer: 
+
+```ruby
+# Make IP address accessible to the handlers
+Rails.application.config.twirp.service_hooks[:before] = lambda do |rack_env, env|
+  env[:ip] = rack_env["REMOTE_ADDR"]
+end
+
+# Send exceptions to Honeybadger
+Rails.application.config.twirp.service_hooks[:exception_raised] = ->(exception, _env) { Honeybadger.notify(exception) }
+```
+
+### Middleware
+
+As an Engine, we avoid all the standard Rails middleware. That's nice for simplicity, but sometimes you want to add your own middleware. You can do that by specifying it in an initializer:
+
+```ruby
+Rails.application.config.twirp.middleware = [Rack::Deflater]
+```
+
+## Bonus Features
+
+Outside the [Twirp spec](https://twitchtv.github.io/twirp/docs/spec_v7.html), we have some (optional) extra magic. They might be useful to you, but you can easily ignore them too.
+
+### Basic Caching with ETags/If-None-Match Headers
+
+Like Rails GET actions, Twirp::Rails handlers add [`ETag` headers](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/ETag) based on the response's content.
+
+If you have RPCs that can be cached, you can have your Twirp clients send an [`If-None-Match` Header](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/If-None-Match). Twirp::Rails will return a `304 Not Modified` HTTP status and not re-send the body if the ETag matches.
+
+Enable by adding this to an initializer:
+
+```ruby
+Rails.application.config.twirp.middleware = [
+  Twirp::Rails::Rack::ConditionalPost,
+  Rack::ETag
+]
+```
+
+## TODO
+
+* More docs!
+* More tests!
+* installer generator to add `ApplicationHandler`
+    * Maybe a generator for individual handlers that adds that if needed?
+* Auto reload.
+* Make service hooks more configurable? Apply to one service instead of all?
+* Loosen Rails version requirement? Probably works, but haven't tested. 
+
+## Prior Art
+
+We evaluated all these projects and found them to be bad fits for us, for one reason or another. We're grateful to all for their work, and hope they continue and flourish. Some notes from our initial evaluation:
+
+[nikushi/twirp-rails](https://github.com/nikushi/twirp-rails)
+
+* Nice routing abstraction
+* Minimal Handler abstraction
+* Untouched for 4 years
+
+[cheddar-me/rails-twirp](https://github.com/cheddar-me/rails-twirp)
+
+* Too much setup.
+* Nice controllers, but expects you to use their [pbbuilder](https://github.com/cheddar-me/pbbuilder) which I find unnecessary.
+
+[severgroup-tt/twirp_rails-1](https://github.com/severgroup-tt/twirp_rails-1)
+
+* Some nice things
+* No Handler abstractions
+* Archived and not touched for 3 years
+
+[dudo/rails_respond_to_pb](https://github.com/dudo/rails_respond_to_pb)
+
+* Allows routing to existing controllers
+* I dislike the `respond_to` stuff. That shouldn't be something you think about. We have a better way to do that in other recent apps anyway.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/danielmorrison/twirp-rails.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "standard/rake"
+
+task default: %i[spec standard]

data/config/routes.rb

@@ -0,0 +1,11 @@
+Rails.application.routes.draw do
+  if Rails.application.config.twirp.auto_mount
+    mount Twirp::Rails::Engine => Rails.application.config.twirp.endpoint
+  end
+end
+
+Twirp::Rails::Engine.routes.draw do
+  Twirp::Rails.services.each do |service|
+    mount service, at: service.full_name
+  end
+end

data/lib/twirp/on/rails.rb

@@ -0,0 +1,3 @@
+# The gem _should_ put everyting in twirp/on/rails but I don't like "on"
+# being a directory, so this file just requires twirp/rails.rb.
+require_relative "../rails"

data/lib/twirp/rails/callbacks.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "active_support/callbacks"
+require "abstract_controller/callbacks"
+
+module Twirp
+  module Rails
+    # = Twirp Rails Callbacks
+    #
+    # Based on Abstract Controller Callbacks with the terminator changed.
+    #
+    # A before_action that returns a Twirp::Error will halt the action.
+    #
+    # Abstract Controller provides hooks during the life cycle of a controller action.
+    # Callbacks allow you to trigger logic during this cycle. Available callbacks are:
+    #
+    # * <tt>after_action</tt>
+    # * <tt>append_after_action</tt>
+    # * <tt>append_around_action</tt>
+    # * <tt>append_before_action</tt>
+    # * <tt>around_action</tt>
+    # * <tt>before_action</tt>
+    # * <tt>prepend_after_action</tt>
+    # * <tt>prepend_around_action</tt>
+    # * <tt>prepend_before_action</tt>
+    # * <tt>skip_after_action</tt>
+    # * <tt>skip_around_action</tt>
+    # * <tt>skip_before_action</tt>
+    #
+    # NOTE: Calling the same callback multiple times will overwrite previous callback definitions.
+    #
+    module Callbacks
+      extend ActiveSupport::Concern
+
+      include AbstractController::Callbacks
+
+      included do
+        define_callbacks :process_action,
+          terminator: ->(controller, result_lambda) {
+            # save off the error and terminate if a callback returns a Twirp::Error
+            result = result_lambda.call
+
+            if result.is_a?(Twirp::Error)
+              controller.error = result
+              true
+            else
+              false
+            end
+          },
+          skip_after_callbacks_if_terminated: true
+      end
+    end
+  end
+end

data/lib/twirp/rails/configuration.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Twirp
+  module Rails
+    class Configuration
+      # Whether to automatically mount routes at endpoint. Defaults to false
+      attr_accessor :auto_mount
+
+      # Where to mount twirp routes. Defaults to /twirp
+      attr_accessor :endpoint
+
+      # An array of directories to search for *_twirp.rb files
+      # Defaults to ["lib"]
+      attr_accessor :load_paths
+
+      # An array of Rack middleware to use
+      attr_accessor :middleware
+
+      # A hash of lambdas that accepts |rack_env, env| and is passed to Twirp::Service
+      # See: https://github.com/twitchtv/twirp-ruby/wiki/Service-Hooks
+      # for available hooks
+      attr_accessor :service_hooks
+
+      def initialize
+        @auto_mount = false
+        @endpoint = "/twirp"
+        @load_paths = ["lib"]
+        @middleware = []
+        @service_hooks = {}
+      end
+    end
+  end
+end

data/lib/twirp/rails/dispatcher.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Twirp
+  module Rails
+    class Dispatcher
+      def initialize(service_class)
+        @service_handler = "#{service_class.service_name}Handler".constantize
+      end
+
+      def respond_to_missing?(method, *)
+        true
+      end
+
+      def method_missing(name, *args)
+        request = args[0]
+        env = args[1]
+        @service_handler.new.process(name, request, env)
+      end
+    end
+  end
+end

data/lib/twirp/rails/engine.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "rails/engine"
+require "rack/etag"
+require_relative "rack/conditional_post"
+
+module Twirp
+  module Rails
+    class Engine < ::Rails::Engine
+      isolate_namespace Twirp::Rails
+      engine_name "twirp"
+      # endpoint MyRackApplication
+      # # Add a load path for this specific Engine
+      # config.autoload_paths << File.expand_path("lib/some/path", __dir__)
+
+      config.twirp = Configuration.new
+
+      initializer "twirp.configure.defaults", before: "twirp.configure" do |app|
+        twirp = app.config.twirp
+        # twirp.auto_mount = true if twirp.auto_mount.nil?
+        twirp.load_paths ||= ["lib"]
+      end
+
+      initializer "twirp.configure" do |app|
+        [:auto_mount, :endpoint, :load_paths, :middleware, :service_hooks].each do |key|
+          app.config.twirp.send(key)
+        end
+
+        app.config.twirp.middleware.each do |middleware|
+          app.config.middleware.use middleware
+        end
+      end
+    end
+
+    class << self
+      def services
+        if @services.nil?
+          ::Rails.application.config.twirp.load_paths.each do |directory|
+            ::Rails.root.glob("#{directory}/**/*_twirp.rb").sort.each { |file| require file }
+          end
+
+          @services = Twirp::Service.subclasses.map(&:new)
+
+          # Install hooks that may be defined in the config
+          @services.each do |service|
+            ::Rails.application.config.twirp.service_hooks.each do |hook_name, hook|
+              service.send(hook_name, &hook)
+            end
+          end
+        end
+
+        @services
+      end
+    end
+  end
+end
+
+class Twirp::Service
+  # Override inspect to show all available RPCs
+  # This is used when displaying routes.
+  def inspect
+    self.class.rpcs.map { |rpc| "#{self.class.name.demodulize.underscore}_handler##{rpc[1][:ruby_method]}" }.join("\n")
+  end
+end

data/lib/twirp/rails/handler.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Twirp
+  module Rails
+    class Handler
+      include Twirp::Rails::Callbacks
+
+      attr_reader :request, :env
+      attr_reader :action_name
+      attr_accessor :error
+
+      # @param name [Symbol] The method name to invoke in the handler
+      # @param request [Object] The protobuf message request parameter
+      # @param env [Hash] The Twirp environment
+      def process(name, request, env)
+        @request = request
+        @env = env
+        @error = nil
+        @action_name = name.to_s
+
+        response = process_action(action_name)
+        error || response
+      end
+
+      private
+
+      # Call the action. Override this in a subclass to modify the
+      # behavior around processing an action. This, and not #process,
+      # is the intended way to override action dispatching.
+      #
+      # Notice that the first argument is the method to be dispatched
+      # which is *not* necessarily the same as the action name.
+      def process_action(name)
+        ActiveSupport::Notifications.instrument("handler_run_callbacks.twirp_rails", handler: self.class.name, action: action_name, env: @env, request: @request) do
+          run_callbacks(:process_action) do
+            ActiveSupport::Notifications.instrument("handler_run.twirp_rails", handler: self.class.name, action: action_name, env: @env, request: @request) do |payload|
+              payload[:response] = send_action(name)
+            end
+          end
+        end
+      end
+
+      # Actually call the method associated with the action. Override
+      # this method if you wish to change how action methods are called,
+      # not to add additional behavior around it. For example, you would
+      # override #send_action if you want to inject arguments into the
+      # method.
+      alias_method :send_action, :send
+    end
+  end
+end

data/lib/twirp/rails/rack/conditional_post.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "rack/conditional_get"
+
+module Twirp
+  module Rails
+    module Rack
+      # Middleware that enables conditional POST using If-None-Match and
+      # If-Modified-Since. The application should set either or both of the
+      # Last-Modified or Etag response headers according to RFC 2616. When
+      # either of the conditions is met, the response body is set to be zero
+      # length and the response status is set to 304 Not Modified.
+      #
+      # Applications that defer response body generation until the body's each
+      # message is received will avoid response body generation completely when
+      # a conditional POST matches.
+      #
+      # Based on Rack::ConditionalGet
+      #
+      # Twirp requests are, be design, always POST.
+      # We want the logic of Rack::ConditionalGet but applied to POSTs.
+      #
+      # Not all Twirp calls are idemtpotent, so it is left up to the client
+      # to know when 304 Not Modified responses are desirable, and send the
+      # appropriate header(s).
+      class ConditionalPost < ::Rack::ConditionalGet
+        # Return empty 304 response if the response has not been
+        # modified since the last request.
+        def call(env)
+          case env[::Rack::REQUEST_METHOD]
+          when "POST"
+            status, headers, body = @app.call(env)
+            headers = ::Rack::Utils::HeaderHash[headers]
+            if status == 200 && fresh?(env, headers)
+              status = 304
+              headers.delete(::Rack::CONTENT_TYPE)
+              headers.delete(::Rack::CONTENT_LENGTH)
+              original_body = body
+              body = ::Rack::BodyProxy.new([]) do
+                original_body.close if original_body.respond_to?(:close)
+              end
+            end
+            [status, headers, body]
+          else
+            @app.call(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twirp/rails/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Twirp
+  module Rails
+    VERSION = "1.0.0"
+  end
+end

data/lib/twirp/rails.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "rails/version"
+
+module Twirp
+  module Rails
+    class Error < StandardError; end
+    # Your code goes here...
+  end
+end
+
+require "twirp"
+require "active_support/notifications"
+require_relative "rails/callbacks"
+require_relative "rails/configuration"
+require_relative "rails/dispatcher"
+require_relative "rails/engine"
+require_relative "rails/handler"
+
+module Twirp
+  class Service
+    # Override initialize to make handler argument optional.
+    # When left nil, we will use our dispatcher.
+    alias_method :original_initialize, :initialize
+    def initialize(handler = nil)
+      handler ||= Twirp::Rails::Dispatcher.new(self.class)
+      original_initialize(handler)
+    end
+  end
+end

data/sig/twirp/rails.rbs

@@ -0,0 +1,6 @@
+module Twirp
+  module Rails
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

data/twirp-rails.gemspec

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "lib/twirp/rails/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "twirp-on-rails"
+  spec.version = Twirp::Rails::VERSION
+  spec.authors = ["Daniel Morrison", "Darron Schall"]
+  spec.email = ["info@collectiveidea.com"]
+
+  spec.summary = "Use Twirp RPC with Rails"
+  spec.description = "A simple way to serve Twirp RPC services in a Rails app. Minimial configuration and familiar Rails conventions."
+  spec.homepage = "https://github.com/collectiveidea/twirp-rails"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.7.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/collectiveidea/twirp-rails"
+  spec.metadata["changelog_uri"] = "https://github.com/collectiveidea/twirp-rails/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rails", ">= 7.0.0"
+  spec.add_dependency "twirp", ">= 1.8.0"
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: twirp-on-rails
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Daniel Morrison
+- Darron Schall
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-05-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+- !ruby/object:Gem::Dependency
+  name: twirp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+description: A simple way to serve Twirp RPC services in a Rails app. Minimial configuration
+  and familiar Rails conventions.
+email:
+- info@collectiveidea.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".standard.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- config/routes.rb
+- lib/twirp/on/rails.rb
+- lib/twirp/rails.rb
+- lib/twirp/rails/callbacks.rb
+- lib/twirp/rails/configuration.rb
+- lib/twirp/rails/dispatcher.rb
+- lib/twirp/rails/engine.rb
+- lib/twirp/rails/handler.rb
+- lib/twirp/rails/rack/conditional_post.rb
+- lib/twirp/rails/version.rb
+- sig/twirp/rails.rbs
+- twirp-rails.gemspec
+homepage: https://github.com/collectiveidea/twirp-rails
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/collectiveidea/twirp-rails
+  source_code_uri: https://github.com/collectiveidea/twirp-rails
+  changelog_uri: https://github.com/collectiveidea/twirp-rails/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.9
+signing_key:
+specification_version: 4
+summary: Use Twirp RPC with Rails
+test_files: []