ultra-max-sys 0.0.1

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

@@ -0,0 +1,182 @@
+# frozen-string-literal: true
+
+require 'uri'
+
+begin
+  require 'rack/files'
+rescue LoadError
+  require 'rack/file'
+end
+
+#
+class Roda
+  module RodaPlugins
+    # The public plugin adds a +r.public+ routing method to serve static files
+    # from a directory.
+    #
+    # The public plugin recognizes the application's :root option, and defaults to
+    # using the +public+ subfolder of the application's +:root+ option.  If the application's
+    # :root option is not set, it defaults to the +public+ folder in the working
+    # directory.  Additionally, if a relative path is provided as the +:root+
+    # option to the plugin, it will be considered relative to the application's
+    # +:root+ option.
+    #
+    # Examples:
+    #
+    #   # Use public folder as location of files
+    #   plugin :public
+    #
+    #   # Use /path/to/app/static as location of files
+    #   opts[:root] = '/path/to/app'
+    #   plugin :public, root: 'static'
+    #
+    #   # Assuming public is the location of files
+    #   route do
+    #     # Make GET /images/foo.png look for public/images/foo.png 
+    #     r.public
+    #
+    #     # Make GET /static/images/foo.png look for public/images/foo.png
+    #     r.on(:static) do
+    #       r.public
+    #     end
+    #   end
+    module Public
+      SPLIT = Regexp.union(*[File::SEPARATOR, File::ALT_SEPARATOR].compact)
+      RACK_FILES = defined?(Rack::Files) ? Rack::Files : Rack::File
+      ENCODING_MAP = {:zstd=>'zstd', :brotli=>'br', :gzip=>'gzip'}.freeze
+      ENCODING_EXTENSIONS = {'br'=>'.br', 'gzip'=>'.gz', 'zstd'=>'.zst'}.freeze
+
+      # :nocov:
+      PARSER = defined?(::URI::RFC2396_PARSER) ? ::URI::RFC2396_PARSER : ::URI::DEFAULT_PARSER
+      MATCH_METHOD = RUBY_VERSION >= '2.4' ? :match? : :match
+      # :nocov:
+
+      # Use options given to setup a Rack::File instance for serving files. Options:
+      # :brotli :: Whether to serve already brotli-compressed files with a .br extension
+      #            for clients supporting "br" transfer encoding.
+      # :default_mime :: The default mime type to use if the mime type is not recognized.
+      # :encodings :: An enumerable of pairs to handle accepted encodings.  The first
+      #               element of the pair is the accepted encoding name (e.g. 'gzip'),
+      #               and the second element of the pair is the file extension (e.g.
+      #               '.gz'). This allows configuration of the order in which encodings 
+      #               are tried, to prefer brotli to zstd for example, or to support
+      #               encodings other than zstd, brotli, and gzip. This takes
+      #               precedence over the :brotli, :gzip, and :zstd options if given.
+      # :gzip :: Whether to serve already gzipped files with a .gz extension for clients
+      #          supporting "gzip" transfer encoding.
+      # :headers :: A hash of headers to use for statically served files
+      # :root :: Use this option for the root of the public directory (default: "public")
+      # :zstd :: Whether to serve already zstd-compressed files with a .zst extension
+      #          for clients supporting "zstd" transfer encoding.
+      def self.configure(app, opts={})
+        if opts[:root]
+          app.opts[:public_root] = app.expand_path(opts[:root])
+        elsif !app.opts[:public_root]
+          app.opts[:public_root] = app.expand_path("public")
+        end
+        app.opts[:public_server] = RACK_FILES.new(app.opts[:public_root], opts[:headers]||{}, opts[:default_mime] || 'text/plain')
+
+        unless encodings = opts[:encodings]
+          if ENCODING_MAP.any?{|k,| opts.has_key?(k)}
+            encodings = ENCODING_MAP.map{|k, v| [v, ENCODING_EXTENSIONS[v]] if opts[k]}.compact
+          end
+        end
+        encodings = (encodings || app.opts[:public_encodings] || EMPTY_ARRAY).map(&:dup).freeze
+        encodings.each do |a|
+          a << /\b#{a[0]}\b/
+        end
+        encodings.each(&:freeze)
+        app.opts[:public_encodings] = encodings
+      end
+
+      module RequestMethods
+        # Serve files from the public directory if the file exists and this is a GET request.
+        def public
+          public_serve_with(roda_class.opts[:public_server])
+        end
+
+        private
+
+        # Return an array of segments for the given path, handling ..
+        # and . components
+        def public_path_segments(path)
+          segments = []
+            
+          path.split(SPLIT).each do |seg|
+            next if seg.empty? || seg == '.'
+            seg == '..' ? segments.pop : segments << seg
+          end
+            
+          segments
+        end
+
+        # Return whether the given path is a readable regular file.
+        def public_file_readable?(path)
+          ::File.file?(path) && ::File.readable?(path)
+        rescue SystemCallError
+          # :nocov:
+          false
+          # :nocov:
+        end
+
+        def public_serve_with(server)
+          return unless is_get?
+          path = PARSER.unescape(real_remaining_path)
+          return if path.include?("\0")
+
+          roda_opts = roda_class.opts
+          path = ::File.join(server.root, *public_path_segments(path))
+
+          if accept_encoding = env['HTTP_ACCEPT_ENCODING']
+            roda_opts[:public_encodings].each do |enc, ext, regexp|
+              if regexp.send(MATCH_METHOD, accept_encoding)
+                public_serve_compressed(server, path, ext, enc)
+              end
+            end
+          end
+
+          if public_file_readable?(path)
+            s, h, b = public_serve(server, path)
+            headers = response.headers
+            headers.replace(h)
+            halt [s, headers, b]
+          end
+        end
+
+        # Serve the compressed file if it exists.  This should only
+        # be called if the client will accept the related encoding.
+        def public_serve_compressed(server, path, suffix, encoding)
+          compressed_path = path + suffix
+
+          if public_file_readable?(compressed_path)
+            s, h, b = public_serve(server, compressed_path)
+            headers = response.headers
+            headers.replace(h)
+
+            unless s == 304
+              headers[RodaResponseHeaders::CONTENT_TYPE] = ::Rack::Mime.mime_type(::File.extname(path), 'text/plain')
+              headers[RodaResponseHeaders::CONTENT_ENCODING] = encoding
+            end
+
+            halt [s, headers, b]
+          end
+        end
+
+        if ::Rack.release > '2'
+          # Serve the given path using the given Rack::Files server.
+          def public_serve(server, path)
+            server.serving(self, path)
+          end
+        else
+          def public_serve(server, path)
+            server = server.dup
+            server.path = path
+            server.serving(env)
+          end
+        end
+      end
+    end
+
+    register_plugin(:public, Public)
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The r plugin adds an +r+ instance method that will return the request.
+    # This allows you to use common Roda idioms such as +r.halt+ and
+    # +r.redirect+ even when +r+ isn't a local variable in scope. Example:
+    # 
+    #   plugin :r
+    #
+    #   def foo
+    #     r.redirect "/bar"
+    #   end
+    #
+    #   route do |r|
+    #     r.get "foo" do
+    #       foo
+    #     end
+    #     r.get "bar" do
+    #       "bar"
+    #     end
+    #   end
+    module R
+      module InstanceMethods
+        # The request object.
+        def r
+          @_request
+        end
+      end
+    end
+
+    register_plugin(:r, R)
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The recheck_precompiled_assets plugin enables checking for the precompiled asset metadata file.
+    # You need to have already loaded the assets plugin with the +:precompiled+ option and the file
+    # specified by the +:precompiled+ option must already exist in order to use the
+    # recheck_precompiled_assets plugin.
+    #
+    # Any time you want to check whether the precompiled asset metadata file has changed and should be
+    # reloaded, you can call the +recheck_precompiled_assets+ class method.  This method will check
+    # whether the file has changed, and reload it if it has.  If you want to check for modifications on
+    # every request, you can use +self.class.recheck_precompiled_assets+ inside your route block.
+    module RecheckPrecompiledAssets
+      # Thread safe wrapper for the compiled asset metadata hash.  Does not wrap all
+      # hash methods, only a few that are used.
+      class CompiledAssetsHash
+        include Enumerable
+
+        def initialize
+          @hash = {}
+          @mutex = Mutex.new
+        end
+
+        def [](key)
+          @mutex.synchronize{@hash[key]}
+        end
+
+        def []=(key, value)
+          @mutex.synchronize{@hash[key] = value}
+        end
+
+        def replace(hash)
+          hash = hash.instance_variable_get(:@hash) if (CompiledAssetsHash === hash)
+          @mutex.synchronize{@hash.replace(hash)}
+          self
+        end
+
+        def each(&block)
+          @mutex.synchronize{@hash.dup}.each(&block)
+          self
+        end
+
+        def to_json(*args)
+          @mutex.synchronize{@hash.dup}.to_json(*args)
+        end
+      end
+
+      def self.load_dependencies(app)
+        unless app.respond_to?(:assets_opts) && app.assets_opts[:precompiled]
+          raise RodaError, "must load assets plugin with precompiled option before loading recheck_precompiled_assets plugin"
+        end
+      end
+
+      def self.configure(app)
+        precompiled_file = app.assets_opts[:precompiled]
+        prev_mtime = ::File.mtime(precompiled_file)
+        app.instance_exec do
+          opts[:assets] = opts[:assets].merge(:compiled=>_compiled_assets_initial_hash.replace(assets_opts[:compiled])).freeze
+
+          define_singleton_method(:recheck_precompiled_assets) do
+            new_mtime = ::File.mtime(precompiled_file)
+            if new_mtime != prev_mtime
+              prev_mtime = new_mtime
+              assets_opts[:compiled].replace(_precompiled_asset_metadata(precompiled_file))
+
+              # Unset the cached asset matchers, so new ones will be generated.
+              # This is needed in case the new precompiled metadata uses
+              # different files.
+              app::RodaRequest.instance_variable_set(:@assets_matchers, nil)
+            end
+          end
+          singleton_class.send(:alias_method, :recheck_precompiled_assets, :recheck_precompiled_assets)
+        end
+      end
+
+      module ClassMethods
+        private
+
+        # Wrap the precompiled asset metadata in a thread-safe hash.
+        def _precompiled_asset_metadata(file)
+          CompiledAssetsHash.new.replace(super)
+        end
+
+        # Use a thread-safe wrapper of a hash for the :compiled assets option, since
+        # the recheck_precompiled_asset_metadata can modify it at runtime.
+        def _compiled_assets_initial_hash
+          CompiledAssetsHash.new
+        end
+      end
+
+      module RequestClassMethods
+        private
+
+        # Use a regexp that matches any digest.  When the precompiled asset metadata
+        # file is updated, this allows requests for a previous precompiled asset to
+        # still work.
+        def _asset_regexp(type, key, _)
+          /#{Regexp.escape(key.sub(/\A#{type}/, ''))}\.[0-9a-fA-F]+\.#{type}/
+        end
+      end
+    end
+
+    register_plugin(:recheck_precompiled_assets, RecheckPrecompiledAssets)
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The redirect_http_to_https plugin exposes a +redirect_http_to_https+
+    # request method that redirects HTTP requests to HTTPS, helping to ensure
+    # that future requests by the same browser will be submitted securely.
+    #
+    # You should use this plugin if you have an application that can receive
+    # requests using both HTTP and HTTPS, and you want to make sure that all
+    # or a subset of routes are only handled for HTTPS requests.
+    #
+    # The reason this exposes a request method is so that you can choose where
+    # in your routing tree to do the redirection:
+    #
+    #   route do |r|
+    #     # routes available via both HTTP and HTTPS
+    #     r.redirect_http_to_https
+    #     # routes available only via HTTPS
+    #   end
+    #
+    # If you want to redirect to HTTPS for all routes in the routing tree, you
+    # can have this as the very first method call in the routing tree.  Note that
+    # in Roda it is possible to handle routing before the normal routing tree
+    # using before hooks.  The static_routing and heartbeat plugins use this
+    # feature. If you would like to handle routes before the normal routing tree,
+    # you can setup a before hook:
+    #
+    #   plugin :hooks
+    #
+    #   before do
+    #     request.redirect_http_to_https
+    #   end
+    module RedirectHttpToHttps
+      status_map = Hash.new(307)
+      status_map['GET'] = status_map['HEAD'] = 301
+      status_map.freeze
+      DEFAULTS = {:status_map => status_map}.freeze
+      private_constant :DEFAULTS
+
+      # Configures redirection from HTTP to HTTPS.  Available options:
+      #
+      # :body :: The body used in the redirect.  If not set, uses an empty body.
+      # :headers :: Any additional headers used in the redirect response. By default,
+      #             no additional headers are set, the only header used is the Location header.
+      # :host :: The host to redirect to.  If not set, redirects to the same host as the HTTP
+      #          requested to.  It is highly recommended that you set this if requests with
+      #          arbitrary Host headers can be submitted to the application.
+      # :port :: The port to use in the redirect.  By default, will not set an explicit port,
+      #          so that it will implicitly use the HTTPS default port of 443.
+      # :status_map :: A hash mapping request methods to response status codes.  By default,
+      #                uses a hash that redirects GET and HEAD requests with a 301 status,
+      #                and other request methods with a 307 status.
+      def self.configure(app, opts=OPTS)
+        previous = app.opts[:redirect_http_to_https] || DEFAULTS
+        opts = app.opts[:redirect_http_to_https] = previous.merge(opts)
+        opts[:port_string] = opts[:port] ? ":#{opts[:port]}".freeze : "".freeze
+        opts[:prefix] = opts[:host] ? "https://#{opts[:host]}#{opts[:port_string]}".freeze : nil
+        opts.freeze
+      end
+
+      module RequestMethods
+        # Redirect HTTP requests to HTTPS. While this doesn't secure the
+        # current request, it makes it more likely that the browser will submit
+        # future requests securely via HTTPS.
+        def redirect_http_to_https
+          return if ssl?
+
+          opts = roda_class.opts[:redirect_http_to_https]
+
+          res = response
+
+          if body = opts[:body]
+            res.write(body)
+          end
+
+          if headers = opts[:headers]
+            res.headers.merge!(headers)
+          end
+
+          path = if prefix = opts[:prefix]
+            prefix + fullpath
+          else
+            "https://#{host}#{opts[:port_string]}#{fullpath}"
+          end
+
+          unless status = opts[:status_map][@env['REQUEST_METHOD']]
+            raise RodaError, "redirect_http_to_https :status_map provided does not support #{@env['REQUEST_METHOD']}"
+          end
+
+          redirect(path, status)
+        end
+      end
+    end
+
+    register_plugin(:redirect_http_to_https, RedirectHttpToHttps)
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The redirect_path plugin builds on top of the path plugin,
+    # and allows the +r.redirect+ method to be passed a non-string
+    # object that will be passed to +path+, and redirect to the
+    # result of +path+.
+    #
+    # In the second argument, you can provide a suffix to the
+    # generated path. However, in this case you cannot provide a
+    # non-default redirect status in the same call).
+    #
+    # Example:
+    #
+    #   Foo = Struct.new(:id)
+    #   foo = Foo.new(1)
+    #
+    #   plugin :redirect_path
+    #   path Foo do |foo|
+    #     "/foo/#{foo.id}"
+    #   end
+    #
+    #   route do |r|
+    #     r.get "example" do
+    #       # redirects to /foo/1
+    #       r.redirect(foo)
+    #     end
+    #
+    #     r.get "suffix-example" do
+    #       # redirects to /foo/1/status
+    #       r.redirect(foo, "/status")
+    #     end
+    #   end
+    module RedirectPath
+      def self.load_dependencies(app)
+        app.plugin :path
+      end
+
+      module RequestMethods
+        def redirect(path=default_redirect_path, status=default_redirect_status)
+          if String === path
+            super
+          else
+            path = scope.path(path)
+            if status.is_a?(String)
+              super(path + status)
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+
+    register_plugin(:redirect_path, RedirectPath)
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The relative_path plugin adds a relative_path method that accepts
+    # an absolute path and returns a path relative to the current request
+    # by adding an appropriate prefix:
+    #
+    #   plugin :relative_path
+    #   route do |r|
+    #     relative_path("/foo")
+    #   end
+    #
+    #   # GET /
+    #   "./foo"
+    #
+    #   # GET /bar
+    #   "./foo"
+    #
+    #   # GET /bar/
+    #   "../foo"
+    #
+    #   # GET /bar/baz/quux
+    #   "../../foo"
+    #
+    # It also offers a relative_prefix method that returns a string that can
+    # be prepended to an absolute path.  This can be more efficient if you
+    # need to convert multiple paths.
+    #
+    # This plugin is mostly designed for applications using Roda as a static
+    # site generator, where the generated site can be hosted at any subpath.
+    module RelativePath
+      SCOPE_INSTANCE_VARIABLES = [:@_relative_prefix].freeze
+
+      module InstanceMethods
+        # Return a relative path for the absolute path based on the current path
+        # of the request by adding the appropriate prefix.
+        def relative_path(absolute_path)
+          relative_prefix + absolute_path
+        end
+
+        # Return a relative prefix to append to an absolute path to a relative path
+        # based on the current path of the request.
+        def relative_prefix
+          return @_relative_prefix if @_relative_prefix
+          env = @_request.env
+          script_name = env["SCRIPT_NAME"]
+          path_info = env["PATH_INFO"]
+
+          # Check path begins with slash.  All valid paths should, but in case this
+          # request is bad, just skip using a relative prefix.
+          case script_name.getbyte(0)
+          when nil # SCRIPT_NAME empty
+            unless path_info.getbyte(0) == 47 # PATH_INFO starts with /
+              return(@_relative_prefix = '')
+            end
+          when 47 # SCRIPT_NAME starts with /
+            # nothing
+          else
+            return(@_relative_prefix = '')
+          end
+
+          slash_count = script_name.count('/') + path_info.count('/')
+          @_relative_prefix = if slash_count > 1
+            ("../" * (slash_count - 2)) << ".."
+          else
+            "."
+          end
+        end
+      end
+    end
+
+    register_plugin(:relative_path, RelativePath)
+  end
+end