ultra-max-sys 0.0.1

data/roda-3.106.0/lib/roda/plugins/multi_run.rb

@@ -0,0 +1,144 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The multi_run plugin provides the ability to easily dispatch to other
+    # rack applications based on the request path prefix.
+    # First, load the plugin:
+    #
+    #   class App < Roda
+    #     plugin :multi_run
+    #   end
+    #
+    # Then, other rack applications can register with the multi_run plugin:
+    #
+    #   App.run "ra", PlainRackApp
+    #   App.run "ro", OtherRodaApp
+    #   App.run "si", SinatraApp
+    #
+    # Inside your route block, you can call +r.multi_run+ to dispatch to all
+    # three rack applications based on the prefix:
+    #
+    #   App.route do |r|
+    #     r.multi_run
+    #   end
+    #
+    # This will dispatch routes starting with +/ra+ to +PlainRackApp+, routes
+    # starting with +/ro+ to +OtherRodaApp+, and routes starting with +/si+ to
+    # SinatraApp.
+    #
+    # You can pass a block to +r.multi_run+ that will be called with the prefix,
+    # before dispatching to the rack app:
+    #
+    #   App.route do |r|
+    #     r.multi_run do |prefix|
+    #       # do something based on prefix before the request is passed further
+    #     end
+    #   end
+    #
+    # This is useful for modifying the environment before passing it to the rack app.
+    #
+    # You can also call +Roda.run+ with a block:
+    #
+    #   App.run("ra"){PlainRackApp}
+    #   App.run("ro"){OtherRodaApp}
+    #   App.run("si"){SinatraApp}
+    #
+    # When called with a block, Roda will call the block to get the app to dispatch to
+    # every time the block is called.  The expected usage is with autoloaded classes,
+    # so that the related classes are not loaded until there is a request for the
+    # related route.  This can sigficantly speedup startup or testing a subset of the
+    # application.  When freezing an application, the blocks are called once to get the
+    # app to dispatch to, and that is cached, to ensure the any autoloads are completed
+    # before the application is frozen.
+    #
+    # The multi_run plugin is similar to the hash_branches and multi_route plugins, with
+    # the difference being the hash_branches and multi_route plugins keep all routing
+    # subtrees in the same Roda app/class, while multi_run dispatches to other rack apps.
+    # If you want to isolate your routing subtrees, multi_run is a better approach, but
+    # it does not let you set instance variables in the main Roda app and have those
+    # instance variables usable in the routing subtrees.
+    #
+    # To handle development environments that reload code, you can call the
+    # +run+ class method without an app to remove dispatching for the prefix.
+    module MultiRun
+      # Initialize the storage for the dispatched applications
+      def self.configure(app)
+        app.opts[:multi_run_apps] ||= {}
+        app.opts[:multi_run_app_blocks] ||= {}
+      end
+
+      module ClassMethods
+        # Convert app blocks into apps by calling them, in order to force autoloads
+        # and to speed up subsequent calls.
+        # Freeze the multi_run apps so that there can be no thread safety issues at runtime.
+        def freeze
+          app_blocks = opts[:multi_run_app_blocks]
+          apps = opts[:multi_run_apps]
+          app_blocks.each do |prefix, block|
+            apps[prefix] = block.call
+          end
+          app_blocks.clear.freeze
+          apps.freeze
+          self::RodaRequest.refresh_multi_run_regexp!
+          super
+        end
+
+        # Hash storing rack applications to dispatch to, keyed by the prefix
+        # for the application.
+        def multi_run_apps
+          opts[:multi_run_apps]
+        end
+
+        # Add a rack application to dispatch to for the given prefix when
+        # r.multi_run is called. If a block is given, it is called every time
+        # there is a request for the route to get the app to call. If neither
+        # a block or an app is provided, any stored route for the prefix is
+        # removed.  It is an error to provide both an app and block in the same call.
+        def run(prefix, app=nil, &block)
+          prefix = prefix.to_s
+          if app 
+            raise Roda::RodaError, "cannot provide both app and block to Roda.run" if block
+            opts[:multi_run_apps][prefix] = app
+            opts[:multi_run_app_blocks].delete(prefix)
+          elsif block
+            opts[:multi_run_apps].delete(prefix)
+            opts[:multi_run_app_blocks][prefix] = block
+          else
+            opts[:multi_run_apps].delete(prefix)
+            opts[:multi_run_app_blocks].delete(prefix)
+          end
+          self::RodaRequest.refresh_multi_run_regexp!
+        end
+      end
+
+      module RequestClassMethods
+        # Refresh the multi_run_regexp, using the stored route prefixes,
+        # preferring longer routes before shorter routes.
+        def refresh_multi_run_regexp!
+          @multi_run_regexp = /(#{Regexp.union((roda_class.opts[:multi_run_apps].keys + roda_class.opts[:multi_run_app_blocks].keys).sort.reverse)})/
+        end
+
+        # Refresh the multi_run_regexp if it hasn't been loaded yet.
+        def multi_run_regexp
+          @multi_run_regexp || refresh_multi_run_regexp!
+        end
+      end
+
+      module RequestMethods
+        # If one of the stored route prefixes match the current request,
+        # dispatch the request to the appropriate rack application.
+        def multi_run
+          on self.class.multi_run_regexp do |prefix|
+            yield prefix if defined?(yield)
+            opts = scope.opts
+            run(opts[:multi_run_apps][prefix] || opts[:multi_run_app_blocks][prefix].call)
+          end
+        end
+      end
+    end
+
+    register_plugin(:multi_run, MultiRun)
+  end
+end

data/roda-3.106.0/lib/roda/plugins/multi_view.rb

@@ -0,0 +1,83 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The multi_view plugin makes it easy to render multiple views, where the
+    # view template is the same as the matched element.  It adds an +r.multi_view+
+    # method, which takes an argument that is passed to +r.get+, and should
+    # capture a single argument, which is treated as the template name to pass
+    # to +view+.  This makes it possible to pass in an array of strings, or a
+    # regexp with a single capture.
+    #
+    # The advantage of using a regexp over an array of strings is that the regexp
+    # is generally faster and uses less memory.  However, constructing the regexps
+    # is more cumbersome.  To make it easier, the multi_view plugin also offers a
+    # +multi_view_compile+ class method that will take an array of view template
+    # names and construct a regexp that can be passed to +r.multi_view+.
+    #
+    # Example:
+    #
+    #   plugin :multi_view
+    #
+    #   route do |r|
+    #     r.multi_view(['foo', 'bar', 'baz'])
+    #   end
+    #
+    #   # or:
+    #
+    #   route do |r|
+    #     r.multi_view(/(foo|bar|baz)/)
+    #   end
+    #
+    #   # or:
+    #
+    #   regexp = multi_view_compile(['foo', 'bar', 'baz'])
+    #   route do |r|
+    #     r.multi_view(regexp)
+    #   end
+    #
+    #   # all are equivalent to:
+    #
+    #   route do |r|
+    #     r.get 'foo' do
+    #       view('foo')
+    #     end
+    #
+    #     r.get 'bar' do
+    #       view('bar')
+    #     end
+    #
+    #     r.get 'baz' do
+    #       view('baz')
+    #     end
+    #   end
+    module MultiView
+      # Depend on the render plugin, since this plugin only makes
+      # sense when the render plugin is used.
+      def self.load_dependencies(app)
+        app.plugin :render
+      end
+
+      module ClassMethods
+        # Given the array of view template names, return a regexp that will
+        # match on any of the names and capture the matched name.
+        def multi_view_compile(array)
+          /(#{Regexp.union(array)})/
+        end
+      end
+
+      module RequestMethods
+        # Pass the argument to +get+, and assume if the matchers match that
+        # there is one capture, and call view with that capture.
+        def multi_view(arg)
+          get(arg) do |page|
+            scope.view(page)
+          end
+        end
+      end
+    end
+
+    register_plugin(:multi_view, MultiView)
+  end
+end

data/roda-3.106.0/lib/roda/plugins/multibyte_string_matcher.rb

@@ -0,0 +1,57 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The multibyte_string_matcher plugin allows multibyte
+    # strings to be used in matchers.  Roda's default string
+    # matcher does not handle multibyte strings for performance
+    # reasons.
+    #
+    # As browsers send multibyte characters in request paths URL
+    # escaped, so this also loads the unescape_path plugin to
+    # unescape the paths.
+    #
+    #   plugin :multibyte_string_matcher
+    #
+    #   path = "\xD0\xB8".force_encoding('UTF-8')
+    #   route do |r|
+    #     r.get path do
+    #       # GET /\xD0\xB8 (request.path in UTF-8 format)
+    #     end
+    #
+    #     r.get /y-(#{path})/u do |x|
+    #       # GET /y-\xD0\xB8 (request.path in UTF-8 format)
+    #       x => "\xD0\xB8".force_encoding('BINARY')
+    #     end
+    #   end
+    module MultibyteStringMatcher
+      # Must load unescape_path plugin to decode multibyte
+      # paths, which are submitted escaped.
+      def self.load_dependencies(app)
+        app.plugin :unescape_path
+      end
+
+      module RequestMethods
+        private
+
+        # Use multibyte safe string matcher, using the same
+        # approach as in Roda 3.0.
+        def _match_string(str)
+          rp = @remaining_path
+          if rp.start_with?("/#{str}")
+            last = str.length + 1
+            case rp[last]
+            when "/"
+              @remaining_path = rp[last, rp.length]
+            when nil
+              @remaining_path = ""
+            end
+          end
+        end
+      end
+    end
+
+    register_plugin(:multibyte_string_matcher, MultibyteStringMatcher)
+  end
+end

data/roda-3.106.0/lib/roda/plugins/named_routes.rb

@@ -0,0 +1,167 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The named_routes plugin allows for multiple named routes, which the
+    # main route block can dispatch to by name at any point by calling +r.route+.
+    # If the named route doesn't handle the request, execution will continue,
+    # and if the named route does handle the request, the response returned by
+    # the named route will be returned.
+    #
+    # Example:
+    #
+    #   plugin :named_routes
+    #
+    #   route('foo') do |r|
+    #     r.is 'bar' do
+    #       '/foo/bar'
+    #     end
+    #   end
+    #
+    #   route('bar') do |r|
+    #     r.is 'foo' do
+    #       '/bar/foo'
+    #     end
+    #   end
+    #
+    #   route do |r|
+    #     r.on "foo" do
+    #       r.route 'foo'
+    #     end
+    #
+    #     r.on "bar" do
+    #       r.route 'bar'
+    #     end
+    #   end
+    #
+    # Note that in multi-threaded code, you should not attempt to add a
+    # named route after accepting requests.
+    #
+    # To handle development environments that reload code, you can call the
+    # +route+ class method without a block to remove an existing named route.
+    #
+    # == Routing Files
+    #
+    # The convention when using the named_routes plugin is to have a single
+    # named route per file, and these routing files should be stored in
+    # a routes subdirectory in your application.  So for the above example, you
+    # would use the following files:
+    #
+    #   routes/bar.rb
+    #   routes/foo.rb
+    #
+    # == Namespace Support
+    #
+    # The named_routes plugin also has support for namespaces, allowing you to
+    # use +r.route+ at multiple levels in your routing tree.  Example:
+    #
+    #   route('foo') do |r|
+    #     r.on("baz"){r.route("baz", "foo")}
+    #     r.on("quux"){r.route("quux", "foo")}
+    #   end
+    #
+    #   route('bar') do |r|
+    #     r.on("baz"){r.route("baz", "bar")}
+    #     r.on("quux"){r.route("quux", "bar")}
+    #   end
+    #
+    #   route('baz', 'foo') do |r|
+    #     # handles /foo/baz prefix
+    #   end
+    #
+    #   route('quux', 'foo') do |r|
+    #     # handles /foo/quux prefix
+    #   end
+    #
+    #   route('baz', 'bar') do |r|
+    #     # handles /bar/baz prefix
+    #   end
+    #
+    #   route('quux', 'bar') do |r|
+    #     # handles /bar/quux prefix
+    #   end
+    #
+    #   route do |r|
+    #     r.on "foo" do
+    #       r.route("foo")
+    #     end
+    #
+    #     r.on "bar" do
+    #       r.route("bar")
+    #     end
+    #   end
+    #
+    # === Routing Files
+    #
+    # The convention when using namespaces with the multi_route plugin is to
+    # store the routing files in subdirectories per namespace. So for the
+    # above example, you would have the following routing files:
+    #
+    #   routes/bar.rb
+    #   routes/bar/baz.rb
+    #   routes/bar/quux.rb
+    #   routes/foo.rb
+    #   routes/foo/baz.rb
+    #   routes/foo/quux.rb
+    module NamedRoutes
+      # Initialize storage for the named routes.
+      def self.configure(app)
+        app.opts[:namespaced_routes] ||= {}
+      end
+
+      module ClassMethods
+        # Freeze the namespaced routes so that there can be no thread safety issues at runtime.
+        def freeze
+          opts[:namespaced_routes].freeze.each_value(&:freeze)
+          super
+        end
+
+        # Copy the named routes into the subclass when inheriting.
+        def inherited(subclass)
+          super
+          nsr = subclass.opts[:namespaced_routes]
+          opts[:namespaced_routes].each{|k, v| nsr[k] = v.dup}
+        end
+
+        # The names for the currently stored named routes
+        def named_routes(namespace=nil)
+          unless routes = opts[:namespaced_routes][namespace]
+            raise RodaError, "unsupported named_routes namespace used: #{namespace.inspect}"
+          end
+          routes.keys
+        end
+
+        # Return the named route with the given name.
+        def named_route(name, namespace=nil)
+          opts[:namespaced_routes][namespace][name]
+        end
+
+        # If the given route has a name, treat it as a named route and
+        # store the route block.  Otherwise, this is the main route, so
+        # call super.
+        def route(name=nil, namespace=nil, &block)
+          if name
+            routes = opts[:namespaced_routes][namespace] ||= {}
+            if block
+              routes[name] = define_roda_method(routes[name] || "named_routes_#{namespace}_#{name}", 1, &convert_route_block(block))
+            elsif meth = routes.delete(name)
+              remove_method(meth)
+            end
+          else
+            super(&block)
+          end
+        end
+      end
+
+      module RequestMethods
+        # Dispatch to the named route with the given name.
+        def route(name, namespace=nil)
+          scope.send(roda_class.named_route(name, namespace), self)
+        end
+      end
+    end
+
+    register_plugin(:named_routes, NamedRoutes)
+  end
+end

data/roda-3.106.0/lib/roda/plugins/named_templates.rb

@@ -0,0 +1,102 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The named_templates plugin allows you to specify templates by name,
+    # providing the template code to use for a given name:
+    #
+    #   plugin :named_templates
+    #
+    #   template :layout do
+    #     "<html><body><%= yield %></body></html>"
+    #   end
+    #   template :index do
+    #     "<p>Hello <%= @user %>!</p>"
+    #   end
+    #
+    #   route do |r|
+    #     @user = 'You'
+    #     render(:index)
+    #   end
+    #   # => "<html><body><p>Hello You!</p></body></html>"
+    #
+    # You can provide options for the template, for example to change the
+    # engine that the template uses:
+    #
+    #   template :index, engine: :str do
+    #     "<p>Hello #{@user}!</p>"
+    #   end
+    #   
+    # The block you use is reevaluted on every call, allowing you to easily
+    # include additional setup logic:
+    #
+    #   template :index do
+    #     greeting = ['hello', 'hi', 'howdy'].sample
+    #     @user.downcase!
+    #     "<p>#{greating} <%= @user %>!</p>"
+    #   end
+    #   
+    # This plugin also works with the view_options plugin, as long as you
+    # prefix the template name with the view subdirectory:
+    #
+    #   template "main/index" do
+    #     "<html><body><%= yield %></body></html>"
+    #   end
+    #
+    #   route do |r|
+    #     set_view_subdir("main")
+    #     @user = 'You'
+    #     render(:index)
+    #   end
+    module NamedTemplates
+      # Depend on the render plugin
+      def self.load_dependencies(app)
+        app.plugin :render
+      end
+
+      # Initialize the storage for named templates.
+      def self.configure(app)
+        app.opts[:named_templates] ||= {}
+      end
+
+      module ClassMethods
+        # Freeze the named templates so that there can be no thread safety issues at runtime.
+        def freeze
+          opts[:named_templates].freeze
+          super
+        end
+
+        # Store a new template block and options for the given template name.
+        def template(name, options=nil, &block)
+          opts[:named_templates][name.to_s] = [options, define_roda_method("named_templates_#{name}", 0, &block)].freeze
+          nil
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # If a template name is given and it matches a named template, call
+        # the named template block to get the inline template to use.
+        def find_template(options)
+          if options[:template] && (template_opts, meth = opts[:named_templates][template_name(options)]; meth)
+            if template_opts
+              options = template_opts.merge(options)
+            else
+              options = Hash[options]
+            end
+
+            options[:inline] = send(meth)
+
+            super(options)
+          else
+            super
+          end
+        end
+      end
+    end
+
+    register_plugin(:named_templates, NamedTemplates)
+  end
+end

data/roda-3.106.0/lib/roda/plugins/not_allowed.rb

@@ -0,0 +1,151 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The not_allowed plugin makes Roda attempt to automatically
+    # support the 405 Method Not Allowed response status. The plugin
+    # changes the +r.get+ and +r.post+ verb methods to automatically
+    # return a 405 status if they are called with any arguments, and
+    # the arguments match but the request method does not match. So
+    # this code:
+    #
+    #   r.get '' do
+    #     "a"
+    #   end
+    #
+    # will return a 200 response for <tt>GET /</tt> and a 405
+    # response for <tt>POST /</tt>.
+    #
+    # This plugin changes the +r.root+ method to return a 405 status
+    # for non-GET requests to +/+.
+    #
+    # This plugin also changes the +r.is+ method so that if you use
+    # a verb method inside +r.is+, it returns a 405 status if none
+    # of the verb methods match.  So this code:
+    #
+    #   r.is '' do
+    #     r.get do
+    #       "a"
+    #     end
+    #
+    #     r.post do
+    #       "b"
+    #     end
+    #   end
+    #
+    # will return a 200 response for <tt>GET /</tt> and <tt>POST /</tt>,
+    # but a 405 response for <tt>PUT /</tt>.
+    #
+    # Note that this plugin will probably not do what you want for
+    # code such as:
+    #
+    #   r.get '' do
+    #     "a"
+    #   end
+    #
+    #   r.post '' do
+    #     "b"
+    #   end
+    #
+    # Since for a <tt>POST /</tt> request, when +r.get+ method matches
+    # the path but not the request method, it will return an immediate
+    # 405 response.  You must DRY up this code for it work correctly,
+    # like this:
+    #
+    #   r.is '' do
+    #     r.get do
+    #       "a"
+    #     end
+    #
+    #     r.post do
+    #       "b"
+    #     end
+    #   end
+    #
+    # In all cases where it uses a 405 response, it also sets the +Allow+
+    # header in the response to contain the request methods supported.
+    #
+    # This plugin depends on the all_verbs plugin.
+    module NotAllowed
+      REQUEST_INSTANCE_VARIABLES = [:@_is_verbs].freeze
+
+      # Depend on the all_verbs plugin, as this plugin overrides methods
+      # defined by it and calls super.
+      def self.load_dependencies(app)
+        app.plugin :all_verbs
+      end
+
+      module RequestMethods
+        # Keep track of verb calls inside the block.  If there are any
+        # verb calls inside the block, but the block returned, assume
+        # that the verb calls inside the block did not match, and
+        # since there was already a successful terminal match, the
+        # request method must not be allowed, so return a 405
+        # response in that case.
+        def is(*args)
+          super(*args) do
+            begin
+              is_verbs = @_is_verbs = []
+
+              ret = if args.empty?
+                yield
+              else
+                yield(*captures)
+              end
+
+              unless is_verbs.empty?
+                method_not_allowed(is_verbs.join(', '))
+              end
+
+              ret
+            ensure
+              @_is_verbs = nil
+            end
+          end
+        end
+
+        # Treat +r.root+ similar to <tt>r.get ''</tt>, using a 405
+        # response for non-GET requests.
+        def root
+          super
+          if @remaining_path == "/"  && !is_get?
+            always{method_not_allowed("GET")}
+          end
+        end
+
+        # Setup methods for all verbs.  If inside an is block and not given
+        # arguments, record the verb used.  If given an argument, add an is
+        # check with the arguments.
+        %w'get post delete head options link patch put trace unlink'.each do |verb|
+          if ::Rack::Request.method_defined?("#{verb}?")
+            class_eval(<<-END, __FILE__, __LINE__+1)
+              def #{verb}(*args, &block)
+                if (empty = args.empty?) && @_is_verbs
+                  @_is_verbs << "#{verb.to_s.upcase}"
+                end
+                super
+                unless empty
+                  is(*args){method_not_allowed("#{verb.to_s.upcase}")}
+                end
+              end
+            END
+          end
+        end
+
+        private
+
+        # Set the response status to 405 (Method Not Allowed), and set the Allow header
+        # to the given string of allowed request methods.
+        def method_not_allowed(verbs)
+          res = response
+          res.status = 405
+          res[RodaResponseHeaders::ALLOW] = verbs
+          nil
+        end
+      end
+    end
+
+    register_plugin(:not_allowed, NotAllowed)
+  end
+end