ultra-max-sys 0.0.1

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

@@ -0,0 +1,194 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The host_routing plugin adds support for more routing requests based on
+    # the requested host.  It also adds predicate methods for checking
+    # whether a request was requested with the given host.
+    #
+    # When loading the plugin, you pass a block, which is used for configuring
+    # the plugin.  For example, if you want to treat requests to api.example.com
+    # or api2.example.com as api requests, and treat other requests as www
+    # requests, you could use:
+    #
+    #   plugin :host_routing do |hosts|
+    #     hosts.to :api, "api.example.com", "api2.example.com"
+    #     hosts.default :www
+    #   end
+    #
+    # With this configuration, in your routing tree, you can call the +r.api+ and
+    # +r.www+ methods for dispatching to routing blocks only for those types of
+    # requests:
+    #
+    #   route do |r|
+    #     r.api do
+    #       # requests to api.example.com or api2.example.com
+    #     end
+    #
+    #     r.www do
+    #       # requests to other domains
+    #     end
+    #   end
+    #
+    # In addition to the routing methods, predicate methods are also added to the
+    # request object:
+    #
+    #   route do |r|
+    #     "#{r.api?}-#{r.www?}"
+    #   end
+    #   # Requests to api.example.com or api2.example.com return "true-false"
+    #   # Other requests return "false-true"
+    #
+    # If the +:scope_predicates+ plugin option is given, predicate methods are also
+    # created in route block scope:
+    #
+    #   plugin :host_routing, scope_predicates: true do |hosts|
+    #     hosts.to :api, "api.example.com"
+    #     hosts.default :www
+    #   end
+    #
+    #   route do |r|
+    #     "#{api?}-#{www?}"
+    #   end
+    #
+    # To handle hosts that match a certain format (such as all subdomains),
+    # where the specific host names are not known up front, you can provide a block
+    # when calling +hosts.default+. This block is passed the host name, or an empty
+    # string if no host name is provided, and is evaluated in route block scope.
+    # When using this support, you should also call +hosts.register+
+    # to register host types that could be returned by the block.  For example, to
+    # handle api subdomains differently:
+    #
+    #   plugin :host_routing do |hosts|
+    #     hosts.to :api, "api.example.com"
+    #     hosts.register :api_sub
+    #     hosts.default :www do |host|
+    #       :api_sub if host.end_with?(".api.example.com")
+    #     end
+    #   end
+    #
+    # This plugin uses the host method on the request to get the hostname (this method
+    # is defined by Rack).
+    module HostRouting
+      REQUEST_INSTANCE_VARIABLES = [:@_host_routing_host].freeze
+
+      # Setup the host routing support.  The block yields an object used to
+      # configure the plugin.  Options:
+      #
+      # :scope_predicates :: Setup predicate methods in route block scope
+      #                      in addition to request scope.
+      def self.configure(app, opts=OPTS, &block)
+        hosts, host_hash, default_block, default_host = DSL.new.process(&block)
+        app.opts[:host_routing_hash] = host_hash
+        app.opts[:host_routing_default_host] = default_host
+
+        app.send(:define_method, :_host_routing_default, &default_block) if default_block
+
+        app::RodaRequest.class_exec do
+          hosts.each do |host|
+            host_sym = host.to_sym
+            define_method(host_sym){|&blk| always(&blk) if _host_routing_host == host}
+            alias_method host_sym, host_sym
+
+            meth = :"#{host}?"
+            define_method(meth){_host_routing_host == host}
+            alias_method meth, meth
+          end
+        end
+
+        if opts[:scope_predicates]
+          app.class_exec do
+            hosts.each do |host|
+              meth = :"#{host}?"
+              define_method(meth){@_request.send(meth)}
+              alias_method meth, meth
+            end
+          end
+        end
+      end
+
+      class DSL
+        def initialize
+          @hosts = []
+          @host_hash = {}
+          @default_host = nil
+          @default_block = nil
+        end
+
+        # Run the DSL for the given block.
+        def process(&block)
+          instance_exec(self, &block)
+
+          if !@default_host
+            raise RodaError, "must call default method inside host_routing plugin block to set default host"
+          end
+
+          @hosts.concat(@host_hash.values)
+          @hosts << @default_host
+          @hosts.uniq!
+          [@hosts.freeze, @host_hash.freeze, @default_block, @default_host].freeze
+        end
+        
+        # Register hosts that can be returned.  This is only needed if
+        # calling register with a block, where the block can return
+        # a value that doesn't match a host given to +to+ or +default+.
+        def register(*hosts)
+          @hosts = hosts
+        end
+
+        # Treat all given hostnames as routing to the give host.
+        def to(host, *hostnames)
+          hostnames.each do |hostname|
+            @host_hash[hostname] = host
+          end
+        end
+
+        # Register the default hostname.  If a block is provided, it is
+        # called with the host if there is no match for one of the hostnames
+        # provided to +to+.  If the block returns nil/false, the hostname
+        # given to this method is used.
+        def default(hostname, &block)
+          @default_host = hostname
+          @default_block = block
+        end
+      end
+      private_constant :DSL
+
+      module InstanceMethods
+        # Handle case where plugin is used without providing a block to
+        # +hosts.default+.  This returns nil, ensuring that the hostname
+        # provided to +hosts.default+ will be used.
+        def _host_routing_default(_)
+          nil
+        end
+      end
+
+      module RequestMethods
+        private
+
+        # Cache the host to use in the host routing support, so the processing
+        # is only done once per request.
+        def _host_routing_host
+          @_host_routing_host ||= _get_host_routing_host
+        end
+
+        # Determine the host to use for the host routing support.  Tries the
+        # following, in order:
+        #
+        # * An exact match for a hostname given in +hosts.to+
+        # * The return value of the +hosts.default+ block, if given
+        # * The default value provided in the +hosts.default+ call
+        def _get_host_routing_host
+          host = self.host || ""
+
+          roda_class.opts[:host_routing_hash][host] ||
+            scope._host_routing_default(host) ||
+            roda_class.opts[:host_routing_default_host]
+        end
+      end
+    end
+
+    register_plugin(:host_routing, HostRouting)
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The hsts plugin allows for easily configuring an appropriate
+    # Strict-Transport-Security response header for the application:
+    #
+    #   plugin :hsts
+    #   # Strict-Transport-Security: max-age=63072000; includeSubDomains
+    #
+    #   plugin :hsts, preload: true
+    #   # Strict-Transport-Security: max-age=63072000; includeSubDomains; preload
+    #
+    #   plugin :hsts, max_age: 31536000, subdomains: false
+    #   # Strict-Transport-Security: max-age=31536000
+    module Hsts
+      # Ensure default_headers plugin is loaded first
+      def self.load_dependencies(app, opts=OPTS)
+        app.plugin :default_headers
+      end
+
+      # Configure the Strict-Transport-Security header. Options:
+      # :max_age :: Set max-age in seconds (default is 63072000, two years)
+      # :preload :: Set preload, so the domain can be included in HSTS preload lists
+      # :subdomains :: Set to false to not set includeSubDomains. By default, 
+      #                includeSubDomains is set to enforce HTTPS for subdomains.
+      def self.configure(app, opts=OPTS)
+        app.plugin :default_headers, RodaResponseHeaders::STRICT_TRANSPORT_SECURITY => "max-age=#{opts[:max_age]||63072000}#{'; includeSubDomains' unless opts[:subdomains] == false}#{'; preload' if opts[:preload]}".freeze
+      end
+    end
+
+    register_plugin(:hsts, Hsts)
+  end
+end

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

