rails_twirp 0.2.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4aa4bf745efcab88ddcf8cc58f6bf76e482901d37c8736102a5c32a6f20d0892
-  data.tar.gz: 8d6dbf635e44bf444d16d2eeaa7046a53027767745972a7add35e204ae73eaec
+  metadata.gz: 0ed88410115867b689de324aeaf99b91ba473d3aa573915d9bec5de1142b7986
+  data.tar.gz: dadc45ad3c6ed38f6791e8a45573127c69297772a7b0ae4861a2867dadf26d09
 SHA512:
-  metadata.gz: b48547bdb5e77c0c508f1e5dcdce7b01a692d94ce79aac38f837b0397adb696a6f68d36f116e02221ed24c04152b8fb3cdb77072bfbda81fe4b5247bcf359c1e
-  data.tar.gz: e4ed631582628257e281c78201177f351a6855f9bb9ebdfe6bb3ca0bc52349a59f56995cbcaa8c781640308bd4f032cd8fee7d5bc18191bb239082874379e2bc
+  metadata.gz: 976f3755035c22c65db62aa4b82e8019bf816e5e30cec968e19c5345630aa1b7c6d51d38439e267fde4d9696ce05667c5a2ed2566953bbe87a175ac2ea9df93f
+  data.tar.gz: f3c1460d7cd0ae988e8aabbb516afd1983b975e8aee872f295eb3017061a51500667ee1ecbd226f2260c03f179ad94560227710fc98095e0e60749288271d406

data/.github/workflows/test.yml

@@ -0,0 +1,21 @@
+name: Ruby Test
+on: push
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.0.0
+          bundler-cache: true
+
+      - name: Run tests
+        run: bin/test
+
+      - name: Run standardrb
+        run: bundle exec standardrb

data/.gitignore

@@ -11,3 +11,4 @@
 .byebug_history
 Gemfile.lock
 *.gem
+/.idea

data/.standard.yml

@@ -0,0 +1,4 @@
+ignore:
+  - 'test/dummy/proto/*'
+  - '**/*':
+    - Lint/RescueException

data/Gemfile

@@ -1,8 +1,8 @@
 source "https://rubygems.org"
-git_source(:github) { |repo| "https://github.com/#{repo}.git" }
 
 # Specify your gem's dependencies in rails_twirp.gemspec.
 gemspec
 
-# To use a debugger
-# gem 'byebug', group: [:development, :test]
+gem "sqlite3"
+gem "pbbuilder", "~> 0.3.0"
+gem "standard"

data/lib/rails_twirp.rb

@@ -1,8 +1,10 @@
 require "rails_twirp/version"
 
+require "rails_twirp/application"
 require "rails_twirp/base"
 require "rails_twirp/route_set"
 require "rails_twirp/testing/integration_test"
+require "rails_twirp/log_subscriber"
 
 module RailsTwirp
   mattr_accessor :test_app

data/lib/rails_twirp/base.rb

@@ -1,13 +1,41 @@
+require "abstract_controller/base"
+require "abstract_controller/rendering"
+require "action_view/rendering"
+require "rails_twirp/render_pb"
+require "rails_twirp/errors"
+require "abstract_controller/asset_paths"
+require "abstract_controller/caching"
+require "abstract_controller/logger"
+require "abstract_controller/callbacks"
+require "action_controller/metal/helpers"
+require "rails_twirp/rescue"
+require "rails_twirp/url_for"
+require "rails_twirp/implicit_render"
+require "rails_twirp/instrumentation"
+
 module RailsTwirp
   class Base < AbstractController::Base
     abstract!
 
-    include AbstractController::Logger
+    # The order of these includes matter.
+    # The rendering modules extend each other, so need to be in this order.
+    include AbstractController::Rendering
+
+    # These add helpers for the controller
+    include ActionController::Helpers
+    include UrlFor
     include AbstractController::AssetPaths
-    include AbstractController::Callbacks
     include AbstractController::Caching
-    include AbstractController::Rendering
+
     include ActionView::Rendering
+    include RenderPb
+    include Errors
+    include ImplicitRender
+
+    # These need to be last so errors can be handled as early as possible.
+    include AbstractController::Callbacks
+    include Rescue
+    include Instrumentation
 
     attr_internal :request, :env, :response_class
     def initialize
@@ -30,21 +58,18 @@ module RailsTwirp
 
       process(action)
 
-      # Implicit render
-      self.response_body = render unless response_body
       response_body
     end
 
-    def render(*args)
-      options = {formats: :pb, handlers: :pbbuilder, locals: {response_class: response_class}}
-      options.deep_merge! args.extract_options!
-      super(*args, options)
-    end
-
     def self.dispatch(action, request, response_class, env = {})
       new.dispatch(action, request, response_class, env)
     end
 
