# frozen-string-literal: true # class Roda module RodaPlugins # The symbol_matchers plugin allows you do define custom regexps to use # for specific symbols. For example, if you have a route such as: # # r.on :username do # # ... # end # # By default this will match all nonempty segments. However, if your usernames # must be 6-20 characters, and can only contain +a-z+ and +0-9+, you can do: # # plugin :symbol_matchers # symbol_matcher :username, /([a-z0-9]{6,20})/ # # Then the route will only if the path is +/foobar123+, but not if it is # +/foo+, +/FooBar123+, or +/foobar_123+. # # By default, this plugin sets up the following symbol matchers: # # :d :: /(\d+)/, a decimal segment # :rest :: /(.*)/, all remaining characters, if any # :w :: /(\w+)/, a alphanumeric segment # # If placeholder string matchers are supported, this feature also applies to # embedded colons in strings, so the following: # # r.on "users/:username" do # # ... # end # # Would match +/users/foobar123+, but not +/users/foo+, +/users/FooBar123+, # or +/users/foobar_123+. # # If placeholder string matchers are supported, it also adds the following # symbol matchers: # # :format :: /(?:\.(\w+))?/, an optional format/extension # :opt :: /(?:\/([^\/]+))?, an optional segment # :optd :: /(?:\/(\d+))?, an optional decimal segment # # These are only added when placeholder string matchers are supported, # because they only make sense when used inside of a string, due to how # segment matching works. Example: # # r.is "album:opt" do |id| end # # matches /album (yielding nil) and /album/foo (yielding "foo") # # does not match /album/ or /album/foo/bar # # If using this plugin with the params_capturing plugin, this plugin should # be loaded first. module SymbolMatchers def self.configure(app) app.symbol_matcher(:d, /(\d+)/) app.symbol_matcher(:w, /(\w+)/) app.symbol_matcher(:rest, /(.*)/) if !app.opts[:verbatim_string_matcher] app.symbol_matcher(:format, /(?:\.(\w+))?/) app.symbol_matcher(:opt, /(?:\/([^\/]+))?/) app.symbol_matcher(:optd, /(?:\/(\d+))?/) end end module ClassMethods # Set the regexp to use for the given symbol, instead of the default. def symbol_matcher(s, re) self::RodaRequest.send(:define_method, :"match_symbol_#{s}"){re} end end module RequestMethods private # Use regular expressions to the symbol-specific regular expression # if the symbol is registered. Otherwise, call super for the default # behavior. def _match_symbol(s) meth = :"match_symbol_#{s}" if respond_to?(meth) re = send(meth) consume(self.class.cached_matcher(re){re}) else super end end # Return the symbol-specific regular expression if one is registered. # Otherwise, call super for the default behavior. def _match_symbol_regexp(s) meth = :"match_symbol_#{s}" if respond_to?(meth) send(meth) else super end end end end register_plugin(:symbol_matchers, SymbolMatchers) end end