ultra-max-sys 0.0.1

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

@@ -0,0 +1,91 @@
+# frozen-string-literal: true
+
+require 'json'
+require 'find'
+
+class Roda
+  module RodaPlugins
+    # The hash_public_cache plugin builds on top of the hash_public plugin and
+    # adds the ability to store the digests for the public files in a json file,
+    # and load that file at startup, which avoids the need for the process to
+    # read the public file in order to compute the digest.
+    #
+    # Examples:
+    #
+    #   # Load the plugin. Options given will be passed to public and hash_public.
+    #   plugin :hash_public_cache, "path/to/cache_file.json"
+    #
+    #   # When rebuilding the cache:
+    #   #
+    #   # * Scan the public directory for files, calculate the digest on each.
+    #   # * Write the hash public cache to a file.
+    #   #
+    #   # This is split into separate steps in case you want to modify the cache
+    #   # manually after the scan.
+    #   scan_hash_public_cache_dir
+    #   dump_hash_public_cache_file 
+    #
+    #   # To load the cache at application startup (if the file exists):
+    #   load_hash_public_cache_file
+    module HashPublicCache
+      def self.load_dependencies(app, _cache_file, opts = OPTS)
+        app.plugin :hash_public, opts
+      end
+
+      # Specify the location of the hash public cache file.
+      #
+      # The options given are passed to the hash_public plugin.
+      def self.configure(app, cache_file, opts = OPTS)
+        app.opts[:hash_public_cache_file] = cache_file
+      end
+
+      module ClassMethods
+        # Load the hash public cache file, if it exists. This replaces the hash
+        # public cache with the values from the file.
+        def load_hash_public_cache_file
+          file = opts[:hash_public_cache_file]
+          return unless File.file?(file)
+
+          cache = opts[:hash_public_cache] = (opts[:json_parser] || ::JSON.method(:parse)).call(::File.read(file))
+          cache.each_value(&:freeze)
+          nil
+        end
+
+        # Scan the public directory for files, computing the hash public digest
+        # for each. This will not rescan files that already have digest values.
+        # If a block is given, it will only calculate the digest for the file
+        # if the block returns truthy.
+        def scan_hash_public_cache_dir
+          cache = opts[:hash_public_cache]
+
+          # Public root doesn't have trailing slash even if given, as
+          # File.expand_path removes it.
+          root = opts[:public_root] + File::SEPARATOR
+
+          Find.find(opts[:public_root]) do |file|
+            if File.file?(file)
+              file = file.sub(root, '')
+              next if cache[file]
+
+              if defined?(yield)
+                next unless yield file
+              end
+
+              cache[file] = hash_path_digest(file)
+            end
+          end
+
+          nil
+        end
+
+        # Write the current hash public cache to the cache file.
+        def dump_hash_public_cache_file
+          File.write(opts[:hash_public_cache_file], (opts[:json_serializer] || :to_json.to_proc).call(opts[:hash_public_cache]))
+          nil
+        end
+      end
+    end
+
+    register_plugin(:hash_public_cache, HashPublicCache)
+  end
+end

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

