ultra-max-sys 0.0.1

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

@@ -0,0 +1,445 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The exception_page plugin provides an exception_page method that is designed
+    # to be called inside the error handler to provide a page to the developer
+    # with debugging information. It should only be used in developer environments
+    # with trusted clients, as it can leak source code and other information that
+    # may be useful for attackers if used in other environments.
+    #
+    # Example:
+    #
+    #   plugin :exception_page
+    #   plugin :error_handler do |e|
+    #     next exception_page(e) if ENV['RACK_ENV'] == 'development'
+    #     # ...
+    #   end
+    #
+    # The exception_page plugin is based on Rack::ShowExceptions, with the following
+    # differences:
+    #
+    # * Not a middleware, so it doesn't handle exceptions itself, and has no effect
+    #   on the callstack unless the exception_page method is called.
+    # * Supports external javascript and stylesheets, allowing context toggling to
+    #   work in applications that use a content security policy to restrict inline
+    #   javascript and stylesheets (:assets, :css_file, and :js_file options).
+    # * Has fewer dependencies (does not require ostruct and erb).
+    # * Sets the Content-Type for the response, and returns the body string, but does
+    #   not modify other headers or the response status.
+    # * Supports a configurable amount of context lines in backtraces (:context option).
+    # * Supports optional JSON formatted output, if used with the json plugin (:json option).
+    #
+    # To use the external javascript and stylesheets, you can call +r.exception_page_assets+
+    # in your routing tree:
+    #
+    #   route do |r|
+    #     # ...
+    #
+    #     # serve GET /exception_page.{css,js} requests
+    #     # Use with assets: true +exception_page+ option
+    #     r.exception_page_assets
+    #     
+    #     r.on "static" do
+    #       # serve GET /static/exception_page.{css,js} requests
+    #       # Use with assets: '/static' +exception_page+ option
+    #       r.exception_page_assets
+    #     end
+    #   end
+    #
+    # It's also possible to store the asset information in static files and serve those,
+    # you can get the current assets by calling:
+    #
+    #   Roda::RodaPlugins::ExceptionPage.css
+    #   Roda::RodaPlugins::ExceptionPage.js
+    #
+    # As the exception_page plugin is based on Rack::ShowExceptions, it is also under
+    # rack's license:
+    #
+    # Copyright (C) 2007-2018 Christian Neukirchen <http://chneukirchen.org/infopage.html>
+    #
+    # Permission is hereby granted, free of charge, to any person obtaining a copy
+    # of this software and associated documentation files (the "Software"), to
+    # deal in the Software without restriction, including without limitation the
+    # rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+    # sell copies of the Software, and to permit persons to whom the Software is
+    # furnished to do so, subject to the following conditions:
+    #
+    # The above copyright notice and this permission notice shall be included in
+    # all copies or substantial portions of the Software.
+    #
+    # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+    # THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+    # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+    # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+    #
+    # The HTML template used in Rack::ShowExceptions was based on Django's
+    # template and is under the following license:
+    #
+    # adapted from Django <www.djangoproject.com>
+    # Copyright (c) Django Software Foundation and individual contributors.
+    # Used under the modified BSD license:
+    # http://www.xfree86.org/3.3.6/COPYRIGHT2.html#5
+    module ExceptionPage
+      def self.load_dependencies(app)
+        app.plugin :h
+      end
+
+      # Stylesheet used by the HTML exception page
+      def self.css
+        <<END
+html * { padding:0; margin:0; }
+body * { padding:10px 20px; }
+body * * { padding:0; }
+body { font:small sans-serif; }
+body>div { border-bottom:1px solid #ddd; }
+h1 { font-weight:normal; }
+h2 { margin-bottom:.8em; }
+h2 span { font-size:80%; color:#666; font-weight:normal; }
+h3 { margin:1em 0 .5em 0; }
+h4 { margin:0 0 .5em 0; font-weight: normal; }
+table {
+    border:1px solid #ccc; border-collapse: collapse; background:white; }
+tbody td, tbody th { vertical-align:top; padding:2px 3px; }
+thead th {
+    padding:1px 6px 1px 3px; background:#fefefe; text-align:left;
+    font-weight:normal; font-size:11px; border:1px solid #ddd; }
+tbody th { text-align:right; color:#666; padding-right:.5em; }
+table.vars { margin:5px 0 2px 40px; }
+table.vars td, table.req td { font-family:monospace; }
+table td.code { width:100%;}
+table td.code div { overflow:hidden; }
+table.source th { color:#666; }
+table.source td {
+    font-family:monospace; white-space:pre; border-bottom:1px solid #eee; }
+ul.traceback { list-style-type:none; }
+ul.traceback li.frame { margin-bottom:1em; }
+div.context { margin: 10px 0; }
+div.context ol {
+    padding-left:30px; margin:0 10px; list-style-position: inside; }
+div.context ol li {
+    font-family:monospace; white-space:pre; color:#666; cursor:pointer; }
+div.context ol.context-line li { color:black; background-color:#ccc; }
+div.context ol.context-line li span { float: right; }
+div.commands { margin-left: 40px; }
+div.commands a { color:black; text-decoration:none; }
+#summary { background: #ffc; }
+#summary h2 { font-weight: normal; color: #666; font-family: monospace; white-space: pre-wrap;}
+#summary ul#quicklinks { list-style-type: none; margin-bottom: 2em; }
+#summary ul#quicklinks li { float: left; padding: 0 1em; }
+#summary ul#quicklinks>li+li { border-left: 1px #666 solid; }
+#explanation { background:#eee; }
+#traceback { background:#eee; }
+#requestinfo { background:#f6f6f6; padding-left:120px; }
+#summary table { border:none; background:transparent; }
+#requestinfo h2, #requestinfo h3 { position:relative; margin-left:-100px; }
+#requestinfo h3 { margin-bottom:-1em; }
+.error { background: #ffc; }
+.specific { color:#cc3300; font-weight:bold; }
+END
+      end
+
+      # Javascript used by the HTML exception page for context toggling
+      def self.js
+        <<END
+var contexts = document.getElementsByClassName('context');
+var num_contexts = contexts.length;
+function toggle() {
+  for (var i = 0; i < arguments.length; i++) {
+    var e = document.getElementById(arguments[i]);
+    if (e) {
+      e.style.display = e.style.display == 'none' ? 'block' : 'none';
+    }
+  }
+  return false;
+}
+for (var j = 0; j < num_contexts; j++) {
+  contexts[j].onclick = function(){toggle('b'+this.id, 'a'+this.id);}
+  contexts[j].onclick();
+}
+END
+      end
+
+      module InstanceMethods
+        # Return a HTML page showing the exception, allowing a developer
+        # more information for debugging.  Designed to be called inside
+        # an exception handler, passing in the received exception.
+        # Sets the Content-Type header in the response, and returns the
+        # string used for the body.  If the Accept request header is present
+        # and text/html is accepted, return an HTML page with the backtrace
+        # with the ability to see the context for each backtrace line, as
+        # well as the GET, POST, cookie, and rack environment data.  If text/html
+        # is not accepted, then just show a plain text page with the exception
+        # class, message, and backtrace.
+        #
+        # Options:
+        # 
+        # :assets :: If +true+, sets :css_file to +/exception_page.css+ and :js_file to
+        #            +/exception_page.js+, assuming that +r.exception_page_assets+ is called
+        #            in the route block to serve the exception page assets.  If a String,
+        #            uses the string as a prefix, assuming that +r.exception_page_assets+
+        #            is called in a nested block inside the route block. If false, doesn't
+        #            use any CSS or JS.
+        # :context :: The number of context lines before and after each line in
+        #             the backtrace (default: 7).
+        # :css_file :: A path to the external CSS file for the HTML exception page. If false,
+        #              doesn't use any CSS.
+        # :js_file :: A path to the external javascript file for the HTML exception page. If
+        #             false, doesn't use any JS.
+        # :json :: Return a hash of exception information.  The hash will have
+        #          a single key, "exception", with a value being a hash with
+        #          three keys, "class", "message", and "backtrace", which
+        #          contain information derived from the given exception.
+        #          Designed to be used with the +json+ exception, which will
+        #          automatically convert the hash to JSON format.
+        def exception_page(exception, opts=OPTS)
+          message = exception_page_exception_message(exception)
+          if opts[:json]
+            @_response[RodaResponseHeaders::CONTENT_TYPE] = "application/json"
+            {
+              "exception"=>{
+                "class"=>exception.class.to_s,
+                "message"=>message,
+                "backtrace"=>exception.backtrace.map(&:to_s)
+              }
+            }
+          elsif env['HTTP_ACCEPT'] =~ /text\/html/
+            @_response[RodaResponseHeaders::CONTENT_TYPE] = "text/html"
+
+            context = opts[:context] || 7
+            css_file = opts[:css_file]
+            js_file = opts[:js_file]
+
+            case prefix = opts[:assets]
+            when false
+              css_file = false if css_file.nil?
+              js_file = false if js_file.nil?
+            when nil
+              # nothing
+            else
+              prefix = '' if prefix == true
+              css_file ||= "#{prefix}/exception_page.css"
+              js_file ||= "#{prefix}/exception_page.js"
+            end
+
+            css = case css_file
+            when nil
+              "<style type=\"text/css\">#{exception_page_css}</style>"
+            when false
+              # :nothing
+            else
+              "<link rel=\"stylesheet\" href=\"#{h css_file}\" />"
+            end
+
+            js = case js_file
+            when nil
+              "<script type=\"text/javascript\">\n//<!--\n#{exception_page_js}\n//-->\n</script>"
+            when false
+              # :nothing
+            else
+              "<script type=\"text/javascript\" src=\"#{h js_file}\"></script>"
+            end
+
+            frames = exception.backtrace.map.with_index do |line, i|
+              frame = {:id=>i}
+              if line =~ /\A(.*?):(\d+)(?::in [`'](.*)')?\Z/
+                filename = frame[:filename] = $1
+                lineno = frame[:lineno] = $2.to_i
+                frame[:function] = $3
+
+                begin
+                  lineno -= 1
+                  lines = ::File.readlines(filename)
+                  if line = lines[lineno]
+                    pre_lineno = [lineno-context, 0].max
+                    if (pre_context = lines[pre_lineno...lineno]) && !pre_context.empty?
+                      frame[:pre_context_lineno] = pre_lineno
+                      frame[:pre_context] = pre_context
+                    end
+
+                    post_lineno = [lineno+context, lines.size].min
+                    if (post_context = lines[lineno+1..post_lineno]) && !post_context.empty?
+                      frame[:post_context_lineno] = post_lineno
+                      frame[:post_context] = post_context
+                    end
+
+                    frame[:context_line] = line.chomp
+                  end
+                rescue
+                end
+
+                frame
+              end
+            end.compact
+
+            r = @_request
+            begin 
+              post_data = r.POST
+              missing_post = "No POST data"
+            rescue
+              missing_post = "Invalid POST data"
+            end
+            info = lambda do |title, id, var, none|
+              <<END
+  <h3 id="#{id}">#{title}</h3>
+  #{(var && !var.empty?) ? (<<END1) : "<p>#{none}</p>"
+    <table class="req">
+      <thead>
+        <tr>
+          <th>Variable</th>
+          <th>Value</th>
+        </tr>
+      </thead>
+      <tbody>
+          #{var.sort_by{|k, _| k.to_s}.map{|key, val| (<<END2)}.join
+          <tr>
+            <td>#{h key}</td>
+            <td class="code"><div>#{h val.inspect}</div></td>
+          </tr>
+END2
+}
+      </tbody>
+    </table>
+END1
+}
+END
+            end
+
+            <<END
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
+  <title>#{h exception.class} at #{h r.path}</title>
+  #{css}
+</head>
+<body>
+
+<div id="summary">
+  <h1>#{h exception.class} at #{h r.path}</h1>
+  <h2>#{h message}</h2>
+  <table><tr>
+    <th>Ruby</th>
+    <td>
+#{(first = frames.first) ? "<code>#{h first[:filename]}</code>: in <code>#{h first[:function]}</code>, line #{first[:lineno]}" : "unknown location"}
+    </td>
+  </tr><tr>
+    <th>Web</th>
+    <td><code>#{r.request_method} #{h r.host}#{h r.path}</code></td>
+  </tr></table>
+
+  <h3>Jump to:</h3>
+  <ul id="quicklinks">
+    <li><a href="#get-info">GET</a></li>
+    <li><a href="#post-info">POST</a></li>
+    <li><a href="#cookie-info">Cookies</a></li>
+    <li><a href="#env-info">ENV</a></li>
+  </ul>
+</div>
+
+<div id="traceback">
+  <h2>Traceback <span>(innermost first)</span></h2>
+  <ul class="traceback">
+#{frames.map{|frame| id = frame[:id]; (<<END1)}.join
+      <li class="frame">
+        <code>#{h frame[:filename]}:#{frame[:lineno]}</code> in <code>#{h frame[:function]}</code>
+
+          #{frame[:context_line] ? (<<END2) : '</li>'
+          <div class="context" id="c#{id}">
+            #{frame[:pre_context] ? (<<END3) : ''
+            <ol start="#{frame[:pre_context_lineno]+1}" id="bc#{id}">
+              #{frame[:pre_context].map{|line| "<li>#{h line}</li>"}.join}
+            </ol>
+END3
+}
+
+            <ol start="#{frame[:lineno]}" class="context-line">
+              <li>#{h frame[:context_line]}<span>...</span></li>
+            </ol>
+
+            #{frame[:post_context] ? (<<END4) : ''
+            <ol start='#{frame[:lineno]+1}' id="ac#{id}">
+              #{frame[:post_context].map{|line| "<li>#{h line}</li>"}.join}
+            </ol>
+END4
+}
+          </div>
+END2
+}
+END1
+}
+  </ul>
+</div>
+
+<div id="requestinfo">
+  <h2>Request information</h2>
+
+  #{info.call('GET', 'get-info', r.GET, 'No GET data')}
+  #{info.call('POST', 'post-info', post_data, missing_post)}
+  #{info.call('Cookies', 'cookie-info', r.cookies, 'No cookie data')}
+  #{info.call('Rack ENV', 'env-info', r.env, 'No Rack env?')}
+</div>
+
+<div id="explanation">
+  <p>
+    You're seeing this error because you use the Roda exception_page plugin.
+  </p>
+</div>
+
+#{js}
+</body>
+</html>
+END
+          else
+            @_response[RodaResponseHeaders::CONTENT_TYPE] = "text/plain"
+            "#{exception.class}: #{message}\n#{exception.backtrace.map{|l| "\t#{l}"}.join("\n")}"
+          end
+        end
+
+        # The CSS to use on the exception page
+        def exception_page_css
+          ExceptionPage.css
+        end
+
+        # The JavaScript to use on the exception page
+        def exception_page_js
+          ExceptionPage.js
+        end
+
+        private
+
+        if Exception.method_defined?(:detailed_message)
+          def exception_page_exception_message(exception)
+            exception.detailed_message(highlight: false).to_s
+          end
+        # :nocov:
+        else
+          # Return message to use for exception.
+          def exception_page_exception_message(exception)
+            exception.message.to_s
+          end
+        end
+        # :nocov:
+      end
+
+      module RequestMethods
+        # Serve exception page assets
+        def exception_page_assets
+          get 'exception_page.css' do
+            response[RodaResponseHeaders::CONTENT_TYPE] = "text/css"
+            scope.exception_page_css
+          end
+          get 'exception_page.js' do
+            response[RodaResponseHeaders::CONTENT_TYPE] = "application/javascript"
+            scope.exception_page_js
+          end
+        end
+      end
+    end
+
+    register_plugin(:exception_page, ExceptionPage)
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The skip_common_logger plugin allows for skipping common_logger logging
+    # of some requests. You pass a block when loading the plugin, and the
+    # block will be called before logging each request.  The block should return
+    # whether the request should be logged.
+    #
+    # Example:
+    #
+    #   # Only log server errors
+    #   plugin :filter_common_logger do |result|
+    #     result[0] >= 500
+    #   end
+    #
+    #   # Don't log requests to certain paths
+    #   plugin :filter_common_logger do |_|
+    #     # Block is called in the same context as the route block
+    #     !request.path.start_with?('/admin/')
+    #   end
+    module FilterCommonLogger
+      def self.load_dependencies(app, &_)
+        app.plugin :common_logger
+      end
+
+      def self.configure(app, &block)
+        app.send(:define_method, :_common_log_request?, &block)
+        app.send(:private, :_common_log_request?)
+        app.send(:alias_method, :_common_log_request?, :_common_log_request?)
+      end
+
+      module InstanceMethods
+        private
+
+        # Log request/response information in common log format to logger.
+        def _roda_after_90__common_logger(result)
+          super if result && _common_log_request?(result)
+        end
+      end
+    end
+
+    register_plugin(:filter_common_logger, FilterCommonLogger)
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen-string-literal: true
+
+require 'delegate'
+
+class Roda
+  module RodaPlugins
+    # The flash plugin adds a +flash+ instance method to Roda,
+    # for typical web application flash handling, where values
+    # set in the current flash hash are available in the next
+    # request.
+    #
+    # With the example below, if a POST request is submitted,
+    # it will redirect and the resulting GET request will
+    # return 'b'.
+    #
+    #   plugin :flash
+    #
+    #   route do |r|
+    #     r.is '' do
+    #       r.get do
+    #         flash['a']
+    #       end
+    #
+    #       r.post do
+    #         flash['a'] = 'b'
+    #         r.redirect('')
+    #       end
+    #     end
+    #   end
+    #
+    # You can modify the flash for the current request (instead of
+    # the next request) by using the +flash.now+ method:
+    #
+    #   r.get do
+    #     flash.now['a'] = 'b'
+    #     flash['a'] # = >'b'
+    #   end
+    module Flash
+      SCOPE_INSTANCE_VARIABLES = [:@_flash].freeze
+
+      # Simple flash hash, where assiging to the hash updates the flash
+      # used in the following request.
+      class FlashHash < DelegateClass(Hash)
+        # The flash hash for the next request.  This
+        # is what gets written to by #[]=.
+        attr_reader :next 
+
+        # The flash hash for the current request
+        alias now __getobj__
+
+        # Setup the next hash when initializing, and handle treat nil
+        # as a new empty hash.
+        def initialize(hash={})
+          super(hash||{})
+          @next = {}
+        end
+
+        # Update the next hash with the given key and value.
+        def []=(k, v)
+          @next[k] = v
+        end
+
+        # Remove given key from the next hash, or clear the next hash if
+        # no argument is given.
+        def discard(key=(no_arg=true))
+          if no_arg
+            @next.clear
+          else
+            @next.delete(key)
+          end
+        end
+
+        # Copy the entry with the given key from the current hash to the
+        # next hash, or copy all entries from the current hash to the
+        # next hash if no argument is given.
+        def keep(key=(no_arg=true))
+          if no_arg
+            @next.merge!(self)
+          else
+            self[key] = self[key]
+          end
+        end
+
+        # Replace the current hash with the next hash and clear the next hash.
+        def sweep
+          replace(@next)
+          @next.clear
+          self
+        end
+      end
+
+      module InstanceMethods
+        # Access the flash hash for the current request, loading
+        # it from the session if it is not already loaded.
+        def flash
+          # :_flash to support transparent upgrades from previous key
+          @_flash ||= FlashHash.new(session['_flash'] || (session['_flash'] = session.delete(:_flash)))
+        end
+
+        private
+
+        # If the routing doesn't raise an error, rotate the flash
+        # hash in the session so the next request has access to it.
+        def _roda_after_40__flash(_)
+          if f = @_flash
+            f = f.next
+            if f.empty?
+              session.delete('_flash')
+            else
+              session['_flash'] = f
+            end
+          end
+        end
+      end
+    end
+
+    register_plugin(:flash, Flash)
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The h plugin adds an +h+ instance method that will HTML
+    # escape the input and return it.
+    #
+    # The following example will return "<foo>" as the body.
+    #
+    #   plugin :h
+    #
+    #   route do |r|
+    #     h('<foo>')
+    #   end
+    module H
+      begin
+        require 'cgi/escape'
+        unless CGI.respond_to?(:escapeHTML) # work around for JRuby 9.1
+          # :nocov:
+          CGI = Object.new
+          CGI.extend(defined?(::CGI::Escape) ? ::CGI::Escape : ::CGI::Util)
+          # :nocov:
+        end
+
+        module InstanceMethods
+          # HTML escape the input and return the escaped version.
+          def h(string)
+            CGI.escapeHTML(string.to_s)
+          end
+        end
+      rescue LoadError
+        # :nocov:
+
+        # A Hash of entities and their escaped equivalents,
+        # to be escaped by h().
+        ESCAPE_HTML = {
+          "&" => "&amp;".freeze,
+          "<" => "&lt;".freeze,
+          ">" => "&gt;".freeze,
+          "'" => "&#39;".freeze,
+          '"' => "&quot;".freeze,
+        }.freeze
+
+        # A Regexp of HTML entities to match for escaping.
+        ESCAPE_HTML_PATTERN = Regexp.union(*ESCAPE_HTML.keys)
+
+        module InstanceMethods
+          def h(string)
+            string.to_s.gsub(ESCAPE_HTML_PATTERN){|c| ESCAPE_HTML[c] }
+          end
+        end
+        # :nocov:
+      end
+    end
+
+    register_plugin(:h, H)
+  end
+end