ultra-max-sys 0.0.1

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

@@ -0,0 +1,105 @@
+# frozen-string-literal: true
+
+require 'tilt'
+# :nocov:
+raise 'Tilt version does not support coverable templates' unless Tilt::Template.method_defined?(:compiled_path=)
+# :nocov:
+
+#
+class Roda
+  module RodaPlugins
+    # The render_coverage plugin builds on top of the render plugin
+    # and sets compiled_path on created templates.  This allows
+    # Ruby's coverage library before Ruby 3.2 to consider code created
+    # by templates. You may not need this plugin on Ruby 3.2+, since
+    # on Ruby 3.2+, coverage can consider code loaded with +eval+.
+    # This plugin is only supported when using tilt 2.1+, since it
+    # requires the compiled_path supported added in tilt 2.1. 
+    #
+    # By default, the render_coverage plugin will use +coverage/views+
+    # as the directory containing the compiled template files.  You can
+    # change this by passing the :dir option when loading the plugin.
+    # By default, the plugin will set the compiled_path by taking the
+    # template file path, stripping off any of the allowed_paths used
+    # by the render plugin, and converting slashes to dashes. You can
+    # override the allowed_paths to strip by passing the :strip_paths
+    # option when loading the plugin.  Paths outside :strip_paths (or
+    # the render plugin allowed_paths if :strip_paths is not set) will
+    # not have a compiled_path set.
+    #
+    # Due to how Ruby's coverage library works in regards to loading
+    # a compiled template file with identical code more than once,
+    # it may be beneficial to run coverage testing with the
+    # +RODA_RENDER_COMPILED_METHOD_SUPPORT+ environment variable set
+    # to +no+ if using this plugin.
+    module RenderCoverage
+      def self.load_dependencies(app, opts=OPTS)
+        app.plugin :render
+      end
+
+      # Use the :dir option to set the directory to store the compiled
+      # template files, and the :strip_paths directory for paths to
+      # strip.
+      def self.configure(app, opts=OPTS)
+        app.opts[:render_coverage_strip_paths] = opts[:strip_paths].map{|f| File.expand_path(f)} if opts.has_key?(:strip_paths)
+        coverage_dir = app.opts[:render_coverage_dir] = opts[:dir] || app.opts[:render_coverage_dir] || 'coverage/views'
+        Dir.mkdir(coverage_dir) unless File.directory?(coverage_dir)
+      end
+
+      module ClassMethods
+        # Set a compiled path on the created template, if the path for
+        # the template is in one of the allowed_views.
+        def create_template(opts, template_opts)
+          return super if opts[:template_block]
+
+          path = File.expand_path(opts[:path])
+          compiled_path = nil
+          (self.opts[:render_coverage_strip_paths] || render_opts[:allowed_paths]).each do |dir|
+            if path.start_with?(dir + '/')
+              compiled_path = File.join(self.opts[:render_coverage_dir], path[dir.length+1, 10000000].tr('/', '-'))
+              break
+            end
+          end
+
+          # For Tilt 2.6+, when using :scope_class and fixed locals, must provide
+          # compiled path as option, since compilation happens during initalization
+          # in that case. This option should be ignored if the template does not
+          # support it, but some template class may break if the option is not
+          # handled, so for compatibility, only set the method if Tilt::Template
+          # will handle it.
+          if compiled_path && Tilt::Template.method_defined?(:fixed_locals?)
+            template_opts = template_opts.dup
+            template_opts[:compiled_path] = compiled_path
+            compiled_path = nil
+          end
+
+          template = super
+
+          # Set compiled path for template when using older tilt versions.
+          # :nocov:
+          template.compiled_path = compiled_path if compiled_path
+          # :nocov:
+
+          template
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # Convert template paths to real paths to try to ensure the same template is cached.
+        def template_path(opts)
+          path = super
+
+          if File.file?(path)
+            File.realpath(path)
+          else
+            path
+          end
+        end
+      end
+    end
+
+    register_plugin(:render_coverage, RenderCoverage)
+  end
+end

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

