ultra-max-sys 0.0.1

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

@@ -0,0 +1,225 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The middleware plugin allows the Roda app to be used as
+    # rack middleware.
+    #
+    # In the example below, requests to /mid will return Mid
+    # by the Mid middleware, and requests to /app will not be
+    # matched by the Mid middleware, so they will be forwarded
+    # to App.
+    #
+    #   class Mid < Roda
+    #     plugin :middleware
+    #
+    #     route do |r|
+    #       r.is "mid" do
+    #         "Mid"
+    #       end
+    #     end
+    #   end
+    #
+    #   class App < Roda
+    #     use Mid
+    #
+    #     route do |r|
+    #       r.is "app" do
+    #         "App"
+    #       end
+    #     end
+    #   end
+    #
+    #   run App
+    #
+    # By default, when the app is used as middleware and handles the request at
+    # all, it does not forward the request to the next middleware.  For the
+    # following setup:
+    #
+    #   class Mid < Roda
+    #     plugin :middleware
+    #
+    #     route do |r|
+    #       r.on "foo" do
+    #         r.is "mid" do
+    #           "Mid"
+    #         end
+    #       end
+    #     end
+    #   end
+    #
+    #   class App < Roda
+    #     use Mid
+    #
+    #     route do |r|
+    #       r.on "foo" do
+    #         r.is "app" do
+    #           "App"
+    #         end
+    #       end
+    #     end
+    #   end
+    #
+    #   run App
+    #
+    # Requests for +/foo/mid will+ return +Mid+, but requests for +/foo/app+
+    # will return an empty 404 response, because the middleware handles the
+    # +/foo/app+ request in the <tt>r.on "foo" do</tt> block, but does not
+    # have the block return a result, which Roda treats as an empty 404 response.
+    # If you would like the middleware to forward +/foo/app+ request to the
+    # application, you should use the +:next_if_not_found+ plugin option.
+    #
+    # It is possible to use the Roda app as a regular app even when using
+    # the middleware plugin.  Using an app as middleware automatically creates
+    # a subclass of the app for the middleware.  Because a subclass is automatically
+    # created when the app is used as middleware, any configuration of the app
+    # should be done before using it as middleware instead of after.
+    #
+    # You can support configurable middleware by passing a block when loading
+    # the plugin:
+    #
+    #   class Mid < Roda
+    #     plugin :middleware do |middleware, *args, &block|
+    #       middleware.opts[:middleware_args] = args
+    #       block.call(middleware)
+    #     end
+    #
+    #     route do |r|
+    #       r.is "mid" do
+    #         opts[:middleware_args].join(' ')
+    #       end
+    #     end
+    #   end
+    #
+    #   class App < Roda
+    #     use Mid, :foo, :bar do |middleware|
+    #       middleware.opts[:middleware_args] << :baz
+    #     end
+    #   end
+    #
+    #   # Request to App for /mid returns
+    #   # "foo bar baz"
+    module Middleware
+      NEXT_PROC = lambda{throw :next, true}
+      private_constant :NEXT_PROC
+
+      # Configure the middleware plugin.  Options:
+      # :env_var :: Set the environment variable to use to indicate to the roda
+      #             application that the current request is a middleware request.
+      #             You should only need to override this if you are using multiple
+      #             roda middleware in the same application.
+      # :handle_result :: Callable object that will be called with request environment
+      #                   and rack response for all requests passing through the middleware,
+      #                   after either the middleware or next app handles the request
+      #                   and returns a response.
+      # :forward_response_headers :: Whether changes to the response headers made inside
+      #                              the middleware's route block should be applied to the
+      #                              final response when the request is forwarded to the app.
+      #                              Defaults to false.
+      # :next_if_not_found :: If the middleware handles the request but returns a not found
+      #                       result (404 with no body), forward the result to the next middleware.
+      def self.configure(app, opts={}, &block)
+        app.opts[:middleware_env_var] = opts[:env_var] if opts.has_key?(:env_var)
+        app.opts[:middleware_env_var] ||= 'roda.forward_next'
+        app.opts[:middleware_configure] = block if block
+        app.opts[:middleware_handle_result] = opts[:handle_result]
+        app.opts[:middleware_forward_response_headers] = opts[:forward_response_headers]
+        app.opts[:middleware_next_if_not_found] = opts[:next_if_not_found]
+      end
+
+      # Forwarder instances are what is actually used as middleware.
+      class Forwarder
+        # Make a subclass of +mid+ to use as the current middleware,
+        # and store +app+ as the next middleware to call.
+        def initialize(mid, app, *args, &block)
+          @mid = Class.new(mid)
+          RodaPlugins.set_temp_name(@mid){"#{mid}::middleware_subclass"}
+          if @mid.opts[:middleware_next_if_not_found]
+            @mid.plugin(:not_found, &NEXT_PROC)
+          end
+          if configure = @mid.opts[:middleware_configure]
+            configure.call(@mid, *args, &block)
+          elsif block || !args.empty?
+            raise RodaError, "cannot provide middleware args or block unless loading middleware plugin with a block"
+          end
+          @app = app
+        end
+
+        # When calling the middleware, first call the current middleware.
+        # If this returns a result, return that result directly.  Otherwise,
+        # pass handling of the request to the next middleware.
+        def call(env)
+          res = nil
+
+          call_next = catch(:next) do
+            env[@mid.opts[:middleware_env_var]] = true
+            res = @mid.call(env)
+            false
+          end
+
+          if call_next
+            res = @app.call(env)
+
+            if modified_headers = env.delete('roda.response_headers')
+              res[1] = modified_headers.merge(res[1])
+            end
+          end
+
+          if handle_result = @mid.opts[:middleware_handle_result]
+            handle_result.call(env, res)
+          end
+
+          res
+        end
+      end
+
+      module ClassMethods
+        # Create a Forwarder instead of a new instance if a non-Hash is given.
+        def new(app, *args, &block)
+          if app.is_a?(Hash)
+            super
+          else
+            Forwarder.new(self, app, *args, &block)
+          end
+        end
+      end
+
+      module InstanceMethods
+        # Override the route block so that if no route matches, we throw so
+        # that the next middleware is called. Old Dispatch API.
+        def call(&block)
+          super do |r|
+            res = instance_exec(r, &block) # call Fallback
+            if r.forward_next
+              r.env['roda.response_headers'] = response.headers if opts[:middleware_forward_response_headers]
+              throw :next, true
+            end
+            res
+          end
+        end
+
+        # Override the route block so that if no route matches, we throw so
+        # that the next middleware is called.
+        def _roda_run_main_route(r)
+          res = super
+          if r.forward_next
+            r.env['roda.response_headers'] = response.headers if opts[:middleware_forward_response_headers]
+            throw :next, true
+          end
+          res
+        end
+      end
+
+      module RequestMethods
+        # Whether to forward the request to the next application.  Set only if
+        # this request is being performed for middleware.
+        def forward_next
+          env[roda_class.opts[:middleware_env_var]]
+        end
+      end
+    end
+
+    register_plugin(:middleware, Middleware)
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The middleware_stack plugin adds methods to remove middleware
+    # from the middleware stack, and insert new middleware at specific
+    # positions in the middleware stack.
+    #
+    #   plugin :middleware_stack
+    #
+    #   # Remove csrf middleware
+    #   middleware_stack.remove{|m, *args| m == Rack::Csrf}
+    #
+    #   # Insert csrf middleware
+    #   middleware_stack.before{|m, *args| m == Rack::CommonLogger}.use(Rack::Csrf, raise: true)
+    #   middleware_stack.after{|m, *args| m == Rack::CommonLogger}.use(Rack::Csrf, raise: true)
+    module MiddlewareStack
+      # Represents a specific position in the application's middleware stack where new
+      # middleware can be inserted.
+      class StackPosition
+        def initialize(app, middleware, position)
+          @app = app
+          @middleware = middleware
+          @position = position
+        end
+
+        # Insert a new middleware into the current position in the middleware stack.
+        # Increments the position so that calling this multiple times adds later
+        # middleware after earlier middleware, similar to how +Roda.use+ works.
+        def use(*args, &block)
+          @middleware.insert(@position, [args, block])
+          @app.send(:build_rack_app)
+          @position += 1
+          nil
+        end
+      end
+
+      # Represents the applications middleware as a stack, allowing for easily
+      # removing middleware or finding places to insert new middleware.
+      class Stack
+        def initialize(app, middleware)
+          @app = app
+          @middleware = middleware
+        end
+
+        # Return a StackPosition representing the position after the middleware where
+        # the block returns true. Yields the middleware and any middleware arguments
+        # given, but not the middleware block.
+        # It the block never returns true, returns a StackPosition that will insert
+        # new middleware at the end of the stack.
+        def after(&block)
+          handle(1, &block)
+        end
+
+        # Return a StackPosition representing the position before the middleware where
+        # the block returns true. Yields the middleware and any middleware arguments
+        # given, but not the middleware block.
+        # It the block never returns true, returns a StackPosition that will insert
+        # new middleware at the end of the stack.
+        def before(&block)
+          handle(0, &block)
+        end
+
+        # Removes any middleware where the block returns true. Yields the middleware
+        # and any middleware arguments given, but not the middleware block
+        def remove
+          @middleware.delete_if do |m, _|
+            yield(*m)
+          end
+          @app.send(:build_rack_app)
+          nil
+        end
+
+        private
+
+        # Internals of before and after.
+        def handle(offset)
+          @middleware.each_with_index do |(m, _), i|
+            if yield(*m)
+              return StackPosition.new(@app, @middleware, i+offset)
+            end
+          end
+
+          StackPosition.new(@app, @middleware, @middleware.length)
+        end
+      end
+
+      module ClassMethods
+        # Return a new Stack that allows removing middleware and inserting
+        # middleware at specific places in the stack.
+        def middleware_stack
+          Stack.new(self, @middleware)
+        end
+      end
+    end
+
+    register_plugin(:middleware_stack, MiddlewareStack)
+  end
+end
+

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