+    # Used by the template renderer to figure out which template to use
+    def details_for_lookup
+      {formats: [:pb], handlers: [:pbbuilder]}
+    end
+
     ActiveSupport.run_load_hooks(:rails_twirp, self)
   end
 end

data/lib/rails_twirp/engine.rb

@@ -1,5 +1,6 @@
-require "rails/railtie"
 require "rails_twirp/application"
+require "rails_twirp/route_set"
+require "rails/railtie"
 
 module RailsTwirp
   # Even though this is an engine, we don't inherit from Rails::Engine because we don't want anything it provides.
@@ -14,20 +15,38 @@ module RailsTwirp
     end
 
     initializer "rails_twirp.logger" do
-      # This hook is called whenever a RailsTwirp::Base is initialized, and it sets the logger
+      # This hook is called when RailsTwirp::Base is initialized, and it sets the logger
       ActiveSupport.on_load(:rails_twirp) { self.logger ||= Rails.logger }
     end
 
     initializer :add_paths, before: :bootstrap_hook do |app|
       app.config.paths.add "config/twirp/routes.rb"
       app.config.paths.add "config/twirp/routes", glob: "**/*.rb"
-      app.config.paths.add "app/twirp/controllers", eager_load: true
       app.config.paths.add "proto", load_path: true
-      app.config.paths.add "app/twirp/views", load_path: true
     end
 
-    initializer :set_controller_view_path do
-      ActiveSupport.on_load(:rails_twirp) { prepend_view_path "app/twirp/views" }
+    initializer :set_controller_view_path do |app|
+      views = app.config.paths["app/views"].existent
+      unless views.empty?
+        ActiveSupport.on_load(:rails_twirp) { prepend_view_path views }
+      end
+    end
+
+    initializer "rails_twirp.helpers" do |app|
+      ActiveSupport.on_load(:rails_twirp) do
+        # Load all the application helpers into the controller
+        include app.routes.mounted_helpers
+        extend ::AbstractController::Railties::RoutesHelpers.with(app.routes, false)
+        extend ::ActionController::Railties::Helpers
+        define_singleton_method(:inherited) do |klass|
+          super(klass)
+
+          # Have to call this explicitely, because ::ActionController::Railties::Helpers
+          # checks if ActionController::Base is a parent class, which it isn't.
+          # If we don't call this, the helpers don't get loaded
+          klass.helper :all
+        end
+      end
     end
 
     initializer :add_twirp do |app|
@@ -37,11 +56,12 @@ module RailsTwirp
 
     initializer :load_twirp_routes do |app|
       # Load route files
-      route_configs = [
+      [
         *app.config.paths["config/twirp/routes.rb"].existent,
         *app.config.paths["config/twirp/routes"].existent
-      ]
-      load(*route_configs)
+      ].each do |path|
+        load path
+      end
 
       # Create a router that knows how to route all the registered services
       services = app.twirp.routes.to_services

data/lib/rails_twirp/errors.rb

@@ -0,0 +1,11 @@
+require "twirp/error"
+
+module RailsTwirp
+  module Errors
+    # Helper that sets the response to a Twirp Error
+    # The valid error codes can be found in Twirp::ERROR_CODES
+    def error(code, message, meta = nil)
+      self.response_body = Twirp::Error.new(code, message, meta)
+    end
+  end
+end

data/lib/rails_twirp/implicit_render.rb

@@ -0,0 +1,11 @@
+require "action_controller/metal/basic_implicit_render"
+
+module RailsTwirp
+  module ImplicitRender
+    include ActionController::BasicImplicitRender
+
+    def default_render
+      render
+    end
+  end
+end

data/lib/rails_twirp/instrumentation.rb

@@ -0,0 +1,32 @@
+module RailsTwirp
+  module Instrumentation
+    extend ActiveSupport::Concern
+
+    include AbstractController::Logger
+
+    def process_action(*)
+      raw_payload = {
+        controller: self.class.name,
+        action: action_name,
+        request: request,
+        http_request: http_request,
+        headers: http_request.headers,
+        path: http_request.fullpath
+      }
+
+      ActiveSupport::Notifications.instrument("start_processing.rails_twirp", raw_payload)
+
+      ActiveSupport::Notifications.instrument("process_action.rails_twirp", raw_payload) do |payload|
+        result = super
+        if response_body.is_a?(Twirp::Error)
+          payload[:code] = response_body.code
+          payload[:msg] = response_body.msg
+        else
+          payload[:code] = :success
+        end
+        payload[:response] = response_body
+        result
+      end
+    end
+  end
+end

data/lib/rails_twirp/log_subscriber.rb