@@ -0,0 +1,304 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The hash_routes plugin builds on top of the hash_branches and hash_paths plugins, and adds
+    # a DSL for configuring hash branches and paths. It also adds an +r.hash_routes+ method for
+    # first attempting dispatch to the configured hash_paths, then to the configured hash_branches:
+    #
+    #   class App < Roda
+    #     plugin :hash_routes
+    #
+    #     hash_branch("a") do |r|
+    #       # /a branch
+    #     end
+    #
+    #     hash_branch("b") do |r|
+    #       # /b branch
+    #     end
+    #
+    #     hash_path("/a") do |r|
+    #       # /a path
+    #     end
+    #
+    #     hash_path("/a/b") do |r|
+    #       # /a/b path 
+    #     end
+    #
+    #     route do |r|
+    #       r.hash_routes
+    #     end
+    #   end
+    #
+    # With the above routing tree, requests for +/a+ and +/a/b+ will be routed to the appropriate
+    # +hash_path+ block.  Other requests for the +/a+ branch, and all requests for the +/b+
+    # branch will be routed to the appropriate +hash_branch+ block.
+    #
+    # It is best for performance to explicitly specify the namespace when calling
+    # +r.hash_routes+.
+    #
+    # Because specifying routes explicitly using the +hash_branch+ and +hash_path+
+    # class methods can get repetitive, the hash_routes plugin offers a DSL for DRYing
+    # the code up.  This DSL is used by calling the +hash_routes+ class method.  The
+    # DSL used tries to mirror the standard Roda DSL, but it is not a normal routing
+    # tree (it's not possible to execute arbitrary code between branches during routing).
+    #
+    #   class App < Roda
+    #     plugin :hash_routes
+    #
+    #     # No block argument is used, DSL evaluates block using instance_exec 
+    #     hash_routes "" do
+    #       # on method is used for routing to next segment,
+    #       # for similarity to standard Roda
+    #       on "a" do |r|
+    #         r.hash_routes '/a'
+    #       end
+    #
+    #       on "b" do |r|
+    #         r.hash_routes(:b)
+    #       end
+    #     end
+    #
+    #     # Block argument is used, block is yielded DSL instance
+    #     hash_routes "/a" do |hr|
+    #       # is method is used for routing to the remaining path,
+    #       # for similarity to standard Roda
+    #       hr.is "b" do |r|
+    #         # /a/b path
+    #       end
+    #
+    #       hr.is "c" do |r|
+    #         # /a/c path 
+    #       end
+    #     end
+    #
+    #     hash_routes :b do
+    #       is "b" do |r|
+    #         # /b/b path
+    #       end
+    #
+    #       is "c" do |r|
+    #         # /b/c path 
+    #       end
+    #     end
+    #
+    #     route do |r|
+    #       # No change here, DSL only makes setup DRYer
+    #       r.hash_branches
+    #     end
+    #   end
+    #
+    # The +hash_routes+ DSL also offers some additional features to handle additional
+    # cases.  It supports verb methods, such as +get+ and +post+, which operate like
+    # +is+, but are only called if the verb matches (and are not yielded the request).
+    # It supports a +view+ method for routes that only render views, as well as a
+    # +views+ method for setting up routes for multiple views in a single call, which
+    # is a good replacement for the +multi_view+ plugin.
+    # +is+, +view+, and the verb methods can use a value of +true+ for the empty
+    # remaining path (as the empty string specifies the <tt>"/"</tt> remaining path).
+    # It also supports a +dispatch_from+ method, allowing you to setup dispatching to
+    # current group of routes from a higher-level namespace.
+    # The +hash_routes+ class method will return the DSL instance, so you are not
+    # limited to using it with a block.
+    #
+    # Here's the above example modified to use some of these features:
+    #
+    #   class App < Roda
+    #     plugin :hash_routes
+    #
+    #     hash_routes "/a" do
+    #       # Dispatch requests for the /a branch from the empty (default) routing
+    #       # namespace to this namespace
+    #       dispatch_from "a"
+    #
+    #       # Handle GET /a path, render "a" template, returning 404 for non-GET requests
+    #       view true, "a"
+    #
+    #       # Handle /a/b path, returning 404 for non-GET requests
+    #       get "b" do
+    #         # GET /a/b path
+    #       end
+    #
+    #       # Handle /a/c path, returning 404 for non-POST requests
+    #       post "c" do
+    #         # POST /a/c path 
+    #       end
+    #     end
+    #
+    #     bhr = hash_routes(:b)
+    #
+    #     # Dispatch requests for the /b branch from the empty routing to this namespace,
+    #     # but first check routes in the :b_preauth namespace.  If there is no
+    #     # matching route in the :b_preauth namespace, call the check_authenticated!
+    #     # method before dispatching to any of the routes in this namespace
+    #     bhr.dispatch_from "", "b" do |r|
+    #       r.hash_routes :b_preauth
+    #       check_authenticated!
+    #     end
+    #
+    #     bhr.is true do |r|
+    #       # /b path
+    #     end
+    #
+    #     bhr.is "" do |r|
+    #       # /b/ path 
+    #     end
+    #
+    #     # GET /b/d path, render 'd2' template, returning 404 for non-GET requests
+    #     bhr.views 'd', 'd2'
+    #
+    #     # GET /b/e path, render 'e' template, returning 404 for non-GET requests
+    #     # GET /b/f path, render 'f' template, returning 404 for non-GET requests
+    #     bhr.views %w'e f'
+    #
+    #     route do |r|
+    #       r.hash_branches
+    #     end
+    #   end
+    #
+    # The +view+ and +views+ method depend on the render plugin being loaded, but this
+    # plugin does not load the render plugin.  You must load the render plugin separately
+    # if you want to use the +view+ and +views+ methods.
+    #
+    # Certain parts of the +hash_routes+ DSL support do not work with the
+    # route_block_args plugin, as doing so would reduce performance.  These are:
+    #
+    # * dispatch_from
+    # * view
+    # * views
+    # * all verb methods (get, post, etc.)
+    module HashRoutes
+      def self.load_dependencies(app)
+        app.plugin :hash_branches
+        app.plugin :hash_paths
+      end
+
+      def self.configure(app)
+        app.opts[:hash_routes_methods] ||= {}
+      end
+
+      # Internal class handling the internals of the +hash_routes+ class method blocks.
+      class DSL
+        def initialize(roda, namespace)
+          @roda = roda
+          @namespace = namespace
+        end
+
+        # Setup the given branch in the given namespace to dispatch to routes in this
+        # namespace.  If a block is given, call the block with the request before
+        # dispatching to routes in this namespace.
+        def dispatch_from(namespace='', branch, &block)
+          ns = @namespace
+          if block
+            meth_hash = @roda.opts[:hash_routes_methods]
+            key = [:dispatch_from, namespace, branch].freeze
+            meth = meth_hash[key] = @roda.define_roda_method(meth_hash[key] || "hash_routes_dispatch_from_#{namespace}_#{branch}", 1, &block)
+            @roda.hash_branch(namespace, branch) do |r|
+              send(meth, r)
+              r.hash_routes(ns)
+            end
+          else
+            @roda.hash_branch(namespace, branch) do |r|
+              r.hash_routes(ns)
+            end
+          end
+        end
+
+        # Use the segment to setup a branch in the current namespace.
+        def on(segment, &block)
+          @roda.hash_branch(@namespace, segment, &block)
+        end
+
+        # Use the segment to setup a path in the current namespace.
+        # If path is given as a string, it is prefixed with a slash.
+        # If path is +true+, the empty string is used as the path.
+        def is(path, &block)
+          path = path == true ? "" : "/#{path}"
+          @roda.hash_path(@namespace, path, &block)
+        end
+
+        # Use the segment to setup a path in the current namespace that
+        # will render the view with the given name if the GET method is
+        # used, and will return a 404 if another request method is used.
+        # If path is given as a string, it is prefixed with a slash.
+        # If path is +true+, the empty string is used as the path.
+        def view(path, template)
+          path = path == true ? "" : "/#{path}"
+          @roda.hash_path(@namespace, path) do |r|
+            r.get do
+              view(template)
+            end
+          end
+        end
+
+        # For each template in the array of templates, setup a path in
+        # the current namespace for the template using the same name
+        # as the template.
+        def views(templates)
+          templates.each do |template|
+            view(template, template)
+          end
+        end
+
+        [:get, :post, :delete, :head, :options, :link, :patch, :put, :trace, :unlink].each do |meth|
+          define_method(meth) do |path, &block|
+            verb(meth, path, &block)
+          end
+        end
+
+        private
+        
+        # Setup a path in the current namespace for the given request method verb.
+        # Returns 404 for requests for the path with a different request method.
+        def verb(verb, path, &block)
+          path = path == true ? "" : "/#{path}"
+          meth_hash = @roda.opts[:hash_routes_methods]
+          key = [@namespace, path].freeze
+          meth = meth_hash[key] = @roda.define_roda_method(meth_hash[key] || "hash_routes_#{@namespace}_#{path}", 0, &block)
+          @roda.hash_path(@namespace, path) do |r|
+            r.send(verb) do
+              send(meth)
+            end
+          end
+        end
+      end
+
+      module ClassMethods
+        # Freeze the hash_routes metadata when freezing the app.
+        def freeze
+          opts[:hash_routes_methods].freeze
+          super
+        end
+
+        # Invoke the DSL for configuring hash routes, see DSL for methods inside the
+        # block.  If the block accepts an argument, yield the DSL instance.  If the
+        # block does not accept an argument, instance_exec the block in the context
+        # of the DSL instance.
+        def hash_routes(namespace='', &block)
+          dsl = DSL.new(self, namespace)
+          if block
+            if block.arity == 1
+              yield dsl
+            else
+              dsl.instance_exec(&block)
+            end
+          end
+
+          dsl
+        end
+      end
+
+      module RequestMethods
+        # Check for matches in both the hash_path and hash_branch namespaces for
+        # a matching remaining path or next segment in the remaining path, respectively.
+        def hash_routes(namespace=matched_path)
+          hash_paths(namespace)
+          hash_branches(namespace)
+        end
+      end
+    end
+
+    register_plugin(:hash_routes, HashRoutes)
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The head plugin attempts to automatically handle HEAD requests,
+    # by treating them as GET requests and returning an empty body
+    # without modifying the response status or response headers.
+    #
+    # So for the following routes,
+    #
+    #   route do |r|
+    #     r.root do
+    #       'root'
+    #     end
+    #
+    #     r.get 'a' do
+    #       'a'
+    #     end
+    #
+    #     r.is 'b', method: [:get, :post] do
+    #       'b'
+    #     end
+    #   end
+    #
+    # HEAD requests for +/+, +/a+, and +/b+ will all return 200 status
+    # with an empty body.
+    #
+    # This plugin also works with the not_allowed plugin if it is loaded
+    # after the not_allowed plugin.  In that case, if GET is one of Allow
+    # header options, then HEAD will be as well.
+    #
+    # NOTE: if you have a public facing website it is recommended that
+    # you enable this plugin, or manually handle HEAD anywhere you would
+    # handle GET. Search engines and other bots may send a
+    # HEAD request prior to crawling a page with a GET request. Without
+    # this plugin those HEAD requests will return a 404 status, which
+    # may prevent search engines from crawling your website.
+    module Head
+      # used to ensure proper resource release on HEAD requests
+      # we do not respond to a to_path method, here.
+      class CloseLater
+        def initialize(body)
+          @body = body
+        end
+
+        # yield nothing
+        def each(&_)
+        end
+
+        # this should be called by the Rack server
+        def close
+          @body.close
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # Always use an empty response body for head requests, with a
+        # content length of 0.
+        def _roda_after_30__head(res)
+          if res && @_request.head?
+            body = res[2]
+            if body.respond_to?(:close)
+              res[2] = CloseLater.new(body)
+            else
+              res[2] = EMPTY_ARRAY
+            end
+          end
+        end
+      end
+
+      module RequestMethods
+        # Consider HEAD requests as GET requests.
+        def is_get?
+          super || head?
+        end
+
+        private
+
+        # If the current request is a HEAD request, match if one of
+        # the given methods is a GET request.
+        def match_method(method)
+          super || (!method.is_a?(Array) && head? && method.to_s.upcase == 'GET')
+        end
+
+        # Work with the not_allowed plugin so that if GET is one
+        # of the Allow header options, then HEAD is as well.
+        def method_not_allowed(verbs)
+          verbs = verbs.sub('GET', 'HEAD, GET')
+          super
+        end
+      end
+    end
+
+    register_plugin(:head, Head)
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The header_matchers plugin adds hash matchers for matching on less-common
+    # HTTP headers.
+    #
+    #   plugin :header_matchers
+    #
+    # It adds a +:header+ matcher for matching on arbitrary headers, which matches
+    # if the header is present, and yields the header value:
+    #
+    #   r.on header: 'HTTP-X-App-Token' do |header_value|
+    #     # Looks for env['HTTP_X_APP_TOKEN'] and yields it
+    #   end
+    #
+    # It adds a +:host+ matcher for matching by the host of the request:
+    #
+    #   r.on host: 'foo.example.com' do
+    #   end
+    #
+    # For regexp values of the +:host+ matcher, any captures are yielded to the block:
+    #
+    #   r.on host: /\A(\w+).example.com\z/ do |subdomain|
+    #   end
+    #
+    # It adds a +:user_agent+ matcher for matching on a user agent patterns, which
+    # yields the regexp captures to the block:
+    #
+    #   r.on user_agent: /Chrome\/([.\d]+)/ do |chrome_version|
+    #   end
+    #
+    # It adds an +:accept+ matcher for matching based on the Accept header:
+    #
+    #   r.on accept: 'text/csv' do
+    #   end
+    #
+    # Note that the +:accept+ matcher is very simple and cannot handle wildcards,
+    # priorities, or anything but a simple comma separated list of mime types.
+    module HeaderMatchers
+      module RequestMethods
+        private
+
+        # Match if the given mimetype is one of the accepted mimetypes.
+        def match_accept(mimetype)
+          if @env["HTTP_ACCEPT"].to_s.split(',').any?{|s| s.strip == mimetype}
+            response[RodaResponseHeaders::CONTENT_TYPE] = mimetype
+          end
+        end
+
+        # Match if the given uppercase key is present inside the environment.
+        def match_header(key)
+          key = key.upcase
+          key.tr!("-","_")
+          unless key == "CONTENT_TYPE" || key == "CONTENT_LENGTH"
+            key = "HTTP_#{key}"
+          end
+          if v = @env[key]
+            @captures << v
+          end
+        end
+
+        # Match if the host of the request is the same as the hostname.  +hostname+
+        # can be a regexp or a string.
+        def match_host(hostname)
+          if hostname.is_a?(Regexp)
+            if match = hostname.match(host)
+              @captures.concat(match.captures)
+            end
+          else
+            hostname === host
+          end
+        end
+
+        # Match the submitted user agent to the given pattern, capturing any
+        # regexp match groups.
+        def match_user_agent(pattern)
+          if (user_agent = @env["HTTP_USER_AGENT"]) && (match = pattern.match(user_agent))
+            @captures.concat(match.captures)
+          end
+        end
+      end
+    end
+
+    register_plugin(:header_matchers, HeaderMatchers)
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The heartbeat handles heartbeat/status requests.  If a request for
+    # the heartbeat path comes in, a 200 response with a
+    # text/plain Content-Type and a body of "OK" will be returned.
+    # The default heartbeat path is "/heartbeat", so to use that:
+    #
+    #   plugin :heartbeat
+    #
+    # You can also specify a custom heartbeat path:
+    #
+    #   plugin :heartbeat, path: '/status'
+    module Heartbeat
+      # Set the heartbeat path to the given path.
+      def self.configure(app, opts=OPTS)
+        app.opts[:heartbeat_path] = (opts[:path] || app.opts[:heartbeat_path] || "/heartbeat").dup.freeze
+      end
+
+      module InstanceMethods
+        private
+
+        # If the request is for a heartbeat path, return the heartbeat response.
+        def _roda_before_20__heartbeat
+          if env['PATH_INFO'] == opts[:heartbeat_path]
+            response = @_response
+            response.status = 200
+            response[RodaResponseHeaders::CONTENT_TYPE] = 'text/plain'
+            response.write 'OK'
+            throw :halt, response.finish
+          end
+        end
+      end
+    end
+
+    register_plugin(:heartbeat, Heartbeat)
+  end
+end
+