rage-rb 1.6.0 → 1.8.0

data/lib/rage/cable/router.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+class Rage::Cable::Router
+  # @private
+  def initialize
+    # Hash<String(channel name) => Proc(new channel instance)>
+    @channels_map = {}
+    init_connection_class
+  end
+
+  # Calls the `connect` method on the `Connection` class to handle authentication.
+  #
+  # @param connection [Rage::Cable::WebSocketConnection] the connection object
+  # @return [true] if the connection was accepted
+  # @return [false] if the connection was rejected
+  def process_connection(connection)
+    cable_connection = @connection_class.new(connection.env)
+    cable_connection.connect
+
+    if cable_connection.rejected?
+      Rage.logger.debug { "An unauthorized connection attempt was rejected" }
+    else
+      connection.env["rage.identified_by"] = cable_connection.__identified_by_map
+      connection.env["rage.cable"] = {}
+    end
+
+    !cable_connection.rejected?
+  end
+
+  # Calls the `subscribed` method on the specified channel.
+  #
+  # @param connection [Rage::Cable::WebSocketConnection] the connection object
+  # @param identifier [String] the identifier of the subscription
+  # @param channel_name [String] the name of the channel class
+  # @param params [Hash] the params hash associated with the subscription
+  #
+  # @return [:invalid] if the subscription class does not exist
+  # @return [:rejected] if the subscription was rejected
+  # @return [:subscribed] if the subscription was accepted
+  def process_subscription(connection, identifier, channel_name, params)
+    channel_class = @channels_map[channel_name] || begin
+      begin
+        klass = Object.const_get(channel_name)
+      rescue NameError
+        nil
+      end
+
+      if klass.nil? || !klass.ancestors.include?(Rage::Cable::Channel)
+        Rage.logger.debug { "Subscription class not found: #{channel_name}" }
+        return :invalid
+      end
+
+      klass.__register_actions.tap do |available_actions|
+        Rage.logger.debug { "Compiled #{channel_name}. Available remote actions: #{available_actions}." }
+      end
+
+      @channels_map[channel_name] = klass
+    end
+
+    channel = channel_class.new(connection, params, connection.env["rage.identified_by"])
+    channel.__run_action(:subscribed)
+
+    if channel.subscription_rejected?
+      Rage.logger.debug { "#{channel_name} is transmitting the subscription rejection" }
+      # if the subscription is rejected in the `subscribed` method, ActionCable will additionally run
+      # the `unsubscribed` method; this makes little sense to me as the client was never subscribed in
+      # the first place; additionally, I don't think this behaviour is documented anywhere;
+      # so, I'm going to leave this line commented out for now;
+      # channel.__run_action(:unsubscribed)
+      :rejected
+    else
+      Rage.logger.debug { "#{channel_name} is transmitting the subscription confirmation" }
+      connection.env["rage.cable"][identifier] = channel
+      :subscribed
+    end
+  end
+
+  # Calls the handler method on the specified channel.
+  #
+  # @param connection [Rage::Cable::WebSocketConnection] the connection object
+  # @param identifier [String] the identifier of the subscription
+  # @param action_name [Symbol] the name of the handler method
+  # @param data [Object] the data sent by the client
+  #
+  # @return [:no_subscription] if the client is not subscribed to the specified channel
+  # @return [:unknown_action] if the action does not exist on the specified channel
+  # @return [:processed] if the message has been successfully processed
+  def process_message(connection, identifier, action_name, data)
+    channel = connection.env["rage.cable"][identifier]
+    unless channel
+      Rage.logger.debug { "Unable to find the subscription" }
+      return :no_subscription
+    end
+
+    if channel.__has_action?(action_name)
+      channel.__run_action(action_name, data)
+      :processed
+    else
+      Rage.logger.debug { "Unable to process #{channel.class.name}##{action_name}" }
+      :unknown_action
+    end
+  end
+
+  # Runs the `unsubscribed` methods on all the channels the client is subscribed to.
+  #
+  # @param connection [Rage::Cable::WebSocketConnection] the connection object
+  def process_disconnection(connection)
+    connection.env["rage.cable"]&.each do |_, channel|
+      channel.__run_action(:unsubscribed)
+    end
+
+    if @connection_can_disconnect
+      cable_connection = @connection_class.new(connection.env, connection.env["rage.identified_by"])
+      cable_connection.disconnect
+    end
+  end
+
+  # @private
+  def reset
+    @channels_map.clear
+    init_connection_class
+  end
+
+  private
+
+  def init_connection_class
+    @connection_class = if Object.const_defined?("RageCable::Connection")
+      RageCable::Connection
+    elsif Object.const_defined?("ApplicationCable::Connection")
+      ApplicationCable::Connection
+    else
+      puts "WARNING: Could not find the RageCable connection class! All connections will be accepted by default."
+      Rage::Cable::Connection
+    end
+
+    @connection_can_disconnect = @connection_class.method_defined?(:disconnect)
+  end
+end