@@ -0,0 +1,96 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The module_include plugin adds request_module and response_module class methods
+    # for adding modules/methods to request/response classes.  It's designed to make
+    # it easier to add request/response methods for a given roda class.  To add a module
+    # to the request or response class:
+    #
+    #   Roda.request_module SomeRequestModule
+    #   Roda.response_module SomeResponseModule
+    #
+    # Alternatively, you can pass a block to the methods and it will create a module
+    # automatically:
+    #
+    #   Roda.request_module do
+    #     def description
+    #       "#{request_method} #{path_info}"
+    #     end
+    #   end
+    module ModuleInclude
+      module ClassMethods
+        # Include the given module in the request class. If a block
+        # is provided instead of a module, create a module using the
+        # the block. Example:
+        #
+        #   Roda.request_module SomeModule
+        #
+        #   Roda.request_module do
+        #     def description
+        #       "#{request_method} #{path_info}"
+        #     end
+        #   end
+        #
+        #   Roda.route do |r|
+        #     r.description
+        #   end
+        def request_module(mod = nil, &block)
+          module_include(:request, mod, &block)
+        end
+    
+        # Include the given module in the response class. If a block
+        # is provided instead of a module, create a module using the
+        # the block. Example:
+        #
+        #   Roda.response_module SomeModule
+        #
+        #   Roda.response_module do
+        #     def error!
+        #       self.status = 500
+        #     end
+        #   end
+        #
+        #   Roda.route do |r|
+        #     response.error!
+        #   end
+        def response_module(mod = nil, &block)
+          module_include(:response, mod, &block)
+        end
+
+        private
+
+        # Backbone of the request_module and response_module methods.
+        def module_include(type, mod, &block)
+          if type == :response
+            klass = self::RodaResponse
+            iv = :@response_module
+          else
+            klass = self::RodaRequest
+            iv = :@request_module
+          end
+
+          if mod
+            raise RodaError, "can't provide both argument and block to response_module" if defined?(yield)
+            klass.send(:include, mod)
+          else
+            if instance_variable_defined?(iv)
+              mod = instance_variable_get(iv)
+            else
+              mod = instance_variable_set(iv, Module.new)
+              RodaPlugins.set_temp_name(mod){"#{klass}::module_include"}
+              klass.send(:include, mod)
+            end
+
+            mod.module_eval(&block) if block
+          end
+
+          mod
+        end
+      end
+    end
+
+    register_plugin(:module_include, ModuleInclude)
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen-string-literal: true
+
+begin
+  require 'rack/files'
+rescue LoadError
+  require 'rack/file'
+end
+
+#
+class Roda
+  module RodaPlugins
+    # The multi_public plugin adds an +r.multi_public+ method that accepts an argument specifying
+    # a directory from which to serve static files.  It is similar to the public plugin, but
+    # allows for multiple separate directories.
+    #
+    # Here's an example of using the multi_public plugin to serve 3 different types of files
+    # from 3 different directories:
+    #
+    #   plugin :multi_public,
+    #     img:  'static/images',
+    #     font: 'assets/fonts',
+    #     form: 'static/forms/pdfs'
+    #
+    #   route do
+    #     r.on "images" do
+    #       r.multi_public(:img)
+    #     end
+    #
+    #     r.on "fonts" do
+    #       r.multi_public(:font)
+    #     end
+    #
+    #     r.on "forms" do
+    #       r.multi_public(:form)
+    #     end
+    #   end
+    #
+    # It is possible to simplify the routing tree for this using string keys and an array
+    # matcher:
+    # 
+    #   plugin :multi_public,
+    #     'images' => 'static/images',
+    #     'fonts'  => 'assets/fonts',
+    #     'forms'  => 'static/forms/pdfs'
+    #
+    #   route do
+    #     r.on %w"images fonts forms" do |dir|
+    #       r.multi_public(dir)
+    #     end
+    #   end
+    #
+    # You can provide custom headers and default mime type for each directory using an array
+    # of three elements as the value, with the first element being the path, the second
+    # being the custom headers, and the third being the default mime type:
+    #
+    #   plugin :multi_public,
+    #     'images' => ['static/images', {'Cache-Control'=>'max-age=86400'}, nil],
+    #     'fonts'  => ['assets/fonts', {'Cache-Control'=>'max-age=31536000'}, 'font/ttf'],
+    #     'forms'  => ['static/forms/pdfs', nil, 'application/pdf']
+    #
+    #   route do
+    #     r.on %w"images fonts forms" do |dir|
+    #       r.multi_public(dir)
+    #     end
+    #   end
+    module MultiPublic
+      RACK_FILES = defined?(Rack::Files) ? Rack::Files : Rack::File
+
+      def self.load_dependencies(app, _, opts=OPTS)
+        app.plugin(:public, opts)
+      end
+
+      # Use the given directories to setup servers.  Any opts are passed to the public plugin.
+      def self.configure(app, directories, _=OPTS)
+        roots = app.opts[:multi_public_servers] = (app.opts[:multi_public_servers] || {}).dup
+        directories.each do |key, path|
+          path, headers, mime = path
+          roots[key] = RACK_FILES.new(app.expand_path(path), headers||{}, mime||'text/plain')
+        end
+        roots.freeze
+      end
+
+      module RequestMethods
+        # Serve files from the directory corresponding to the given key if the file exists and
+        # this is a GET request.
+        def multi_public(key)
+          public_serve_with(roda_class.opts[:multi_public_servers].fetch(key))
+        end
+      end
+    end
+
+    register_plugin(:multi_public, MultiPublic)
+  end
+end
+

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

