ultra-max-sys 0.0.1

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

@@ -0,0 +1,108 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The halt plugin augments the standard request +halt+ method to allow the response
+    # status, body, or headers to be changed when halting.
+    #
+    # After loading the halt plugin:
+    #
+    #   plugin :halt
+    #
+    # You can call the halt method with an integer to set the response status and return:
+    #   
+    #   route do |r|
+    #     r.halt(403)
+    #   end
+    #
+    # Or set the response body and return:
+    #
+    #   route do |r|
+    #     r.halt('body')
+    #   end
+    #
+    # Or set both:
+    #
+    #   route do |r|
+    #     r.halt(403, 'body')
+    #   end
+    #
+    # Or set response status, headers, and body:
+    #
+    #   route do |r|
+    #     r.halt(403, {'Content-Type'=>'text/csv'}, 'body')
+    #   end
+    #
+    # As supported by default, you can still pass an array which contains a rack response:
+    #
+    #   route do |r|
+    #     r.halt([403, {'Content-Type'=>'text/csv'}, ['body']])
+    #   end
+    #
+    # Note that there is a difference between providing status, headers, and body as separate
+    # arguments and providing them as a single rack response array.  With a rack response array,
+    # the values are used directly, while with 3 arguments, the headers given are merged into
+    # the existing headers and the given body is written to the existing response body.
+    #
+    # If using other plugins that recognize additional types of match block responses, such
+    # as +symbol_views+ and +json+, you can pass those additional types to +r.halt+:
+    #
+    #   plugin :halt
+    #   plugin :symbol_views
+    #   plugin :json
+    #   route do |r|
+    #     # symbol_views plugin, specifying template file to render as body
+    #     r.halt(:template) if r.params['a']
+    #
+    #     # symbol_views plugin, specifying status code, headers, and template file to render as body
+    #     r.halt(500, {'header'=>'value'}, :other_template) if r.params['c']
+    #
+    #     # json plugin, specifying status code and JSON body
+    #     r.halt(500, [{'error'=>'foo'}]) if r.params['b']
+    #   end
+    #
+    # Note that when using the +json+ plugin with the +halt+ plugin, you cannot return a
+    # array as a single argument and have it be converted to json, since it would be interpreted 
+    # as a rack response.  You must use call +r.halt+ with either two or three argument forms 
+    # in that case.
+    module Halt
+      module RequestMethods
+        # Expand default halt method to handle status codes, headers, and bodies.  See Halt.
+        def halt(*res)
+          case res.length
+          when 0 # do nothing
+          when 1
+            case v = res[0]
+            when Integer
+              response.status = v
+            when Array
+              throw :halt, v
+            else
+              if result = block_result_body(v)
+                response.write(result)
+              else
+                raise Roda::RodaError, "singular argument given to #halt not handled: #{v.inspect}"
+              end
+            end
+          when 2
+            resp = response
+            resp.status = res[0]
+            resp.write(block_result_body(res[1]))
+          when 3
+            resp = response
+            resp.status = res[0]
+            resp.headers.merge!(res[1])
+            resp.write(block_result_body(res[2]))
+          else
+            raise Roda::RodaError, "too many arguments given to #halt (accepts 0-3, received #{res.length})"
+          end
+
+          super()
+        end
+      end
+    end
+
+    register_plugin(:halt, Halt)
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The hash_branch_view_subdir plugin builds on the hash_branches and view_options
+    # plugins, automatically appending a view subdirectory for any matching hash branch
+    # taken. In cases where you are using a separate view subdirectory per hash branch,
+    # this can result in DRYer code. Example:
+    #
+    #   plugin :hash_branch_view_subdir
+    #
+    #   route do |r|
+    #     r.hash_branches
+    #   end
+    #
+    #   hash_branch 'foo' do |r|
+    #     # view subdirectory here is 'foo'
+    #     r.hash_branches('foo')
+    #   end
+    #
+    #   hash_branch 'foo', 'bar' do |r|
+    #     # view subdirectory here is 'foo/bar'
+    #   end
+    module HashBranchViewSubdir
+      def self.load_dependencies(app)
+        app.plugin :hash_branches
+        app.plugin :view_options
+      end
+
+      def self.configure(app)
+        app.opts[:hash_branch_view_subdir_methods] ||= {}
+      end
+
+      module ClassMethods
+        # Freeze the hash_branch_view_subdir metadata when freezing the app.
+        def freeze
+          opts[:hash_branch_view_subdir_methods].freeze.each_value(&:freeze)
+          super
+        end
+
+        # Duplicate hash_branch_view_subdir metadata in subclass.
+        def inherited(subclass)
+          super
+
+          h = subclass.opts[:hash_branch_view_subdir_methods]
+          opts[:hash_branch_view_subdir_methods].each do |namespace, routes|
+            h[namespace] = routes.dup
+          end
+        end
+
+        # Automatically append a view subdirectory for a successful hash_branch route,
+        # by modifying the generated method to append the view subdirectory before
+        # dispatching to the original block.
+        def hash_branch(namespace='', segment, &block)
+          meths = opts[:hash_branch_view_subdir_methods][namespace] ||= {}
+
+          if block
+            meth = meths[segment] = define_roda_method(meths[segment] || "_hash_branch_view_subdir_#{namespace}_#{segment}", 1, &convert_route_block(block))
+            super do |*_|
+              append_view_subdir(segment)
+              send(meth, @_request)
+            end
+          else
+            if meth = meths.delete(segment)
+              remove_method(meth)
+            end
+            super
+          end
+        end
+      end
+    end
+
+    register_plugin(:hash_branch_view_subdir, HashBranchViewSubdir)
+  end
+end

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