data/lib/rage/cli.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "thor"
 require "rack"
 
@@ -40,7 +41,7 @@ module Rage
       ::Iodine.start
     end
 
-    desc 'routes', 'List all routes.'
+    desc "routes", "List all routes."
     option :grep, aliases: "-g", desc: "Filter routes by pattern"
     option :help, aliases: "-h", desc: "Show this message."
     def routes

data/lib/rage/code_loader.rb

@@ -30,8 +30,13 @@ class Rage::CodeLoader
 
     @reloading = true
     @loader.reload
+
     Rage.__router.reset_routes
     load("#{Rage.root}/config/routes.rb")
+
+    unless Rage.autoload?(:Cable) # the `Cable` component is loaded
+      Rage::Cable.__router.reset
+    end
   end
 
   # in Rails mode - reset the routes; everything else will be done by Rails
@@ -40,6 +45,10 @@ class Rage::CodeLoader
 
     @reloading = true
     Rage.__router.reset_routes
+
+    unless Rage.autoload?(:Cable) # the `Cable` component is loaded
+      Rage::Cable.__router.reset
+    end
   end
 
   def reloading?

data/lib/rage/configuration.rb

@@ -1,6 +1,15 @@
 # frozen_string_literal: true
 
 ##
+# `Rage.configure` can be used to adjust the behavior of your Rage application:
+#
+# ```ruby
+# Rage.configure do
+#   config.logger = Rage::Logger.new(STDOUT)
+#   config.server.workers_count = 2
+# end
+# ```
+#
 # # General Configuration
 #
 # • _config.logger_
@@ -93,6 +102,20 @@
 #
 # > Specifies connection timeout.
 #
+# # Cable Configuration
+#
+# • _config.cable.protocol_
+#
+# > Specifies the protocol the server will use. The only value currently supported is `Rage::Cable::Protocol::ActioncableV1Json`. The client application will need to use [@rails/actioncable](https://www.npmjs.com/package/@rails/actioncable) to talk to the server.
+#
+# • _config.cable.allowed_request_origins_
+#
+# > Restricts the server to only accept requests from specified origins. The origins can be instances of strings or regular expressions, against which a check for the match will be performed.
+#
+# • _config.cable.disable_request_forgery_protection_
+#
+# > Allows requests from any origin.
+#
 # # Transient Settings
 #
 # The settings described in this section should be configured using **environment variables** and are either temporary or will become the default in the future.
@@ -138,6 +161,10 @@ class Rage::Configuration
     @middleware ||= Middleware.new
   end
 
+  def cable
+    @cable ||= Cable.new
+  end
+
   def internal
     @internal ||= Internal.new
   end
@@ -193,6 +220,32 @@ class Rage::Configuration
     end
   end
 
+  class Cable
+    attr_accessor :protocol, :allowed_request_origins, :disable_request_forgery_protection
+
+    def initialize
+      @protocol = Rage::Cable::Protocol::ActioncableV1Json
+      @allowed_request_origins = if Rage.env.development? || Rage.env.test?
+        /localhost/
+      end
+    end
+
+    # @private
+    def middlewares
+      @middlewares ||= begin
+        origin_middleware = if @disable_request_forgery_protection
+          []
+        else
+          [[Rage::OriginValidator, Array(@allowed_request_origins), nil]]
+        end
+
+        origin_middleware + Rage.config.middleware.middlewares.reject do |middleware, _, _|
+          middleware == Rage::FiberWrapper
+        end
+      end
+    end
+  end
+
   # @private
   class Internal
     attr_accessor :rails_mode

data/lib/rage/controller/api.rb