@@ -0,0 +1,224 @@
+# frozen-string-literal: true
+
+require_relative 'render'
+
+#
+class Roda
+  module RodaPlugins
+    # The render_each plugin allows you to render a template for each
+    # value in an enumerable, returning the concatention of all of the
+    # template renderings.  For example:
+    #
+    #   render_each([1,2,3], :foo)
+    #
+    # will render the +foo+ template 3 times.  Each time the template
+    # is rendered, the local variable +foo+ will contain the given
+    # value (e.g. on the first rendering +foo+ is 1).
+    #
+    # If you provide a block when calling the method, it will yield
+    # each rendering instead of returning a concatentation of the
+    # renderings. This is useful if you want to wrap each rendering in
+    # something else.  For example, instead of calling +render+ multiple
+    # times in a loop:
+    #
+    #   <% [1,2,3].each do |v| %>
+    #     <p><%= render(:foo, locals: {foo: v}) %></p>
+    #   <% end %>
+    #  
+    # You can use +render_each+, allowing for simpler and more optimized
+    # code:
+    #
+    #   <% render_each([1,2,3], :foo) do |text| %>
+    #     <p><%= text %></p>
+    #   <% end %>
+    #
+    # You can also provide a block to avoid excess memory usage.  For
+    # example, if you are calling the method inside an erb template,
+    # instead of doing:
+    #
+    #   <%= render_each([1,2,3], :foo) %>
+    #
+    # You can do:
+    #
+    #   <% render_each([1,2,3], :foo) %><%= body %><% end %>
+    #
+    # This results in the same behavior, but avoids building a large
+    # intermediate string just to concatenate to the template result.
+    #
+    # When passing a block, +render_each+ returns +nil+.
+    #
+    # You can pass additional render options via an options hash:
+    #
+    #   render_each([1,2,3], :foo, views: 'partials')
+    #
+    # One additional option supported by is +:local+, which sets the
+    # local variable containing the current value to use.  So:
+    #
+    #   render_each([1,2,3], :foo, local: :bar)
+    #
+    # Will render the +foo+ template, but the local variable used inside
+    # the template will be +bar+.  You can use <tt>local: nil</tt> to
+    # not set a local variable inside the template. By default, the
+    # local variable name is based on the template name, with any
+    # directories and file extensions removed.
+    module RenderEach
+      # Load the render plugin before this plugin, since this plugin
+      # calls the render method.
+      def self.load_dependencies(app)
+        app.plugin :render
+      end
+
+      ALLOWED_KEYS = [:locals, :local].freeze
+
+      if Render::COMPILED_METHOD_SUPPORT
+        module ClassMethods
+          # If using compiled methods and assuming fixed locals, optimize
+          # _cached_render_each_template_method.
+          def freeze
+            if render_opts[:assume_fixed_locals] && !render_opts[:check_template_mtime]
+              include AssumeFixedLocalsInstanceMethods
+            end
+
+            super
+          end
+        end
+
+        module AssumeFixedLocalsInstanceMethods
+          private
+
+          # Optimize method since this module is only loaded when using fixed locals
+          # and when caching templates.
+          def _cached_render_each_template_method(template)
+            case template
+            when String, Symbol
+              _cached_template_method_lookup(render_opts[:template_method_cache], template)
+            else
+              false
+            end
+          end
+        end
+      end
+
+      module InstanceMethods
+        # For each value in enum, render the given template using the
+        # given opts.  The template and options hash are passed to +render+.
+        # Additional options supported:
+        # :local :: The local variable to use for the current enum value
+        #           inside the template.  An explicit +nil+ value does not
+        #           set a local variable.  If not set, uses the template name.
+        def render_each(enum, template, opts=(no_opts = true; optimized_template = _cached_render_each_template_method(template); OPTS), &block)
+          if optimized_template
+            return _optimized_render_each(enum, optimized_template, render_each_default_local(template), {}, &block)
+          elsif opts.has_key?(:local)
+            as = opts[:local]
+          else
+            as = render_each_default_local(template)
+            if no_opts && optimized_template.nil? && (optimized_template = _optimized_render_method_for_locals(template, (locals = {as=>nil})))
+              return _optimized_render_each(enum, optimized_template, as, locals, &block)
+            end
+          end
+
+          if as
+            opts = opts.dup
+            if locals
+              opts[:locals] = locals
+            else
+              locals = opts[:locals] = if locals = opts[:locals]
+                Hash[locals]
+              else
+                {}
+              end
+              locals[as] = nil
+            end
+
+            if (opts.keys - ALLOWED_KEYS).empty? && (optimized_template = _optimized_render_method_for_locals(template, locals))
+              return _optimized_render_each(enum, optimized_template, as, locals, &block)
+            end
+          end
+
+          if defined?(yield)
+            enum.each do |v|
+              locals[as] = v if as
+              yield render_template(template, opts)
+            end
+            nil
+          else
+            enum.map do |v|
+              locals[as] = v if as
+              render_template(template, opts)
+            end.join
+          end
+        end
+        
+        private
+
+        if File.basename("a/b") == "b" && File.basename("a\\b") == "a\\b" && RUBY_VERSION >= '3'
+          # The default local variable name to use for the template, if the :local option
+          # is not used when calling render_each.
+          def render_each_default_local(template)
+            # Optimize to avoid allocations when possible
+            template = case template
+            when Symbol
+              s = template.name
+              return template unless s.include?("/") || s.include?(".")
+              s
+            when String
+              return template.to_sym unless template.include?("/") || template.include?(".")
+              template
+            else
+              template.to_s
+            end
+
+            File.basename(template).sub(/\..+\z/, '').to_sym
+          end
+        # :nocov:
+        else
+          def render_each_default_local(template)
+            File.basename(template.to_s).sub(/\..+\z/, '').to_sym
+          end
+        # :nocov:
+        end
+
+        if Render::COMPILED_METHOD_SUPPORT
+          # If compiled method support is enabled in the render plugin, return the
+          # method name to call to render the template.  Return false if not given
+          # a string or symbol, or if compiled method support for this template has
+          # been explicitly disabled.  Otherwise return nil.
+          def _cached_render_each_template_method(template)
+            case template
+            when String, Symbol
+              if (method_cache = render_opts[:template_method_cache])
+                key = render_opts[:assume_fixed_locals] ? template : [:_render_locals, template, [template.to_sym]]
+                _cached_template_method_lookup(method_cache, key)
+              end
+            else
+              false
+            end
+          end
+
+          # Use an optimized render for each value in the enum.
+          def _optimized_render_each(enum, optimized_template, as, locals)
+            if defined?(yield)
+              enum.each do |v|
+                locals[as] = v
+                yield _call_optimized_template_method(optimized_template, locals)
+              end
+              nil
+            else
+              enum.map do |v|
+                locals[as] = v
+                _call_optimized_template_method(optimized_template, locals)
+              end.join
+            end
+          end
+        else
+          def _cached_render_each_template_method(template)
+            nil
+          end
+        end
+      end
+    end
+
+    register_plugin(:render_each, RenderEach)
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen-string-literal: true
+
+require_relative 'render'
+
+#
+class Roda
+  module RodaPlugins
+    # The render_locals plugin allows setting default locals for rendering templates.
+    #
+    #   plugin :render_locals, render: {heading: 'Hello'}
+    #
+    #   route do |r|
+    #     r.get "foo" do
+    #       view 'foo', locals: {name: 'Foo'} # locals: {:heading=>'Hello', :name=>'Foo'}
+    #     end
+    #
+    #     r.get "bar" do
+    #       view 'foo', locals: {heading: 'Bar'} # locals: {:heading=>'Bar'}
+    #     end
+    #
+    #     view "default" # locals: {:heading=>'Hello'}
+    #   end
+    #
+    # The render_locals plugin accepts the following options:
+    #
+    # render :: The default locals to use for template rendering
+    # layout :: The default locals to use for layout rendering
+    # merge :: Whether to merge template locals into layout locals
+    module RenderLocals
+      def self.load_dependencies(app, opts=OPTS)
+        app.plugin :render
+      end
+
+      def self.configure(app, opts=OPTS)
+        app.opts[:render_locals] = (app.opts[:render_locals] || {}).merge(opts[:render]||{}).freeze
+        app.opts[:layout_locals] = (app.opts[:layout_locals] || {}).merge(opts[:layout]||{}).freeze
+        if opts.has_key?(:merge)
+          app.opts[:merge_locals] = opts[:merge]
+          app.opts[:layout_locals] = app.opts[:render_locals].merge(app.opts[:layout_locals]).freeze
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        if Render::COMPILED_METHOD_SUPPORT
+          # Disable use of cached templates, since it assumes a render/view call with no
+          # options will have no locals.
+          def _cached_template_method(template)
+            nil
+          end
+
+          def _optimized_view_content(template)
+            nil
+          end
+        end
+
+        def render_locals
+          opts[:render_locals]
+        end
+
+        def layout_locals
+          opts[:layout_locals]
+        end
+
+        # If this isn't the layout template, then use the plugin's render locals as the default locals.
+        def render_template_opts(template, opts)
+          opts = super
+          return opts if opts[:_is_layout]
+
+          plugin_locals = render_locals
+          if locals = opts[:locals]
+            plugin_locals = Hash[plugin_locals].merge!(locals)
+          end
+          opts[:locals] = plugin_locals
+          opts
+        end
+
+        # If using a layout, then use the plugin's layout locals as the default locals.
+        def view_layout_opts(opts)
+          if layout_opts = super
+            merge_locals = layout_opts.has_key?(:merge_locals) ? layout_opts[:merge_locals] : self.opts[:merge_locals] 
+
+            locals = {}
+            locals.merge!(layout_locals)
+            if merge_locals && (method_locals = opts[:locals])
+              locals.merge!(method_locals)
+            end
+            if method_layout_locals = layout_opts[:locals]
+              locals.merge!(method_layout_locals)
+            end
+
+            layout_opts[:locals] = locals
+            layout_opts
+          end
+        end
+      end
+    end
+
+    register_plugin(:render_locals, RenderLocals)
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The request_aref plugin allows for custom handling of the r[] and r[]=
+    # methods (where r is the Request instance).  In the current version of
+    # rack, these methods are deprecated, but the deprecation message is only
+    # printed in verbose mode.  This plugin can allow for handling calls to
+    # these methods in one of three ways:
+    #
+    # :allow :: Allow the method calls without a deprecation, which is the
+    #           historical behavior
+    # :warn :: Always issue a deprecation message by calling +warn+, not just
+    #          in verbose mode.
+    # :raise :: Raise an error if either method is called
+    module RequestAref
+      # Make #[] and #[]= methods work as configured by aliasing the appropriate
+      # request_a(ref|set)_* methods to them.
+      def self.configure(app, setting)
+        case setting
+        when :allow, :raise, :warn
+          app::RodaRequest.class_eval do
+            alias_method(:[],  :"request_aref_#{setting}")
+            alias_method(:[]=, :"request_aset_#{setting}")
+            public :[], :[]=
+          end
+        else
+          raise RodaError, "Unsupport request_aref plugin setting: #{setting.inspect}"
+        end
+      end
+
+      # Exception class raised when #[] or #[]= are called when the
+      # :raise setting is used.
+      class Error < RodaError
+      end
+
+      module RequestMethods
+        private
+
+        # Allow #[] calls
+        def request_aref_allow(k)
+          params[k.to_s]
+        end
+
+        # Always warn on #[] calls
+        def request_aref_warn(k)
+          warn("#{self.class}#[] is deprecated, use #params.[] instead")
+          params[k.to_s]
+        end
+
+        # Raise error on #[] calls
+        def request_aref_raise(k)
+          raise Error, "#{self.class}#[] has been removed, use #params.[] instead"
+        end
+
+        # Allow #[]= calls
+        def request_aset_allow(k, v)
+          params[k.to_s] = v
+        end
+
+        # Always warn on #[]= calls
+        def request_aset_warn(k, v)
+          warn("#{self.class}#[]= is deprecated, use #params.[]= instead")
+          params[k.to_s] = v
+        end
+
+        # Raise error on #[]= calls
+        def request_aset_raise(k, v)
+          raise Error, "#{self.class}#[]= has been removed, use #params.[]= instead"
+        end
+      end
+    end
+
+    register_plugin(:request_aref, RequestAref)
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen-string-literal: true
+
+require 'set'
+
+class Roda
+  module RodaPlugins
+    # The request_headers plugin provides access to headers sent in the
+    # request in a more natural way than directly accessing the env hash.
+    #
+    # In practise this means you don't need to uppercase, convert dashes
+    # to underscores, or add a HTTP_ prefix.
+    #
+    # For example, to access a header called X-My-Header you
+    # would previously need to do:
+    #
+    #   r.env['HTTP_X_MY_HEADER']
+    #
+    # But with this plugin you can now say:
+    #
+    #   r.headers['X-My-Header']
+    #
+    # The name is actually case-insensitive so <tt>x-my-header</tt> will work as well.
+    #
+    # Example:
+    #
+    #   plugin :request_headers
+    module RequestHeaders
+      REQUEST_INSTANCE_VARIABLES = [:@request_headers].freeze
+
+      module RequestMethods
+        # Provide access to the request headers while normalizing indexes.
+        def headers
+          @request_headers ||= Headers.new(@env)
+        end
+      end
+
+      class Headers
+        # Set of environment variable names that don't need HTTP_ prepended to them.
+        CGI_VARIABLES = Set.new(%w'
+          AUTH_TYPE
+          CONTENT_LENGTH
+          CONTENT_TYPE
+          GATEWAY_INTERFACE
+          HTTPS
+          PATH_INFO
+          PATH_TRANSLATED
+          QUERY_STRING
+          REMOTE_ADDR
+          REMOTE_HOST
+          REMOTE_IDENT
+          REMOTE_USER
+          REQUEST_METHOD
+          SCRIPT_NAME
+          SERVER_NAME
+          SERVER_PORT
+          SERVER_PROTOCOL
+          SERVER_SOFTWARE
+        ').freeze
+
+        def initialize(env)
+          @env = env
+        end
+
+        # Returns the value for the given key mapped to @env
+        def [](key)
+          @env[env_name(key)]
+        end
+
+        private
+
+        # Convert a HTTP header name into an environment variable name
+        def env_name(key)
+          key = key.to_s.upcase
+          key.tr!('-', '_')
+          key = 'HTTP_' + key unless CGI_VARIABLES.include?(key)
+          key
+        end
+      end
+    end
+
+    register_plugin(:request_headers, RequestHeaders)
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen-string-literal: true
+
+require 'rack/mime'
+
+#
+class Roda
+  module RodaPlugins
+    # The attachment plugin adds a response.attachment method.
+    # When called with no filename, +attachment+ sets the Content-Disposition
+    # to attachment.  When called with a filename,+attachment+ sets the Content-Disposition
+    # to attachment with the appropriate filename parameter, and if the filename
+    # extension is recognized, this also sets the Content-Type to the appropriate
+    # MIME type if not already set.
+    #
+    #   # set Content-Disposition to 'attachment'
+    #   response.attachment
+    #
+    #   # set Content-Disposition to 'attachment; filename="a.csv"',
+    #   # also set Content-Type to 'text/csv'
+    #   response.attachment 'a.csv'
+    #
+    # == License
+    #
+    # The implementation was originally taken from Sinatra,
+    # which is also released under the MIT License:
+    #
+    # Copyright (c) 2007, 2008, 2009 Blake Mizerany
+    # Copyright (c) 2010, 2011, 2012, 2013, 2014 Konstantin Haase
+    # 
+    # 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 OR COPYRIGHT
+    # HOLDERS 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.
+    module ResponseAttachment
+      UTF8_ENCODING = Encoding.find('UTF-8')
+      ISO88591_ENCODING = Encoding.find('ISO-8859-1')
+      BINARY_ENCODING = Encoding.find('BINARY')
+
+      module ResponseMethods
+        # Set the Content-Disposition to "attachment" with the specified filename,
+        # instructing the user agents to prompt to save.
+        def attachment(filename = nil, disposition='attachment')
+          if filename
+            param_filename = File.basename(filename)
+            encoding = param_filename.encoding
+
+            needs_encoding = param_filename.gsub!(/[^ 0-9a-zA-Z!\#$&\+\.\^_`\|~]+/, '-')
+            params = "; filename=#{param_filename.inspect}"
+
+            if needs_encoding && (encoding == UTF8_ENCODING || encoding == ISO88591_ENCODING)
+              # File name contains non attr-char characters from RFC 5987 Section 3.2.1
+
+              encoded_filename = File.basename(filename).force_encoding(BINARY_ENCODING)
+              # Similar regexp as above, but treat each byte separately, and encode
+              # space characters, since those aren't allowed in attr-char
+              encoded_filename.gsub!(/[^0-9a-zA-Z!\#$&\+\.\^_`\|~]/) do |c|
+                "%%%X" % c.ord
+              end
+
+              encoded_params = "; filename*=#{encoding.to_s}''#{encoded_filename}"
+            end
+
+            unless @headers[RodaResponseHeaders::CONTENT_TYPE]
+              ext = File.extname(filename)
+              if !ext.empty? && (content_type = Rack::Mime.mime_type(ext, nil))
+                @headers[RodaResponseHeaders::CONTENT_TYPE] = content_type
+              end
+            end
+          end
+
+          @headers[RodaResponseHeaders::CONTENT_DISPOSITION] = "#{disposition}#{params}#{encoded_params}"
+        end
+      end
+    end
+
+    register_plugin(:response_attachment, ResponseAttachment)
+  end
+end