@@ -0,0 +1,145 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The hash_branches plugin allows for O(1) dispatch to multiple route tree branches,
+    # based on the next segment in the remaining path:
+    #
+    #   class App < Roda
+    #     plugin :hash_branches
+    #
+    #     hash_branch("a") do |r|
+    #       # /a branch
+    #     end
+    #
+    #     hash_branch("b") do |r|
+    #       # /b branch
+    #     end
+    #
+    #     route do |r|
+    #       r.hash_branches
+    #     end
+    #   end
+    #
+    # With the above routing tree, the +r.hash_branches+ call in the main routing tree
+    # will dispatch requests for the +/a+ and +/b+ branches of the tree to the appropriate
+    # routing blocks.
+    #
+    # In this example, the hash branches for +/a+ and +/b+ are in the same file, but in larger
+    # applications, they are usually stored in separate files.  This allows for easily splitting
+    # up the routing tree into a separate file per branch.
+    #
+    # The +hash_branch+ method supports namespaces, which allow for dispatching to sub-branches
+    # any level of the routing tree, fully supporting the needs of applications with large and
+    # deep routing branches:
+    #
+    #   class App < Roda
+    #     plugin :hash_branches
+    #
+    #     # Only one argument used, so the namespace defaults to '', and the argument
+    #     # specifies the route name
+    #     hash_branch("a") do |r|
+    #       # No argument given, so uses the already matched path as the namespace,
+    #       # which is '/a' in this case.
+    #       r.hash_branches
+    #     end
+    #
+    #     hash_branch("b") do |r|
+    #       # uses :b as the namespace when looking up routes, as that was explicitly specified
+    #       r.hash_branches(:b)
+    #     end
+    #
+    #     # Two arguments used, so first specifies the namespace and the second specifies
+    #     # the branch name
+    #     hash_branch("/a", "b") do |r|
+    #       # /a/b path
+    #     end
+    #
+    #     hash_branch("/a", "c") do |r|
+    #       # /a/c path 
+    #     end
+    #
+    #     hash_branch(:b, "b") do |r|
+    #       # /b/b path
+    #     end
+    #
+    #     hash_branch(:b, "c") do |r|
+    #       # /b/c path 
+    #     end
+    #
+    #     route do |r|
+    #       # No argument given, so uses '' as the namespace, as no part of the path has
+    #       # been matched yet
+    #       r.hash_branches
+    #     end
+    #   end
+    #
+    # With the above routing tree, requests for the +/a+ and +/b+ branches will be
+    # dispatched to the appropriate +hash_branch+ block.  Those blocks will the dispatch
+    # to the remaining +hash_branch+ blocks, with the +/a+ branch using the implicit namespace of
+    # +/a+, and the +/b+ branch using the explicit namespace of +:b+.
+    #
+    # It is best for performance to explicitly specify the namespace when calling
+    # +r.hash_branches+.
+    module HashBranches
+      def self.configure(app)
+        app.opts[:hash_branches] ||= {}
+      end
+
+      module ClassMethods
+        # Freeze the hash_branches metadata when freezing the app.
+        def freeze
+          opts[:hash_branches].freeze.each_value(&:freeze)
+          super
+        end
+
+        # Duplicate hash_branches metadata in subclass.
+        def inherited(subclass)
+          super
+
+          h = subclass.opts[:hash_branches]
+          opts[:hash_branches].each do |namespace, routes|
+            h[namespace] = routes.dup
+          end
+        end
+
+        # Add branch handler for the given namespace and segment. If called without
+        # a block, removes the existing branch handler if it exists.
+        def hash_branch(namespace='', segment, &block)
+          segment = "/#{segment}"
+          routes = opts[:hash_branches][namespace] ||= {}
+          if block
+            routes[segment] = define_roda_method(routes[segment] || "hash_branch_#{namespace}_#{segment}", 1, &convert_route_block(block))
+          elsif meth = routes.delete(segment)
+            remove_method(meth)
+          end
+        end
+      end
+
+      module RequestMethods
+        # Checks the matching hash_branch namespace for a branch matching the next
+        # segment in the remaining path, and dispatch to that block if there is one.
+        def hash_branches(namespace=matched_path)
+          rp = @remaining_path
+
+          return unless rp.getbyte(0) == 47 # "/"
+
+          if routes = roda_class.opts[:hash_branches][namespace]
+            if segment_end = rp.index('/', 1)
+              if meth = routes[rp[0, segment_end]]
+                @remaining_path = rp[segment_end, 100000000]
+                always{scope.send(meth, self)}
+              end
+            elsif meth = routes[rp]
+              @remaining_path = ''
+              always{scope.send(meth, self)}
+            end
+          end
+        end
+      end
+    end
+
+    register_plugin(:hash_branches, HashBranches)
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The hash_matcher plugin adds the hash_matcher class method, which
+    # allows for easily defining hash matchers:
+    #
+    #   class App < Roda
+    #     plugin :hash_matcher
+    #
+    #     hash_matcher(:foo) do |v|
+    #       params['foo'] == v
+    #     end
+    #
+    #     route do
+    #       r.on foo: 'bar' do
+    #         # matches when param foo has value bar
+    #       end
+    #     end
+    #   end
+    module HashMatcher
+      module ClassMethods
+        # Create a match_#{key} method in the request class using the given
+        # block, so that using a hash key in a request match method will
+        # call the block.  The block should return nil or false to not
+        # match, and anything else to match.  See the HashMatcher module
+        # documentation for an example.
+        def hash_matcher(key, &block)
+          meth = :"match_#{key}"
+          self::RodaRequest.send(:define_method, meth, &block)
+          self::RodaRequest.send(:private, meth)
+        end
+      end
+    end
+
+    register_plugin(:hash_matcher, HashMatcher)
+  end
+end

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