@@ -7,6 +7,7 @@ class RageController::API
     # registering means defining a new method which calls the action, makes additional calls (e.g. before actions) and
     # sends a correct response down to the server;
     # returns the name of the newly defined method;
+    # rubocop:disable Layout/IndentationWidth, Layout/EndAlignment, Layout/HeredocIndentation
     def __register_action(action)
       raise Rage::Errors::RouterError, "The action '#{action}' could not be found for #{self}" unless method_defined?(action)
 
@@ -65,7 +66,7 @@ class RageController::API
         lines = @__rescue_handlers.map do |klasses, handler|
           <<~RUBY
           rescue #{klasses.join(", ")} => __e
-            #{handler}(__e)
+            #{instance_method(handler).arity == 0 ? handler : "#{handler}(__e)"}
             [@__status, @__headers, @__body]
           RUBY
         end
@@ -77,7 +78,24 @@ class RageController::API
 
       activerecord_loaded = defined?(::ActiveRecord)
 
-      class_eval <<~RUBY,  __FILE__, __LINE__ + 1
+      wrap_parameters_chunk = if __wrap_parameters_key
+        <<~RUBY
+          wrap_key = self.class.__wrap_parameters_key
+          if !@__params.key?(wrap_key) && @__env["CONTENT_TYPE"]
+            wrap_options = self.class.__wrap_parameters_options
+            wrapped_params = if wrap_options[:include].any?
+                               @__params.slice(*wrap_options[:include])
+                             else
+                               params_to_exclude_by_default = %i[action controller]
+                               @__params.except(*(wrap_options[:exclude] + params_to_exclude_by_default))
+                             end
+
+            @__params[wrap_key] = wrapped_params
+          end
+        RUBY
+      end
+
+      class_eval <<~RUBY, __FILE__, __LINE__ + 1
         def __run_#{action}
           #{if activerecord_loaded
             <<~RUBY
@@ -85,6 +103,7 @@ class RageController::API
             RUBY
           end}
 
+          #{wrap_parameters_chunk}
           #{before_actions_chunk}
           #{action}
 
@@ -119,9 +138,12 @@ class RageController::API
         end
       RUBY
     end
+    # rubocop:enable all
 
     # @private
     attr_writer :__before_actions, :__after_actions, :__rescue_handlers
+    # @private
+    attr_accessor :__wrap_parameters_key, :__wrap_parameters_options
 
     # @private
     # pass the variable down to the child; the child will continue to use it until changes need to be made;
@@ -130,6 +152,8 @@ class RageController::API
       klass.__before_actions = @__before_actions.freeze
       klass.__after_actions = @__after_actions.freeze
       klass.__rescue_handlers = @__rescue_handlers.freeze
+      klass.__wrap_parameters_key = __wrap_parameters_key
+      klass.__wrap_parameters_options = __wrap_parameters_options
     end
 
     # @private
@@ -151,18 +175,17 @@ class RageController::API
     # Register a global exception handler. Handlers are inherited and matched from bottom to top.
     #
     # @param klasses [Class, Array<Class>] exception classes to watch on
-    # @param with [Symbol] the name of a handler method. The method must take one argument, which is the raised exception. Alternatively, you can pass a block, which must also take one argument.
+    # @param with [Symbol] the name of a handler method. Alternatively, you can pass a block.
     # @example
     #   rescue_from User::NotAuthorized, with: :deny_access
     #
-    #   def deny_access(exception)
+    #   def deny_access
     #     head :forbidden
     #   end
     # @example
-    #   rescue_from User::NotAuthorized do |_|
-    #     head :forbidden
+    #   rescue_from User::NotAuthorized do |exception|
+    #     render json: { message: exception.message }, status: :forbidden
     #   end
-    # @note Unlike in Rails, the handler must always take an argument. Use `_` if you don't care about the actual exception.
     def rescue_from(*klasses, with: nil, &block)
       unless with
         if block_given?
@@ -183,7 +206,7 @@ class RageController::API
 
     # Register a new `before_action` hook. Calls with the same `action_name` will overwrite the previous ones.
     #
-    # @param action_name [String, nil] the name of the callback to add
+    # @param action_name [Symbol, nil] the name of the callback to add
     # @param [Hash] opts action options
     # @option opts [Symbol, Array<Symbol>] :only restrict the callback to run only for specific actions
     # @option opts [Symbol, Array<Symbol>] :except restrict the callback to run for all actions except specified