@@ -0,0 +1,126 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The indifferent_params plugin adds a +params+ instance
+    # method which offers indifferent access to the request
+    # params, allowing you to use symbols to lookup values in
+    # a hash where the keys are strings.  Note that while this
+    # allows for an easier transition from some other ruby frameworks,
+    # it is a bad idea in general as it makes it more difficult to
+    # separate external data from internal data, and doesn't handle
+    # any typecasting of the data.  Consider using the typecast_params
+    # plugin instead of this plugin for accessing parameters.
+    #
+    # Example:
+    #
+    #   plugin :indifferent_params
+    #
+    #   route do |r|
+    #     params[:foo]
+    #   end
+    #
+    # The exact behavior depends on the version of Rack in use.
+    # If you are using Rack 2, this plugin uses rack's API
+    # to set the query parser for the request to use indifferent
+    # access. Rack 1 doesn't support indifferent access to
+    # params, so if you are using Rack 1, this plugin will make
+    # a deep copy of the request params hash, where each level
+    # uses indifferent access.  On Rack 1, The params hash is
+    # initialized lazily, so you only pay the penalty of
+    # copying the request params if you call the +params+ method.
+    #
+    # Note that there is a rack-indifferent gem that
+    # monkey patches rack to always use indifferent params. If
+    # you are using Rack 1, it is recommended to use
+    # rack-indifferent instead of this plugin, as it is faster
+    # and has some other minor advantages, though
+    # it affects all rack applications instead of just the Roda app that
+    # you load the plugin into.
+    module IndifferentParams
+      SCOPE_INSTANCE_VARIABLES = [:@_params].freeze
+
+      INDIFFERENT_PROC = lambda{|h,k| h[k.to_s] if k.is_a?(Symbol)}
+
+      if Rack.release > '2'
+        require 'rack/query_parser'
+
+        class QueryParser < Rack::QueryParser
+          # Work around for invalid optimization in rack
+          def parse_nested_query(qs, d=nil)
+            return make_params.to_params_hash if qs.nil? || qs.empty?
+            super
+          end
+          
+          class Params < Rack::QueryParser::Params
+            if Rack.release >= '3'
+              if Params < Hash
+                def initialize
+                  super(&INDIFFERENT_PROC)
+                end
+              else
+                def initialize
+                  @size   = 0
+                  @params = Hash.new(&INDIFFERENT_PROC)
+                end
+              end
+            else
+              def initialize(limit = Rack::Utils.key_space_limit)
+                @limit  = limit
+                @size   = 0
+                @params = Hash.new(&INDIFFERENT_PROC)
+              end
+            end
+          end
+
+        end
+
+        module RequestMethods
+          query_parser = Rack.release >= '3' ? QueryParser.new(QueryParser::Params, 32) : QueryParser.new(QueryParser::Params, 65536, 32)
+          QUERY_PARSER = Rack::Utils.default_query_parser = query_parser
+
+          private
+
+          def query_parser
+            QUERY_PARSER
+          end
+        end
+
+        module InstanceMethods
+          def params
+            @_request.params
+          end
+        end
+      else
+        module InstanceMethods
+          # A copy of the request params that will automatically
+          # convert symbols to strings.
+          def params
+            @_params ||= indifferent_params(@_request.params)
+          end
+
+          private
+
+          # Recursively process the request params and convert
+          # hashes to support indifferent access, leaving
+          # other values alone.
+          def indifferent_params(params)
+            case params 
+            when Hash
+              hash = Hash.new(&INDIFFERENT_PROC)
+              params.each{|k, v| hash[k] = indifferent_params(v)}
+              hash
+            when Array
+              params.map{|x| indifferent_params(x)}
+            else
+              params
+            end
+          end
+        end
+      end  
+    end
+
+    register_plugin(:indifferent_params, IndifferentParams)
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The inject_erb plugin allows you to inject content directly
+    # into the template output:
+    #
+    #   <% inject_erb("Some HTML Here") %>
+    #
+    # This will inject <tt>Some HTML Here</tt> into the template output,
+    # even though the tag being used is <tt><%</tt> and not <tt><%=</tt>.
+    #
+    # This method can be used inside methods, such as to wrap calls to
+    # methods that accept template blocks, to inject code before and after
+    # the template blocks.
+    module InjectERB
+      def self.load_dependencies(app)
+        app.plugin :render
+      end
+
+      module InstanceMethods
+        # Inject into the template output for the template currently being
+        # rendered.
+        def inject_erb(value)
+          instance_variable_get(render_opts[:template_opts][:outvar]) << value.to_s
+        end
+      end
+    end
+
+    register_plugin(:inject_erb, InjectERB)
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The invalid_request_body plugin allows for custom handling of invalid request
+    # bodies.  Roda uses Rack for parsing request bodies, so by default, any
+    # invalid request bodies would result in Rack raising an exception, and the
+    # exception could change for different reasons the request body is invalid.
+    # This plugin overrides RodaRequest#POST (which parses parameters from request
+    # bodies), and if parsing raises an exception, it allows for custom behavior.
+    # 
+    # If you want to treat an invalid request body as the submission of no parameters,
+    # you can use the :empty_hash argument when loading the plugin:
+    #
+    #   plugin :invalid_request_body, :empty_hash
+    #
+    # If you want to return a empty 400 (Bad Request) response if an invalid request
+    # body is submitted, you can use the :empty_400 argument when loading the plugin:
+    #
+    #   plugin :invalid_request_body, :empty_400
+    #
+    # If you want to raise a Roda::RodaPlugins::InvalidRequestBody::Error exception
+    # if an invalid request body is submitted (which makes it easier to handle these
+    # exceptions when using the error_handler plugin), you can use the :raise argument
+    # when loading the plugin:
+    #
+    #   plugin :invalid_request_body, :raise
+    #
+    # For custom behavior, you can pass a block when loading the plugin.  The block
+    # is called with the exception Rack raised when parsing the body. The block will
+    # be used to define a method in the application's RodaRequest class.  It can either
+    # return a hash of parameters, or you can raise a different exception, or you
+    # can halt processing and return a response:
+    #
+    #   plugin :invalid_request_body do |exception|
+    #     # To treat the exception raised as a submitted parameter
+    #     {body_error: exception}
+    #   end
+    module InvalidRequestBody
+      # Exception class raised for invalid request bodies.
+      Error = Class.new(RodaError)
+
+      # Set the action to use (:empty_400, :empty_hash, :raise) for invalid request bodies,
+      # or use a block for custom behavior.
+      def self.configure(app, action=nil, &block)
+        if action
+          if block
+            raise RodaError, "cannot provide both block and action when loading invalid_request_body plugin"
+          end
+
+          method = :"handle_invalid_request_body_#{action}"
+          unless RequestMethods.private_method_defined?(method)
+            raise RodaError, "invalid invalid_request_body action provided: #{action}"
+          end
+
+          app::RodaRequest.send(:alias_method, :handle_invalid_request_body, method)
+        elsif block
+          app::RodaRequest.class_eval do
+            define_method(:handle_invalid_request_body, &block)
+            alias handle_invalid_request_body handle_invalid_request_body
+          end
+        else
+          raise RodaError, "must provide block or action when loading invalid_request_body plugin"
+        end
+
+        app::RodaRequest.send(:private, :handle_invalid_request_body)
+      end
+
+      module RequestMethods
+        # Handle invalid request bodies as configured if the default behavior
+        # raises an exception.
+        def POST
+          super
+        rescue => e 
+          handle_invalid_request_body(e)
+        end
+
+        private
+
+        # Return an empty 400 HTTP response for invalid request bodies.
+        def handle_invalid_request_body_empty_400(e)
+          response.status = 400
+          headers = response.headers
+          headers.clear
+          headers[RodaResponseHeaders::CONTENT_TYPE] = 'text/html'
+          headers[RodaResponseHeaders::CONTENT_LENGTH] ='0'
+          throw :halt, response.finish_with_body([])
+        end
+
+        # Treat invalid request bodies by using an empty hash as the
+        # POST params.
+        def handle_invalid_request_body_empty_hash(e)
+          {}
+        end
+
+        # Raise a specific error for all invalid request bodies,
+        # to allow for easy rescuing using the error_handler plugin.
+        def handle_invalid_request_body_raise(e)
+          raise Error, e.message
+        end
+      end
+    end
+
+    register_plugin(:invalid_request_body, InvalidRequestBody)
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The ip_from_header plugin allows for overriding +request.ip+ to return
+    # the value contained in a specific header. This is useful when the
+    # application is behind a proxy that sets a specific header, especially
+    # when the proxy does not use a fixed IP address range. Example showing 
+    # usage with Cloudflare:
+    #
+    #   plugin :ip_from_header, "CF-Connecting-IP"
+    #
+    # This plugin assumes that if the header is set, it contains a valid IP
+    # address, it does not check the format of the header value, just as
+    # <tt>Rack::Request#ip</tt> does not check the IP address it returns is
+    # actually valid.
+    module IPFromHeader
+      def self.configure(app, header)
+        app.opts[:ip_from_header_env_key] = "HTTP_#{header.upcase.tr('-', '_')}".freeze
+      end
+
+      module RequestMethods
+        # Return the IP address continained in the configured header, if present.
+        # Fallback to the default behavior if not present.
+        def ip
+          @env[roda_class.opts[:ip_from_header_env_key]] || super
+        end
+      end
+    end
+
+    register_plugin(:ip_from_header, IPFromHeader)
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen-string-literal: true
+
+require 'json'
+
+class Roda
+  module RodaPlugins
+    # The json plugin allows match blocks to return
+    # arrays or hashes, and have those arrays or hashes be
+    # converted to json which is used as the response body.
+    # It also sets the response content type to application/json.
+    # So you can take code like:
+    #
+    #   r.root do
+    #     response['Content-Type'] = 'application/json'
+    #     [1, 2, 3].to_json
+    #   end
+    #   r.is "foo" do
+    #     response['Content-Type'] = 'application/json'
+    #     {'a'=>'b'}.to_json
+    #   end
+    #
+    # and DRY it up:
+    #
+    #   plugin :json
+    #   r.root do
+    #     [1, 2, 3]
+    #   end
+    #   r.is "foo" do
+    #     {'a'=>'b'}
+    #   end
+    #
+    # By default, only arrays and hashes are handled, but you
+    # can specifically set the allowed classes to json by adding
+    # using the :classes option when loading the plugin:
+    #
+    #   plugin :json, classes: [Array, Hash, Sequel::Model]
+    #
+    # By default objects are serialized with +to_json+, but you
+    # can pass in a custom serializer, which can be any object
+    # that responds to +call(object)+.
+    #
+    #   plugin :json, serializer: proc{|o| o.to_json(root: true)}
+    #
+    # If you need the request information during serialization, such
+    # as HTTP headers or query parameters, you can pass in the
+    # +:include_request+ option, which will pass in the request
+    # object as the second argument when calling the serializer.
+    #
+    #   plugin :json, include_request: true, serializer: proc{|o, request| ...}
+    #
+    # The default content-type is 'application/json', but you can change that
+    # using the +:content_type+ option:
+    #
+    #   plugin :json, content_type: 'application/xml'
+    #
+    # This plugin depends on the custom_block_results plugin, and therefore does
+    # not support treating String, FalseClass, or NilClass values as JSON.
+    module Json
+      def self.load_dependencies(app, opts=OPTS)
+        app.plugin :custom_block_results
+      end
+
+      # Set the classes to automatically convert to JSON, and the serializer to use.
+      def self.configure(app, opts=OPTS)
+        classes = opts[:classes] || [Array, Hash]
+        app.opts[:json_result_classes] ||= []
+        app.opts[:json_result_classes] += classes
+        classes = app.opts[:json_result_classes]
+        classes.uniq!
+        classes.freeze
+        classes.each do |klass|
+          app.opts[:custom_block_results][klass] = :handle_json_block_result
+        end
+
+        app.opts[:json_result_serializer] = opts[:serializer] || app.opts[:json_result_serializer] || app.opts[:json_serializer] || :to_json.to_proc
+
+        app.opts[:json_result_include_request] = opts[:include_request] if opts.has_key?(:include_request)
+
+        app.opts[:json_result_content_type] = opts[:content_type] || 'application/json'.freeze
+      end
+
+      module ClassMethods
+        # The classes that should be automatically converted to json
+        def json_result_classes
+          # RODA4: remove, only used by previous implementation.
+          opts[:json_result_classes]
+        end
+      end
+
+      module InstanceMethods
+        # Handle a result for one of the registered JSON result classes
+        # by converting the result to JSON.
+        def handle_json_block_result(result)
+          @_response[RodaResponseHeaders::CONTENT_TYPE] ||= opts[:json_result_content_type]
+          @_request.send(:convert_to_json, result)
+        end
+      end
+
+      module RequestMethods
+        private
+
+        # Convert the given object to JSON.  Uses to_json by default,
+        # but can use a custom serializer passed to the plugin.
+        def convert_to_json(result)
+          opts = roda_class.opts
+          serializer = opts[:json_result_serializer]
+
+          if opts[:json_result_include_request]
+            serializer.call(result, self)
+          else
+            serializer.call(result)
+          end
+        end
+      end
+    end
+
+    register_plugin(:json, Json)
+  end
+end