@@ -0,0 +1,128 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The hash_paths plugin allows for O(1) dispatch to multiple routes at any point
+    # in the routing tree.  It is useful when you have a large number of specific routes
+    # to dispatch to at any point in the routing tree.
+    #
+    # You configure the hash paths to dispatch to using the +hash_path+ class method,
+    # specifying the remaining path, with a block to handle that path.  Then you dispatch
+    # to the configured paths using +r.hash_paths+:
+    #
+    #   class App < Roda
+    #     plugin :hash_paths
+    #
+    #     hash_path("/a") do |r|
+    #       # /a path
+    #     end
+    #
+    #     hash_path("/a/b") do |r|
+    #       # /a/b path 
+    #     end
+    #
+    #     route do |r|
+    #       r.hash_paths
+    #     end
+    #   end
+    #
+    # With the above routing tree, the +r.hash_paths+ call will dispatch requests for the +/a+ and
+    # +/a/b+ request paths.
+    #
+    # The +hash_path+ class method supports namespaces, which allows +r.hash_paths+ to be used at
+    # any level of the routing tree.  Here is an example that uses namespaces for sub-branches:
+    #
+    #   class App < Roda
+    #     plugin :hash_paths
+    #
+    #     # Two arguments provided, so first argument is the namespace
+    #     hash_path("/a", "/b") do |r|
+    #       # /a/b path
+    #     end
+    #
+    #     hash_path("/a", "/c") do |r|
+    #       # /a/c path 
+    #     end
+    #
+    #     hash_path(:b, "/b") do |r|
+    #       # /b/b path
+    #     end
+    #
+    #     hash_path(:b, "/c") do |r|
+    #       # /b/c path 
+    #     end
+    #
+    #     route do |r|
+    #       r.on 'a' do
+    #         # No argument given, so uses the already matched path as the namespace,
+    #         # which is '/a' in this case.
+    #         r.hash_paths
+    #       end
+    #
+    #       r.on 'b' do
+    #         # uses :b as the namespace when looking up routes, as that was explicitly specified
+    #         r.hash_paths(:b)
+    #       end
+    #     end
+    #   end
+    #
+    # With the above routing tree, requests for the +/a+ branch will be handled by the first
+    # +r.hash_paths+ call, and requests for the +/b+ branch will be handled by the second
+    # +r.hash_paths+ call.  Those will dispatch to the configured hash paths for the +/a+ and
+    # +:b+ namespaces.
+    #
+    # It is best for performance to explicitly specify the namespace when calling
+    # +r.hash_paths+.
+    module HashPaths
+      def self.configure(app)
+        app.opts[:hash_paths] ||= {}
+      end
+
+      module ClassMethods
+        # Freeze the hash_paths metadata when freezing the app.
+        def freeze
+          opts[:hash_paths].freeze.each_value(&:freeze)
+          super
+        end
+
+        # Duplicate hash_paths metadata in subclass.
+        def inherited(subclass)
+          super
+
+          h = subclass.opts[:hash_paths]
+          opts[:hash_paths].each do |namespace, routes|
+            h[namespace] = routes.dup
+          end
+        end
+
+        # Add path handler for the given namespace and path. When the
+        # r.hash_paths method is called, checks the matching namespace
+        # for the full remaining path, and dispatch to that block if
+        # there is one.  If called without a block, removes the existing
+        # path handler if it exists.
+        def hash_path(namespace='', path, &block)
+          routes = opts[:hash_paths][namespace] ||= {}
+          if block
+            routes[path] = define_roda_method(routes[path] || "hash_path_#{namespace}_#{path}", 1, &convert_route_block(block))
+          elsif meth = routes.delete(path)
+            remove_method(meth)
+          end
+        end
+      end
+
+      module RequestMethods
+        # Checks the matching hash_path namespace for a branch matching the 
+        # remaining path, and dispatch to that block if there is one.
+        def hash_paths(namespace=matched_path)
+          if (routes = roda_class.opts[:hash_paths][namespace]) && (meth = routes[@remaining_path])
+            @remaining_path = ''
+            always{scope.send(meth, self)}
+          end
+        end
+      end
+    end
+
+    register_plugin(:hash_paths, HashPaths)
+  end
+end

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