@@ -0,0 +1,156 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The multi_route plugin builds on the named_routes plugin and allows for
+    # dispatching to multiple named routes # by calling the +r.multi_route+ method,
+    # which will check # if the first segment in the path matches a named route,
+    # and dispatch to that named route.
+    #
+    # The hash_branches plugin offers a +r.hash_branches+ method that is similar to
+    # and performs better than the +r.multi_route+ method, and it is recommended
+    # to consider using that instead of this plugin.
+    #
+    # Example:
+    #
+    #   plugin :multi_route
+    #
+    #   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.multi_route
+    #   end
+    #
+    # Note that only named routes with string names will be dispatched to by the
+    # +r.multi_route+ method. Named routes with other names can be dispatched to
+    # using the named_routes plugin API, but will not be automatically dispatched
+    # to by +r.multi_route+.
+    #
+    # You can provide a block to +r.multi_route+ that is
+    # called if the route matches but the named route did not handle the
+    # request:
+    #
+    #   r.multi_route do
+    #     "default body"
+    #   end
+    # 
+    # If a block is not provided to multi_route, the return value of the named
+    # route block will be used.
+    #
+    # == Namespace Support
+    #
+    # The multi_route plugin also has support for namespaces, allowing you to
+    # use +r.multi_route+ at multiple levels in your routing tree.  Example:
+    #
+    #   route('foo') do |r|
+    #     r.multi_route('foo')
+    #   end
+    #
+    #   route('bar') do |r|
+    #     r.multi_route('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.multi_route
+    #   end
+    module MultiRoute
+      def self.load_dependencies(app)
+        app.plugin :named_routes
+      end
+
+      # Initialize storage for the named routes.
+      def self.configure(app)
+        app::RodaRequest.instance_variable_set(:@namespaced_route_regexps, {})
+      end
+
+      module ClassMethods
+        # Freeze the multi_route regexp matchers so that there can be no thread safety issues at runtime.
+        def freeze
+          super
+          opts[:namespaced_routes].each_key do |k|
+            self::RodaRequest.named_route_regexp(k)
+          end
+          self::RodaRequest.instance_variable_get(:@namespaced_route_regexps).freeze
+          self
+        end
+
+        # Copy the named routes into the subclass when inheriting.
+        def inherited(subclass)
+          super
+          subclass::RodaRequest.instance_variable_set(:@namespaced_route_regexps, {})
+        end
+
+        # Clear the multi_route regexp matcher for the namespace.
+        def route(name=nil, namespace=nil, &block)
+          super
+          if name
+            self::RodaRequest.clear_named_route_regexp!(namespace)
+          end
+        end
+      end
+
+      module RequestClassMethods
+        # Clear cached regexp for named routes, it will be regenerated
+        # the next time it is needed.
+        #
+        # This shouldn't be an issue in production applications, but
+        # during development it's useful to support new named routes
+        # being added while the application is running.
+        def clear_named_route_regexp!(namespace=nil)
+          @namespaced_route_regexps.delete(namespace)
+        end
+
+        # A regexp matching any of the current named routes.
+        def named_route_regexp(namespace=nil)
+          @namespaced_route_regexps[namespace] ||= /(#{Regexp.union(roda_class.named_routes(namespace).select{|s| s.is_a?(String)}.sort.reverse)})/
+        end
+      end
+
+      module RequestMethods
+        # Check if the first segment in the path matches any of the current
+        # named routes.  If so, call that named route.  If not, do nothing.
+        # If the named route does not handle the request, and a block
+        # is given, yield to the block.
+        def multi_route(namespace=nil)
+          on self.class.named_route_regexp(namespace) do |section|
+            res = route(section, namespace)
+            if defined?(yield)
+              yield
+            else
+              res
+            end
+          end
+        end
+      end
+    end
+
+    register_plugin(:multi_route, MultiRoute)
+  end
+end