@@ -215,7 +238,7 @@ class RageController::API
 
       if @__before_actions.nil?
         @__before_actions = [action]
-      elsif i = @__before_actions.find_index { |a| a[:name] == action_name }
+      elsif (i = @__before_actions.find_index { |a| a[:name] == action_name })
         @__before_actions[i] = action
       else
         @__before_actions << action
@@ -241,7 +264,7 @@ class RageController::API
 
       if @__after_actions.nil?
         @__after_actions = [action]
-      elsif i = @__after_actions.find_index { |a| a[:name] == action_name }
+      elsif (i = @__after_actions.find_index { |a| a[:name] == action_name })
         @__after_actions[i] = action
       else
         @__after_actions << action
@@ -277,6 +300,21 @@ class RageController::API
       @__before_actions[i] = action
     end
 
+    # Wraps the parameters hash into a nested hash. This will allow clients to submit requests without having to specify any root elements.
+    # Params get wrapped only if the `Content-Type` header is present and the `params` hash doesn't contain a param with the same name as the wrapper key.
+    #
+    # @param key [Symbol] the wrapper key
+    # @param include [Symbol, Array<Symbol>] the list of attribute names which parameters wrapper will wrap into a nested hash
+    # @param exclude [Symbol, Array<Symbol>] the list of attribute names which parameters wrapper will exclude from a nested hash
+    # @example
+    #   wrap_parameters :user, include: %i[name age]
+    # @example
+    #   wrap_parameters :user, exclude: %i[address]
+    def wrap_parameters(key, include: [], exclude: [])
+      @__wrap_parameters_key = key
+      @__wrap_parameters_options = { include:, exclude: }
+    end
+
     private
 
     # used by `before_action` and `after_action`
@@ -287,7 +325,7 @@ class RageController::API
         raise ArgumentError, "No handler provided. Pass the `action_name` parameter or provide a block."
       end
 