@@ -0,0 +1,125 @@
+# frozen-string-literal: true
+
+class Roda
+  module RodaPlugins
+    # The hash_public plugin adds a +hash_path+ method for constructing
+    # content-hash-based paths, and a +r.hash_public+ routing method to serve
+    # static files from a directory (using the public plugin).  This plugin is
+    # useful when you want to modify the path to static files when the content
+    # of the file changes, ensuring that requests for the static file will not
+    # be cached.
+    #
+    # Unlike the timestamp_public plugin, which uses file modification times,
+    # hash_public uses a SHA256 digest of the file content.  This makes paths
+    # stable across different build environments (e.g. Docker images built in
+    # CI/CD pipelines), where file modification times may vary even when the
+    # file content has not changed.
+    #
+    # Note that while this plugin will not serve files outside of the public
+    # directory, for performance reasons it does not check the path of the file
+    # is inside the public directory when computing the content hash.  If the
+    # +hash_path+ method is called with untrusted input, it is possible for an
+    # attacker to read the content hash of any file on the file system.
+    #
+    # This plugin caches the digest of file content on first read. That means
+    # if you change the file after that, it will continue to show the old hash.
+    # This can cause problems in development mode if you are modifying the
+    # content of files served by the plugin. You can use the hash_public_cache
+    # plugin to scan the public directory in and store the digests in a file,
+    # avoiding the need for the process to read files to calculate the digest.
+    #
+    # Examples:
+    #
+    #   # Use public folder as location of files, and static as the path prefix
+    #   plugin :hash_public
+    #
+    #   # Use /path/to/app/static as location of files, and public as the path prefix
+    #   opts[:root] = '/path/to/app'
+    #   plugin :hash_public, root: 'static', prefix: 'public'
+    #
+    #   # Assuming public is the location of files, and static as the path prefix
+    #   route do
+    #     # Make GET /static/any-string/images/foo.png look for public/images/foo.png
+    #     r.hash_public
+    #
+    #     r.get "example" do
+    #       # "/static/sha256-url-safe-base64-encoded-file-digest-/images/foo.png"
+    #       hash_path("images/foo.png")
+    #     end
+    #   end
+    module HashPublic
+      Digest = begin
+        require 'openssl'
+        ::OpenSSL::Digest
+      # :nocov:
+      rescue LoadError
+        require 'digest/sha2'
+        ::Digest
+      # :nocov:
+      end
+
+      def self.load_dependencies(app, opts = OPTS)
+        app.plugin :public, opts
+      end
+
+      # Use options given to setup content-hash-based file serving.  The
+      # following options are recognized by the plugin:
+      #
+      # :prefix :: The prefix for paths, before the hash segment
+      # :length :: The number of characters of the digest to use in paths
+      #            (default: full 43-character SHA256 URL safe base64 digest)
+      #
+      # The options given are also passed to the public plugin.
+      def self.configure(app, opts = {})
+        app.opts[:hash_public_prefix] = (opts[:prefix] || app.opts[:hash_public_prefix] || 'static').dup.freeze
+        app.opts[:hash_public_length] = opts[:length] || app.opts[:hash_public_length]
+        app.opts[:hash_public_mutex] ||= Mutex.new
+        app.opts[:hash_public_cache] ||= {}
+      end
+
+      module ClassMethods
+        # The digest for the given file to use in hash_path.
+        def hash_path_digest(file)
+          opts = self.opts
+          cache = opts[:hash_public_cache]
+          mutex = opts[:hash_public_mutex]
+          unless digest = mutex.synchronize{cache[file]}
+            digest = Digest::SHA256.file(File.join(opts[:public_root], file)).base64digest
+            digest.chomp!("=")
+            digest.tr!("+/", "-_")
+            if length = opts[:hash_public_length]
+              digest = digest[0, length]
+            end
+            digest.freeze
+            mutex.synchronize{cache[file] = digest}
+          end
+          digest
+        end
+      end
+
+      module InstanceMethods
+        # Return a path to the static file that could be served by r.hash_public.
+        # This does not check the file is inside the directory for performance
+        # reasons, so this should not be called with untrusted input.
+        def hash_path(file)
+          "/#{opts[:hash_public_prefix]}/#{self.class.hash_path_digest(file)}/#{file}"
+        end
+      end
+
+      module RequestMethods
+        # Serve files from the public directory if the file exists,
+        # it includes the hash_public prefix segment followed by
+        # a string segment for the content hash, and this is a GET request.
+        def hash_public
+          if is_get?
+            on roda_class.opts[:hash_public_prefix], String do |_|
+              public
+            end
+          end
+        end
+      end
+    end
+
+    register_plugin(:hash_public, HashPublic)
+  end
+end