@@ -0,0 +1,64 @@
+require "active_support/log_subscriber"
+
+module RailsTwirp
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def start_processing(event)
+      return unless logger.info?
+
+      payload = event.payload
+
+      info "Processing by #{payload[:controller]}##{payload[:action]}"
+    end
+
+    def process_action(event)
+      payload = event.payload
+      exception_raised(payload[:http_request], payload[:exception_object]) if payload[:exception_object]
+
+      info do
+        code = payload.fetch(:code, :internal)
+
+        message = +"Completed #{code} in #{event.duration.round}ms (Allocations: #{event.allocations})"
+        message << "\n\n" if defined?(Rails.env) && Rails.env.development?
+
+        message
+      end
+    end
+
+    private
+
+    def exception_raised(request, exception)
+      backtrace_cleaner = request.get_header("action_dispatch.backtrace_cleaner")
+      wrapper = ActionDispatch::ExceptionWrapper.new(backtrace_cleaner, exception)
+
+      log_error(wrapper)
+    end
+
+    def log_error(wrapper)
+      exception = wrapper.exception
+      trace = wrapper.exception_trace
+
+      message = []
+      message << "  "
+      message << "#{exception.class} (#{exception.message}):"
+      message.concat(exception.annotated_source_code) if exception.respond_to?(:annotated_source_code)
+      message << "  "
+      message.concat(trace)
+
+      log_array(message)
+    end
+
+    def log_array(array)
+      lines = Array(array)
+
+      return if lines.empty?
+
+      if logger.formatter&.respond_to?(:tags_text)
+        fatal { lines.join("\n#{logger.formatter.tags_text}") }
+      else
+        fatal { lines.join("\n") }
+      end
+    end
+  end
+end
+
+RailsTwirp::LogSubscriber.attach_to :rails_twirp

data/lib/rails_twirp/mapper.rb

@@ -0,0 +1,83 @@
+require "forwardable"
+
+module RailsTwirp
+  class ServiceMapper
+    class Mapping
+      attr_reader :controller, :action
+
+      def initialize(to:, **options)
+        controller, @action = split_to(to)
+        @controller = add_controller_module(controller, options.delete(:module))
+        raise ArgumentError, "Unknown argument #{options.keys.first}" unless options.empty?
+      end
+
+      def to_s
+        "#{controller}##{action}"
+      end
+
+      private
+
+      # copied from Rails
+      def split_to(to)
+        if /#/.match?(to)
+          to.split("#").map!(&:-@)
+        else
+          []
+        end
+      end
+
+      def add_controller_module(controller, modyoule)
+        return controller unless modyoule
+
+        if controller&.start_with?("/")
+          -controller[1..]
+        else
+          -[modyoule, controller].compact.join("/")
+        end
+      end
+    end
+
+    extend Forwardable
+    def_delegator :@mapper, :scope
+
+    def initialize(service_route_set, mapper)
+      @service_route_set = service_route_set
+      @mapper = mapper
+    end
+
+    def rpc(name, to:)
+      mapping = Mapping.new(to: to, module: @mapper.send(:_module))
+      @service_route_set.add_route(name, mapping)
+    end
+  end
+
+  class Mapper
+    def initialize(route_set)
+      @route_set = route_set
+      @module = nil
+    end
+
+    def service(service_definition, **options, &block)
+      service_route_set = @route_set.services[service_definition]
+      service_mapper = ServiceMapper.new(service_route_set, self)
+      scope(**options) { service_mapper.instance_exec(&block) }
+    end
+
+    def scope(**options)
+      last_module = @module
+      if (modyoule = options.delete(:module))
+        @module = @module.nil? ? modyoule : "#{@module}/#{modyoule}"
+      end
+      raise ArgumentError, "Unknown scope argument #{options.keys.first}" unless options.empty?
+      yield
+    ensure
+      @module = last_module
+    end
+
+    private
+
+    def _module
+      @module
+    end
+  end
+end

data/lib/rails_twirp/render_pb.rb

@@ -0,0 +1,18 @@
+module RailsTwirp
+  # RenderPb makes it possible to do 'render pb: <proto object>', skipping templates
+  # The way this module is written is inspired by ActionController::Renderers
+  module RenderPb
+    def render_to_body(options)
+      _render_to_body_with_pb(options) || super
+    end
+
+    def _render_to_body_with_pb(options)
+      if options.include? :pb
+        _process_options(options)
+        return options[:pb]
+      end
+
+      nil
+    end
+  end
+end

data/lib/rails_twirp/rescue.rb

@@ -0,0 +1,14 @@
+module RailsTwirp
+  module Rescue
+    extend ActiveSupport::Concern
+    include ActiveSupport::Rescuable
+
+    private
+
+    def process_action(*)
+      super
+    rescue Exception => exception
+      rescue_with_handler(exception) || raise
+    end
+  end
+end