<%= text %>
11 | <% end %> 12 | 13 | If can also be used to reduce memory usage even in the case where 14 | you are not wrapping template output. Instead of: 15 | 16 | <%= render_each([1,2,3], :foo) %> 17 | 18 | You can do: 19 | 20 | <% render_each([1,2,3], :foo) %><%= body %><% end %> 21 | 22 | This will avoid building a potentially large unnecessary intermediate 23 | string. 24 | 25 | * The capture_erb plugin now supports a returns: :buffer method and 26 | plugin option. When this option is provided, the capture_erb method 27 | returns the buffer instead of the return value of the block passed 28 | to it. This better handles cases where the template ends in a 29 | conditional: 30 | 31 | <% value = capture_erb do %> 32 | Some content here. 33 | <% if something %> 34 | Some more content here. 35 | <% end %> 36 | <% end %> 37 | -------------------------------------------------------------------------------- /doc/release_notes/3.92.0.txt: -------------------------------------------------------------------------------- 1 | = New Features 2 | 3 | * An each_part plugin has been added, offering a simpler method for 4 | using render_each with locals: 5 | 6 | # With render_each: 7 | render_each(array_of_foos, :foo, locals: {bar: 1}) 8 | 9 | # With each_part: 10 | each_part(array_of_foos, :foo, bar: 1) 11 | 12 | The each_part provides similar benefits to the render_each plugin 13 | that the part plugin provides to the render plugin. The each_part 14 | method has been optimized to work with the render plugin's 15 | :assume_fixed_locals option. 16 | 17 | = Other Improvements 18 | 19 | * The render_each plugin has been optimized to work with the render 20 | plugin's :assume_fixed_locals option. 21 | -------------------------------------------------------------------------------- /lib/roda/cache.rb: -------------------------------------------------------------------------------- 1 | # frozen-string-literal: true 2 | 3 | require "thread" 4 | 5 | class Roda 6 | # A thread safe cache class, offering only #[] and #[]= methods, 7 | # each protected by a mutex. 8 | class RodaCache 9 | # Create a new thread safe cache. 10 | def initialize 11 | @mutex = Mutex.new 12 | @hash = {} 13 | end 14 | 15 | # Make getting value from underlying hash thread safe. 16 | def [](key) 17 | @mutex.synchronize{@hash[key]} 18 | end 19 | 20 | # Make setting value in underlying hash thread safe. 21 | def []=(key, value) 22 | @mutex.synchronize{@hash[key] = value} 23 | end 24 | 25 | # Return the frozen internal hash. The internal hash can then 26 | # be accessed directly since it is frozen and there are no 27 | # thread safety issues. 28 | def freeze 29 | @hash.freeze 30 | end 31 | 32 | private 33 | 34 | # Create a copy of the cache with a separate mutex. 35 | def initialize_copy(other) 36 | @mutex = Mutex.new 37 | other.instance_variable_get(:@mutex).synchronize do 38 | @hash = other.instance_variable_get(:@hash).dup 39 | end 40 | end 41 | end 42 | end 43 | -------------------------------------------------------------------------------- /lib/roda/plugins/_after_hook.rb: -------------------------------------------------------------------------------- 1 | # frozen-string-literal: true 2 | 3 | require_relative 'error_handler' 4 | 5 | # 6 | class Roda 7 | module RodaPlugins 8 | # RODA4: Remove 9 | register_plugin(:_after_hook, ErrorHandler) 10 | end 11 | end 12 | -------------------------------------------------------------------------------- /lib/roda/plugins/_base64.rb: -------------------------------------------------------------------------------- 1 | # frozen-string-literal: true 2 | 3 | # 4 | class Roda 5 | module RodaPlugins 6 | module Base64_ 7 | class << self 8 | if RUBY_VERSION >= '2.4' 9 | def decode64(str) 10 | str.unpack1("m0") 11 | end 12 | # :nocov: 13 | else 14 | def decode64(str) 15 | str.unpack("m0")[0] 16 | end 17 | # :nocov: 18 | end 19 | 20 | def urlsafe_encode64(bin) 21 | str = [bin].pack("m0") 22 | str.tr!("+/", "-_") 23 | str 24 | end 25 | 26 | def urlsafe_decode64(str) 27 | decode64(str.tr("-_", "+/")) 28 | end 29 | end 30 | end 31 | 32 | register_plugin(:_base64, Base64_) 33 | end 34 | end 35 | -------------------------------------------------------------------------------- /lib/roda/plugins/_before_hook.rb: -------------------------------------------------------------------------------- 1 | # frozen-string-literal: true 2 | 3 | # 4 | class Roda 5 | module RodaPlugins 6 | # Internal before hook module, not for external use. 7 | # Allows for plugins to configure the order in which 8 | # before processing is done by using _roda_before_* 9 | # private instance methods that are called in sorted order. 10 | # Loaded automatically by the base library if any _roda_before_* 11 | # methods are defined. 12 | module BeforeHook # :nodoc: 13 | module InstanceMethods 14 | # Run internal before hooks - Old Dispatch API. 15 | def call(&block) 16 | # RODA4: Remove 17 | super do 18 | _roda_before 19 | instance_exec(@_request, &block) # call Fallback 20 | end 21 | end 22 | 23 | # Run internal before hooks before running the main 24 | # roda route. 25 | def _roda_run_main_route(r) 26 | _roda_before 27 | super 28 | end 29 | 30 | private 31 | 32 | # Default empty implementation of _roda_before, usually 33 | # overridden by Roda.def_roda_before. 34 | def _roda_before 35 | end 36 | end 37 | end 38 | 39 | register_plugin(:_before_hook, BeforeHook) 40 | end 41 | end 42 | -------------------------------------------------------------------------------- /lib/roda/plugins/_symbol_regexp_matchers.rb: -------------------------------------------------------------------------------- 1 | # frozen-string-literal: true 2 | 3 | # 4 | class Roda 5 | module RodaPlugins 6 | # The _symbol_regexp_matchers plugin is designed for internal use by other plugins, 7 | # for the historical behavior of a symbol matching an arbitrary segment by default 8 | # using a regexp. 9 | module SymbolRegexpMatchers 10 | module RequestMethods 11 | private 12 | 13 | # The regular expression to use for matching symbols. By default, any non-empty 14 | # segment matches. 15 | def _match_symbol_regexp(s) 16 | "([^\\/]+)" 17 | end 18 | end 19 | end 20 | 21 | register_plugin(:_symbol_regexp_matchers, SymbolRegexpMatchers) 22 | end 23 | end 24 | 25 | -------------------------------------------------------------------------------- /lib/roda/plugins/all_verbs.rb: -------------------------------------------------------------------------------- 1 | # frozen-string-literal: true 2 | 3 | # 4 | class Roda 5 | module RodaPlugins 6 | # The all_verbs plugin adds methods for http verbs other than 7 | # get and post. The following verbs are added, assuming 8 | # rack handles them: delete, head, options, link, patch, put, 9 | # trace, unlink. 10 | # 11 | # These methods operate just like Roda's default get and post 12 | # methods, so using them without any arguments just checks for 13 | # the request method, while using them with any arguments also 14 | # checks that the arguments match the full path. 15 | # 16 | # Example: 17 | # 18 | # plugin :all_verbs 19 | # 20 | # route do |r| 21 | # r.delete do 22 | # # Handle DELETE 23 | # end 24 | # r.put do 25 | # # Handle PUT 26 | # end 27 | # r.patch do 28 | # # Handle PATCH 29 | # end 30 | # end 31 | # 32 | # The verb methods are defined via metaprogramming, so there 33 | # isn't documentation for the individual methods created. 34 | module AllVerbs 35 | module RequestMethods 36 | %w'delete head options link patch put trace unlink'.each do |verb| 37 | if ::Rack::Request.method_defined?("#{verb}?") 38 | class_eval(<<-END, __FILE__, __LINE__+1) 39 | def #{verb}(*args, &block) 40 | _verb(args, &block) if #{verb}? 41 | end 42 | END 43 | end 44 | end 45 | end 46 | end 47 | 48 | register_plugin(:all_verbs, AllVerbs) 49 | end 50 | end 51 | -------------------------------------------------------------------------------- /lib/roda/plugins/assume_ssl.rb: -------------------------------------------------------------------------------- 1 | # frozen-string-literal: true 2 | 3 | # 4 | class Roda 5 | module RodaPlugins 6 | # The assume_ssl plugin makes the request ssl? method always return 7 | # true. This is useful when using an SSL-terminating reverse proxy 8 | # that doesn't set the X-Forwarded-Proto or similar header to notify 9 | # Rack that it is forwarding an SSL request. 10 | # 11 | # The sessions and sinatra_helpers plugins that ship with Roda both 12 | # use the ssl? method internally and can be affected by use of the 13 | # plugin. It's recommended that you use this plugin if you are 14 | # using either plugin and an SSL-terminating proxy as described above. 15 | # 16 | # plugin :assume_ssl 17 | module AssumeSSL 18 | module RequestMethods 19 | # Assume all requests are protected by SSL. 20 | def ssl? 21 | true 22 | end 23 | end 24 | end 25 | 26 | register_plugin(:assume_ssl, AssumeSSL) 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/roda/plugins/break.rb: -------------------------------------------------------------------------------- 1 | # frozen-string-literal: true 2 | 3 | # 4 | class Roda 5 | module RodaPlugins 6 | # The break plugin supports calling break inside a match block, to 7 | # return from the block and continue in the routing tree, restoring 8 | # the remaining path so that future matchers operating on the path 9 | # operate as expected. 10 | # 11 | # plugin :break 12 | # 13 | # route do |r| 14 | # r.on "foo", :bar do |bar| 15 | # break if bar == 'baz' 16 | # "/foo/#{bar} (not baz)" 17 | # end 18 | # 19 | # r.on "foo/baz" do 20 | # "/foo/baz" 21 | # end 22 | # end 23 | # 24 | # This provides the same basic feature as the pass plugin, but 25 | # uses Ruby's standard control flow primative instead of a 26 | # separate method. 27 | module Break 28 | module RequestMethods 29 | private 30 | 31 | # Handle break inside match blocks, restoring remaining path. 32 | def if_match(_) 33 | rp = @remaining_path 34 | super 35 | ensure 36 | @remaining_path = rp 37 | end 38 | end 39 | end 40 | 41 | register_plugin(:break, Break) 42 | end 43 | end 44 | -------------------------------------------------------------------------------- /lib/roda/plugins/default_status.rb: -------------------------------------------------------------------------------- 1 | # frozen-string-literal: true 2 | 3 | # 4 | class Roda 5 | module RodaPlugins 6 | # The default_status plugin accepts a block which should 7 | # return a response status integer. This integer will be used as 8 | # the default response status (usually 200) if the body has been 9 | # written to, and you have not explicitly set a response status. 10 | # 11 | # Example: 12 | # 13 | # # Use 201 default response status for all requests 14 | # plugin :default_status do 15 | # 201 16 | # end 17 | module DefaultStatus 18 | def self.configure(app, &block) 19 | raise RodaError, "default_status plugin requires a block" unless block 20 | if check_arity = app.opts.fetch(:check_arity, true) 21 | unless block.arity == 0 22 | if check_arity == :warn 23 | RodaPlugins.warn "Arity mismatch in block passed to plugin :default_status. Expected Arity 0, but arguments required for #{block.inspect}" 24 | end 25 | b = block 26 | block = lambda{instance_exec(&b)} # Fallback 27 | end 28 | end 29 | app::RodaResponse.send(:define_method, :default_status, &block) 30 | end 31 | end 32 | 33 | register_plugin(:default_status, DefaultStatus) 34 | end 35 | end 36 | -------------------------------------------------------------------------------- /lib/roda/plugins/delay_build.rb: -------------------------------------------------------------------------------- 1 | # frozen-string-literal: true 2 | 3 | # 4 | class Roda 5 | module RodaPlugins 6 | module DelayBuild 7 | module ClassMethods 8 | # No-op for backwards compatibility 9 | def build! 10 | end 11 | end 12 | end 13 | 14 | # RODA4: Remove plugin 15 | # Only available for backwards compatibility, no longer needed 16 | register_plugin(:delay_build, DelayBuild) 17 | end 18 | end 19 | -------------------------------------------------------------------------------- /lib/roda/plugins/delete_empty_headers.rb: -------------------------------------------------------------------------------- 1 | # frozen-string-literal: true 2 | 3 | # 4 | class Roda 5 | module RodaPlugins 6 | # The delete_empty_headers plugin deletes any headers whose 7 | # value is set to the empty string. Because of how default headers are 8 | # set in Roda, if you have a default header but don't want 9 | # to set it for a specific request, you need to use this plugin 10 | # and set the header value to the empty string, and Roda will automatically 11 | # delete the header. 12 | module DeleteEmptyHeaders 13 | module ResponseMethods 14 | # Delete any empty headers when calling finish 15 | def finish 16 | delete_empty_headers(super) 17 | end 18 | 19 | # Delete any empty headers when calling finish_with_body 20 | def finish_with_body(_) 21 | delete_empty_headers(super) 22 | end 23 | 24 | private 25 | 26 | # Delete any empty headers from response 27 | def delete_empty_headers(res) 28 | res[1].delete_if{|_, v| v.is_a?(String) && v.empty?} 29 | res 30 | end 31 | end 32 | end 33 | 34 | register_plugin(:delete_empty_headers, DeleteEmptyHeaders) 35 | end 36 | end 37 | -------------------------------------------------------------------------------- /lib/roda/plugins/direct_call.rb: -------------------------------------------------------------------------------- 1 | # frozen-string-literal: true 2 | 3 | # 4 | class Roda 5 | module RodaPlugins 6 | # The direct_call plugin makes the call class method skip the middleware stack 7 | # (app.call will still call the middleware). 8 | # This can be used as an optimization, as the Roda class itself can be used 9 | # as the callable, which is faster than using a lambda. 10 | module DirectCall 11 | def self.configure(app) 12 | app.send(:build_rack_app) 13 | end 14 | 15 | module ClassMethods 16 | # Call the application without middlware. 17 | def call(env) 18 | new(env)._roda_handle_main_route 19 | end 20 | 21 | private 22 | 23 | # If new_api is true, use the receiver as the base rack app for better 24 | # performance. 25 | def base_rack_app_callable(new_api=true) 26 | if new_api 27 | self 28 | else 29 | super 30 | end 31 | end 32 | end 33 | end 34 | 35 | register_plugin(:direct_call, DirectCall) 36 | end 37 | end 38 | 39 | -------------------------------------------------------------------------------- /lib/roda/plugins/disallow_file_uploads.rb: -------------------------------------------------------------------------------- 1 | # frozen-string-literal: true 2 | 3 | raise LoadError, "disallow_file_uploads plugin not supported on Rack <1.6" if Rack.release < '1.6' 4 | 5 | # 6 | class Roda 7 | module RodaPlugins 8 | # The disallow_file_uploads plugin raises a Roda::RodaPlugins::DisallowFileUploads::Error 9 | # if there is an attempt to upload a file. This plugin is useful for applications where 10 | # multipart file uploads are not expected and you want to remove the ability for rack 11 | # to create temporary files. Example: 12 | # 13 | # plugin :disallow_file_uploads 14 | # 15 | # This plugin is only supported on Rack 1.6+. This plugin does not technically 16 | # block users from uploading files, it only blocks the parsing of request bodies containing 17 | # multipart file uploads. So if you do not call +r.POST+ (or something that calls it such as 18 | # +r.params+), then Roda will not attempt to parse the request body, and an exception will not 19 | # be raised. 20 | module DisallowFileUploads 21 | # Exception class used when a multipart file upload is attempted. 22 | class Error < RodaError; end 23 | 24 | NO_TEMPFILE = lambda{|_,_| raise Error, "Support for uploading files has been disabled"} 25 | 26 | module RequestMethods 27 | # HTML escape the input and return the escaped version. 28 | def initialize(_, env) 29 | env['rack.multipart.tempfile_factory'] = NO_TEMPFILE 30 | super 31 | end 32 | end 33 | end 34 | 35 | register_plugin(:disallow_file_uploads, DisallowFileUploads) 36 | end 37 | end 38 | 39 | -------------------------------------------------------------------------------- /lib/roda/plugins/drop_body.rb: -------------------------------------------------------------------------------- 1 | # frozen-string-literal: true 2 | 3 | # 4 | class Roda 5 | module RodaPlugins 6 | # The drop_body plugin automatically drops the body and 7 | # Content-Type/Content-Length headers from the response if 8 | # the response status indicates that the response should 9 | # not include a body (response statuses 100, 101, 102, 204, 10 | # and 304). For response status 205, the body and Content-Type 11 | # headers are dropped, but the Content-length header is set to 12 | # '0' instead of being dropped. 13 | module DropBody 14 | module ResponseMethods 15 | DROP_BODY_STATUSES = [100, 101, 102, 204, 205, 304].freeze 16 | RodaPlugins.deprecate_constant(self, :DROP_BODY_STATUSES) 17 | 18 | DROP_BODY_RANGE = 100..199 19 | private_constant :DROP_BODY_RANGE 20 | 21 | # If the response status indicates a body should not be 22 | # returned, use an empty body and remove the Content-Length 23 | # and Content-Type headers. 24 | def finish 25 | r = super 26 | case r[0] 27 | when DROP_BODY_RANGE, 204, 304 28 | r[2] = EMPTY_ARRAY 29 | h = r[1] 30 | h.delete(RodaResponseHeaders::CONTENT_LENGTH) 31 | h.delete(RodaResponseHeaders::CONTENT_TYPE) 32 | when 205 33 | r[2] = EMPTY_ARRAY 34 | empty_205_headers(r[1]) 35 | end 36 | r 37 | end 38 | end 39 | end 40 | 41 | register_plugin(:drop_body, DropBody) 42 | end 43 | end 44 | -------------------------------------------------------------------------------- /lib/roda/plugins/early_hints.rb: -------------------------------------------------------------------------------- 1 | # frozen-string-literal: true 2 | 3 | # 4 | class Roda 5 | module RodaPlugins 6 | # The early_hints plugin allows sending 103 Early Hints responses 7 | # using the rack.early_hints environment variable. 8 | # Early hints allow clients to preload necessary files before receiving 9 | # the response. 10 | module EarlyHints 11 | module InstanceMethods 12 | # Send given hash of Early Hints using the rack.early_hints environment variable, 13 | # currenly only supported by puma. hash given should generally have the single 14 | # key 'Link', and a string or array of strings for each of the early hints. 15 | def send_early_hints(hash) 16 | if eh_proc = env['rack.early_hints'] 17 | eh_proc.call(hash) 18 | end 19 | end 20 | end 21 | end 22 | 23 | register_plugin(:early_hints, EarlyHints) 24 | end 25 | end 26 | -------------------------------------------------------------------------------- /lib/roda/plugins/empty_root.rb: -------------------------------------------------------------------------------- 1 | # frozen-string-literal: true 2 | 3 | # 4 | class Roda 5 | module RodaPlugins 6 | # The empty_root plugin makes +r.root+ match both on +/+ and 7 | # on the empty string. This is mostly useful when using multiple 8 | # rack applications, where the initial PATH_INFO has been moved 9 | # to SCRIPT_NAME. For example, if you have the following 10 | # applications: 11 | # 12 | # class App1 < Roda 13 | # on "albums" do 14 | # run App2 15 | # end 16 | # end 17 | # 18 | # class App2 < Roda 19 | # plugin :empty_root 20 | # 21 | # route do |r| 22 | # r.root do 23 | # "root" 24 | # end 25 | # end 26 | # end 27 | # 28 | # Then requests for both +/albums/+ and +/albums+ will return 29 | # "root". Without this plugin loaded into App2, only requests 30 | # for +/albums/+ will return "root", since by default, +r.root+ 31 | # matches only when the current PATH_INFO is +/+ and not when 32 | # it is empty. 33 | module EmptyRoot 34 | module RequestMethods 35 | # Match when the remaining path is the empty string, 36 | # in addition to the default behavior of matching when 37 | # the remaining path is +/+. 38 | def root(&block) 39 | super 40 | if remaining_path.empty? && is_get? 41 | always(&block) 42 | end 43 | end 44 | end 45 | end 46 | 47 | register_plugin(:empty_root, EmptyRoot) 48 | end 49 | end 50 | -------------------------------------------------------------------------------- /lib/roda/plugins/erb_h.rb: -------------------------------------------------------------------------------- 1 | # frozen-string-literal: true 2 | 3 | require 'erb/escape' 4 | 5 | # 6 | class Roda 7 | module RodaPlugins 8 | # The erb_h plugin adds an +h+ instance method that will HTML 9 | # escape the input and return it. This is similar to the h 10 | # plugin, but it uses erb/escape to implement the HTML escaping, 11 | # which offers faster performance. 12 | # 13 | # To make sure that this speeds up applications using the h 14 | # plugin, this depends on the h plugin, and overrides the 15 | # h method. 16 | # 17 | # The following example will return "<foo>" as the body. 18 | # 19 | # plugin :erb_h 20 | # 21 | # route do |r| 22 | # h('