-       _only, _except, _if, _unless = opts.values_at(:only, :except, :if, :unless)
+      _only, _except, _if, _unless = opts.values_at(:only, :except, :if, :unless)
 
       action = {
         name: action_name,
@@ -327,13 +365,13 @@ class RageController::API
   # Get the cookie object. See {Rage::Cookies}.
   # @return [Rage::Cookies]
   def cookies
-    @cookies ||= Rage::Cookies.new(@__env, self)
+    @cookies ||= Rage::Cookies.new(@__env, @__headers)
   end
 
   # Get the session object. See {Rage::Session}.
   # @return [Rage::Session]
   def session
-    @session ||= Rage::Session.new(self)
+    @session ||= Rage::Session.new(cookies)
   end
 
   # Send a response to the client.

data/lib/rage/cookies.rb

@@ -14,9 +14,9 @@ end
 
 class Rage::Cookies
   # @private
-  def initialize(env, controller)
+  def initialize(env, headers)
     @env = env
-    @headers = controller.headers
+    @headers = headers
     @request_cookies = {}
     @parsed = false
 
@@ -97,7 +97,7 @@ class Rage::Cookies
       return
     end
 
-    if domain = value[:domain]
+    if (domain = value[:domain])
       host = @env["HTTP_HOST"]
 
       _domain = if domain.is_a?(String)
@@ -141,7 +141,7 @@ class Rage::Cookies
     return @request_cookies if @parsed
 
     @parsed = true
-    if cookie_header = @env["HTTP_COOKIE"]
+    if (cookie_header = @env["HTTP_COOKIE"])
       cookie_header.split(/; */n).each do |cookie|
         next if cookie.empty?
         key, value = cookie.split("=", 2).yield_self { |k, _| [k.to_sym, _] }
@@ -193,7 +193,7 @@ class Rage::Cookies
           nil
         rescue RbNaCl::CryptoError
           i ||= 0
-          if box = fallback_boxes[i]
+          if (box = fallback_boxes[i])
             i += 1
             retry
           end
@@ -230,10 +230,8 @@ class Rage::Cookies
       end
 
       def fallback_boxes
-        @fallback_boxes ||= begin
-          Rage.config.fallback_secret_key_base.map do |key|
-            RbNaCl::SimpleBox.from_secret_key(RbNaCl::Hash.blake2b(key, digest_size: 32, salt: SALT))
-          end
+        @fallback_boxes ||= Rage.config.fallback_secret_key_base.map do |key|
+          RbNaCl::SimpleBox.from_secret_key(RbNaCl::Hash.blake2b(key, digest_size: 32, salt: SALT))
         end
       end
     end # class << self

data/lib/rage/ext/active_record/connection_pool.rb

@@ -97,7 +97,7 @@ module Rage::Ext::ActiveRecord::ConnectionPool
 
   # Signal that the fiber is finished with the current connection and it can be returned to the pool.
   def release_connection(owner = Fiber.current)
-    if conn = @__in_use.delete(owner)
+    if (conn = @__in_use.delete(owner))
       conn.__idle_since = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       @__connections << conn
       Iodine.publish("ext:ar-connection-released", "", Iodine::PubSub::PROCESS) if @__blocked.length > 0

data/lib/rage/fiber.rb

@@ -2,7 +2,7 @@
 
 ##
 # Rage provides a simple and efficient API to wait on several instances of IO at the same time - {Fiber.await}.
-# 
+#
 # Let's say we have the following controller:
 # ```ruby
 # class UsersController < RageController::API
@@ -34,7 +34,7 @@
 # end
 # ```
 # With this change, if each request takes 1 second to execute, the total execution time will still be 1 second.
-# 
+#
 # ## Creating fibers
 # Many developers see fibers as "lightweight threads" that should be used in conjunction with fiber pools, the same way we use thread pools for threads.<br>
 # Instead, it makes sense to think of fibers as regular Ruby objects. We don't use a pool of arrays when we need to create an array - we create a new object and let Ruby and the GC do their job.<br>
@@ -68,7 +68,7 @@ class Fiber
     @__rage_id = object_id.to_s
   end
 
-   # @private
+  # @private
   def __get_id
     @__rage_id
   end

data/lib/rage/fiber_scheduler.rb

@@ -66,7 +66,7 @@ class Rage::FiberScheduler
   end
 
   # TODO: GC works a little strange with this closure;
-  # 
+  #
   # def timeout_after(duration, exception_class = Timeout::Error, *exception_arguments, &block)
   #   fiber, block_status = Fiber.current, :running
   #   ::Iodine.run_after((duration * 1000).to_i) do

data/lib/rage/logger/json_formatter.rb

@@ -15,7 +15,7 @@ class Rage::JSONFormatter
       context.each { |k, v| context_msg << "\"#{k}\":#{v.to_json}," }
     end
 
-    if final = logger[:final]
+    if (final = logger[:final])
       params, env = final[:params], final[:env]
       if params && params[:controller]
         return "{\"tags\":[\"#{tags[0]}\"],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"info\",\"method\":\"#{env["REQUEST_METHOD"]}\",\"path\":\"#{env["PATH_INFO"]}\",\"controller\":\"#{Rage::Router::Util.path_to_name(params[:controller])}\",\"action\":\"#{params[:action]}\",#{context_msg}\"status\":#{final[:response][0]},\"duration\":#{final[:duration]}}\n"

data/lib/rage/logger/logger.rb

@@ -8,7 +8,7 @@ require "logger"
 # [fecbba0735355738] timestamp=2023-10-19T11:12:56+00:00 pid=1825 level=info message=hello
 # ```
 # In the log entry above, `timestamp`, `pid`, `level`, and `message` are keys, while `fecbba0735355738` is a tag.
-# 
+#
 # Use {tagged} to add custom tags to an entry:
 # ```ruby
 # Rage.logger.tagged("ApiCall") do

data/lib/rage/logger/text_formatter.rb

@@ -15,7 +15,7 @@ class Rage::TextFormatter
       context.each { |k, v| context_msg << "#{k}=#{v} " }
     end
 
-    if final = logger[:final]
+    if (final = logger[:final])
       params, env = final[:params], final[:env]
       if params && params[:controller]
         return "[#{tags[0]}] timestamp=#{timestamp} pid=#{@pid} level=info method=#{env["REQUEST_METHOD"]} path=#{env["PATH_INFO"]} controller=#{Rage::Router::Util.path_to_name(params[:controller])} action=#{params[:action]} #{context_msg}status=#{final[:response][0]} duration=#{final[:duration]}\n"

data/lib/rage/middleware/cors.rb

@@ -19,7 +19,7 @@ class Rage::Cors
 
     response
   ensure
-    if !$! && origin = @cors_check.call(env)
+    if !$! && (origin = @cors_check.call(env))
       headers = response[1]
       headers["Access-Control-Allow-Origin"] = origin
       if @origins != "*"
@@ -99,7 +99,7 @@ class Rage::Cors
   def create_headers
     headers = {
       "Access-Control-Allow-Origin" => "",
-      "Access-Control-Allow-Methods" => @methods,
+      "Access-Control-Allow-Methods" => @methods
     }
 
     if @allow_headers

data/lib/rage/middleware/fiber_wrapper.rb

@@ -7,7 +7,9 @@
 class Rage::FiberWrapper
   def initialize(app)
     Iodine.on_state(:on_start) do
-      Fiber.set_scheduler(Rage::FiberScheduler.new)
+      unless Fiber.scheduler
+        Fiber.set_scheduler(Rage::FiberScheduler.new)
+      end
     end
     @app = app
   end

data/lib/rage/middleware/origin_validator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class Rage::OriginValidator
+  def initialize(app, *allowed_origins)
+    @app = app
+    @validator = build_validator(allowed_origins)
+  end
+
+  def call(env)
+    if @validator.call(env)
+      @app.call(env)
+    else
+      Rage.logger.error("Request origin not allowed: #{env["HTTP_ORIGIN"]}")
+      [404, {}, ["Not Found"]]
+    end
+  end
+
+  private
+
+  def build_validator(allowed_origins)
+    if allowed_origins.empty?
+      ->(env) { false }
+    else
+      origins_eval = allowed_origins.map { |origin|
+        origin.is_a?(Regexp) ?
+          "origin =~ /#{origin.source}/.freeze" :
+          "origin == '#{origin}'.freeze"
+      }.join(" || ")
+
+      eval <<-RUBY
+        ->(env) do
+          origin = env["HTTP_ORIGIN".freeze]
+          #{origins_eval}
+        end
+      RUBY
+    end
+  end
+end

data/lib/rage/middleware/reloader.rb

@@ -8,7 +8,7 @@ class Rage::Reloader
   def call(env)
     Rage.code_loader.reload
     @app.call(env)
-rescue Exception => e
+  rescue Exception => e
     exception_str = "#{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}"
     puts(exception_str)
     [500, {}, [exception_str]]

data/lib/rage/params_parser.rb

@@ -29,7 +29,7 @@ class Rage::ParamsParser
       url_params
     end
 
-  rescue => e
+  rescue
     raise Rage::Errors::BadRequest
   end
 

data/lib/rage/router/backend.rb

@@ -51,7 +51,7 @@ class Rage::Router::Backend
   def on(method, path, handler, constraints: {}, defaults: nil)
     raise "Path could not be empty" if path&.empty?
 
-    if match_index = (path =~ OPTIONAL_PARAM_REGEXP)
+    if (match_index = (path =~ OPTIONAL_PARAM_REGEXP))
       raise ArgumentError, "Optional Parameter has to be the last parameter of the path" if path.length != match_index + $&.length
 
       path_full = path.sub(OPTIONAL_PARAM_REGEXP, "/#{$1}")
@@ -200,11 +200,9 @@ class Rage::Router::Backend
     end
 
     @routes.each do |existing_route|
-      if (
-        existing_route[:method] == method &&
-        existing_route[:pattern] == pattern &&
-        existing_route[:constraints] == constraints
-      )
+      if existing_route[:method] == method &&
+         existing_route[:pattern] == pattern &&
+         existing_route[:constraints] == constraints
         raise ArgumentError, "Method '#{method}' already declared for route '#{pattern}' with constraints '#{constraints.inspect}'"
       end
     end

data/lib/rage/router/constrainer.rb

@@ -73,7 +73,7 @@ class Rage::Router::Constrainer
         if key == :host
           lines << "   host: env['HTTP_HOST'.freeze],"
         else
-          raise ArgumentError, 'unknown non-custom strategy for compiling constraint derivation function'
+          raise ArgumentError, "unknown non-custom strategy for compiling constraint derivation function"
         end
       else
         lines << "  #{strategy.name}: @strategies[#{key}].derive_constraint(env),"