ultra-max-sys 0.0.1

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

@@ -0,0 +1,108 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The typecast_params_sized_integers plugin adds sized integer conversion
+    # methods to typecast_params:
+    #
+    # * int8, uint8, pos_int8, pos_uint8, Integer8, Integeru8
+    # * int16, uint16, pos_int16, pos_uint16, Integer16, Integeru16
+    # * int32, uint32, pos_int32, pos_uint32, Integer32, Integeru32
+    # * int64, uint64, pos_int64, pos_uint64, Integer64, Integeru64
+    #
+    # The int*, pos_int*, and Integer* methods operate the same as the
+    # standard int, pos_int, and Integer methods in typecast_params,
+    # except that they will only handle parameter values in the given
+    # range for the signed integer type.  The uint*, pos_int*, and
+    # Integeru* methods are similar to the int*, pos_int*, and
+    # Integer* methods, except they use the range of the unsigned
+    # integer type instead of the range of the signed integer type.
+    #
+    # Here are the signed and unsigned integer type ranges:
+    # 8 :: [-128, 127], [0, 255]
+    # 16 :: [-32768, 32767], [0, 65535]
+    # 32 :: [-2147483648, 2147483647], [0, 4294967295]
+    # 64 :: [-9223372036854775808, 9223372036854775807], [0, 18446744073709551615]
+    #
+    # To only create methods for certain integer sizes, you can pass a
+    # :sizes option when loading the plugin, and it will only create
+    # methods for the sizes you specify.
+    #
+    # You can provide a :default_size option when loading the plugin,
+    # in which case the int, uint, pos_int, pos_uint, Integer, and Integeru,
+    # typecast_params conversion methods will be aliases to the conversion
+    # methods for the given sized type:
+    #
+    #  plugin :typecast_params_sized_integers, default_size: 64
+    #
+    #  route do |r|
+    #    # Returns nil unless param.to_i > 0 && param.to_i <= 9223372036854775807
+    #    typecast_params.pos_int('param_name')
+    #  end
+    module TypecastParamsSizedIntegers
+      def self.load_dependencies(app, opts=OPTS)
+        app.plugin :typecast_params do
+          (opts[:sizes] || [8, 16, 32, 64]).each do |i|
+            # Avoid defining the same methods more than once
+            next if method_defined?(:"pos_int#{i}")
+
+            min_signed = -(2**(i-1))
+            max_signed = 2**(i-1)-1
+            max_unsigned = 2**i-1
+
+            handle_type(:"int#{i}", :max_input_bytesize=>100, :invalid_value_message=>"empty string, non-integer, or too-large integer provided for parameter") do |v|
+              if (v = base_convert_int(v)) && v >= min_signed && v <= max_signed
+                v
+              end
+            end
+
+            handle_type(:"uint#{i}", :max_input_bytesize=>100, :invalid_value_message=>"empty string, non-integer, negative integer, or too-large integer provided for parameter") do |v|
+              if (v = base_convert_int(v)) && v >= 0 && v <= max_unsigned
+                v
+              end
+            end
+
+            handle_type(:"pos_int#{i}", :max_input_bytesize=>100, :invalid_value_message=>"empty string, non-integer, non-positive integer, or too-large integer provided for parameter") do |v|
+              if (v = base_convert_int(v)) && v > 0 && v <= max_signed
+                v
+              end
+            end
+
+            handle_type(:"pos_uint#{i}", :max_input_bytesize=>100, :invalid_value_message=>"empty string, non-integer, non-positive integer, or too-large integer provided for parameter") do |v|
+              if (v = base_convert_int(v)) && v > 0 && v <= max_unsigned
+                v
+              end
+            end
+
+            handle_type(:"Integer#{i}", :max_input_bytesize=>100, :invalid_value_message=>"empty string, non-integer, or too-large integer provided for parameter") do |v|
+              if (v = base_convert_Integer(v)) && v >= min_signed && v <= max_signed
+                v
+              end
+            end
+
+            handle_type(:"Integeru#{i}", :max_input_bytesize=>100, :invalid_value_message=>"empty string, non-integer, negative integer, or too-large integer provided for parameter") do |v|
+              if (v = base_convert_Integer(v)) && v >= 0 && v <= max_unsigned
+                v
+              end
+            end
+          end
+        end
+
+        if default = opts[:default_size]
+          app::TypecastParams.class_eval do
+            meths = ['', 'convert_', '_convert_array_', '_max_input_bytesize_for_', '_invalid_value_message_for_']
+            %w[int uint pos_int pos_uint Integer Integeru].each do |type|
+              meths.each do |prefix|
+                alias_method :"#{prefix}#{type}", :"#{prefix}#{type}#{default}"
+              end
+              alias_method :"#{type}!", :"#{type}#{default}!"
+            end
+          end
+        end
+      end
+    end
+
+    register_plugin(:typecast_params_sized_integers, TypecastParamsSizedIntegers)
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen-string-literal: true
+
+require 'rack/utils'
+
+#
+class Roda
+  module RodaPlugins
+    # The unescape_path plugin decodes a URL-encoded path
+    # before routing.  This fixes routing when the slashes
+    # are URL-encoded as %2f and returns decoded parameters
+    # when matched by symbols or regexps.
+    #
+    #   plugin :unescape_path
+    #
+    #   route do |r|
+    #     # Assume /b/a URL encoded at %2f%62%2f%61
+    #     r.on :x, /(.)/ do |*x|
+    #       # x => ['b', 'a']
+    #     end
+    #   end
+    module UnescapePath
+      module RequestMethods
+        # Make sure the matched path calculation handles the unescaping
+        # of the remaining path.
+        def matched_path
+          e = @env
+          Rack::Utils.unescape(e["SCRIPT_NAME"] + e["PATH_INFO"]).chomp(@remaining_path)
+        end
+
+        private
+
+        # Unescape the path.
+        def _remaining_path(env)
+          Rack::Utils.unescape(super)
+        end
+      end
+    end
+
+    register_plugin(:unescape_path, UnescapePath)
+  end
+end

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

@@ -0,0 +1,203 @@
+# frozen-string-literal: true
+
+require_relative 'render'
+
+#
+class Roda
+  module RodaPlugins
+    # The view_options plugin allows you to override view and layout
+    # options for specific branches and routes.
+    #
+    #   plugin :render
+    #   plugin :view_options
+    #
+    #   route do |r|
+    #     r.on "users" do
+    #       set_layout_options template: 'users_layout'
+    #       set_view_options engine: 'haml'
+    #
+    #       # ...
+    #     end
+    #   end
+    #
+    # The options you specify via the set_view_options and
+    # set_layout_options methods have higher precedence than
+    # the render plugin options, but lower precedence than options
+    # you directly pass to the view/render methods.
+    #
+    # = View Subdirectories
+    #
+    # The view_options plugin also has special support for sites
+    # that have outgrown a flat view directory and use subdirectories
+    # for views.  It allows you to set the view directory to
+    # use, and template names that do not contain a slash will
+    # automatically use that view subdirectory.  Example:
+    #
+    #   plugin :render, layout: './layout'
+    #   plugin :view_options
+    #
+    #   route do |r|
+    #     r.on "users" do
+    #       set_view_subdir 'users'
+    #       
+    #       r.get Integer do |id|
+    #         append_view_subdir 'profile'
+    #         view 'index' # uses ./views/users/profile/index.erb
+    #       end
+    #
+    #       r.get 'list' do
+    #         view 'lists/users' # uses ./views/lists/users.erb
+    #       end
+    #     end
+    #   end
+    #
+    # Note that when a view subdirectory is set, the layout will
+    # also be looked up in the subdirectory unless it contains
+    # a slash.  So if you want to use a view subdirectory for
+    # templates but have a shared layout, you should make sure your
+    # layout contains a slash, similar to the example above.
+    #
+    # = Per-branch HTML escaping
+    #
+    # If you have an existing Roda application that doesn't use
+    # automatic HTML escaping for <tt><%= %></tt> tags via the
+    # render plugin's +:escape+ option, but you want to switch to
+    # using the +:escape+ option, you can now do so without making
+    # all changes at once.  With set_view_options, you can now
+    # specify escaping or not on a per branch basis in the routing
+    # tree:
+    #
+    #   plugin :render, escape: true
+    #   plugin :view_options
+    #
+    #   route do |r|
+    #     # Don't escape <%= %> by default
+    #     set_view_options template_opts: {escape: false}
+    #
+    #     r.on "users" do
+    #       # Escape <%= %> in this branch
+    #       set_view_options template_opts: {escape: true}
+    #     end
+    #   end
+    module ViewOptions
+      SCOPE_INSTANCE_VARIABLES = [:@_view_subdir, :@_view_options, :@_layout_options].freeze
+
+      # Load the render plugin before this plugin, since this plugin
+      # works by overriding methods in the render plugin.
+      def self.load_dependencies(app)
+        app.plugin :render
+      end
+
+      module InstanceMethods
+        # Append a view subdirectory to use.  If there hasn't already
+        # been a view subdirectory set, this just sets it to the argument.
+        # If there has already been a view subdirectory set, this sets
+        # the view subdirectory to a subdirectory of the existing
+        # view subdirectory.
+        def append_view_subdir(v)
+          if subdir = @_view_subdir
+            set_view_subdir("#{subdir}/#{v}")
+          else
+            set_view_subdir(v)
+          end
+        end
+
+        # Set the view subdirectory to use.  This can be set to nil
+        # to not use a view subdirectory.
+        def set_view_subdir(v)
+          @_view_subdir = v
+        end
+
+        # Set branch/route options to use when rendering the layout
+        def set_layout_options(opts)
+          if options = @_layout_options
+            @_layout_options = options.merge!(opts)
+          else
+            @_layout_options = opts
+          end
+        end
+
+        # Set branch/route options to use when rendering the view
+        def set_view_options(opts)
+          if options = @_view_options
+            @_view_options = options.merge!(opts)
+          else
+            @_view_options = opts
+          end
+        end
+
+        private
+
+        if Render::COMPILED_METHOD_SUPPORT
+          # Return nil if using custom view or layout options.
+          # If using a view subdir, prefix the template key with the subdir.
+          def _cached_template_method_key(template)
+            return if @_view_options || @_layout_options
+
+            if subdir = @_view_subdir
+              template = [subdir, template].freeze
+            end
+
+            super
+          end
+
+          # Return nil if using custom view or layout options.
+          # If using a view subdir, prefix the template key with the subdir.
+          def _cached_template_method_lookup(method_cache, template)
+            return if @_view_options || @_layout_options
+
+            if subdir = @_view_subdir
+              template = [subdir, template]
+            end
+
+            super
+          end
+        end
+
+        # If view options or locals have been set and this
+        # template isn't a layout template, merge the options
+        # and locals into the returned hash.
+        def parse_template_opts(template, opts)
+          t_opts = super
+
+          if !t_opts[:_is_layout] && (v_opts = @_view_options)
+            t_opts.merge!(v_opts)
+          end
+
+          t_opts
+        end
+
+        # If layout options or locals have been set,
+        # merge the options and locals into the returned hash.
+        def render_layout_opts
+          opts = super
+
+          if l_opts = @_layout_options
+            opts.merge!(l_opts)
+          end
+
+          opts
+        end
+
+        # Override the template name to use the view subdirectory if the
+        # there is a view subdirectory and the template name does not
+        # contain a slash.
+        def template_name(opts)
+          name = super
+          if (v = @_view_subdir) && use_view_subdir_for_template_name?(name)
+            "#{v}/#{name}"
+          else
+            name
+          end
+        end
+
+        # Whether to use a view subdir for the template name.
+        def use_view_subdir_for_template_name?(name)
+          !name.include?('/')
+        end
+      end
+    end
+
+    register_plugin(:view_options, ViewOptions)
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The view_subdir_leading_slash plugin builds on the view_options
+    # plugin, and changes the behavior so that if a view subdir is set,
+    # it is used for all templates, unless the template starts with a
+    # leading slash:
+    #
+    #   plugin :view_subdir_leading_slash
+    #
+    #   route do |r|
+    #     r.on "users" do
+    #       set_view_subdir 'users'
+    #       
+    #       r.get 'list' do
+    #         view 'lists/users' # uses ./views/users/lists/users.erb
+    #       end
+    #
+    #       r.get 'list' do
+    #         view '/lists/users' # uses ./views//lists/users.erb
+    #       end
+    #     end
+    #   end
+    #
+    # The default for the view_options plugin is to not use a
+    # view subdir if the template name contains a slash at all.
+    module ViewSubdirLeadingSlash
+      # Load the view_options plugin before this plugin, since this plugin
+      # works by overriding a method in the view_options plugin.
+      def self.load_dependencies(app)
+        app.plugin :view_options
+      end
+
+      module InstanceMethods
+        private
+
+        # Use a view subdir unless the template starts with a slash.
+        def use_view_subdir_for_template_name?(name)
+          !name.start_with?('/')
+        end
+      end
+    end
+
+    register_plugin(:view_subdir_leading_slash, ViewSubdirLeadingSlash)
+  end
+end
+

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

@@ -0,0 +1,68 @@
+# frozen-string-literal: true
+
+require_relative "cache"
+
+class Roda
+  # Module in which all Roda plugins should be stored. Also contains logic for
+  # registering and loading plugins.
+  module RodaPlugins
+    OPTS = {}.freeze
+    EMPTY_ARRAY = [].freeze
+
+    # Stores registered plugins
+    @plugins = RodaCache.new
+
+    class << self
+      # Make warn a public method, as it is used for deprecation warnings.
+      # Roda::RodaPlugins.warn can be overridden for custom handling of
+      # deprecation warnings.
+      public :warn
+    end
+
+    # If the registered plugin already exists, use it.  Otherwise,
+    # require it and return it.  This raises a LoadError if such a
+    # plugin doesn't exist, or a RodaError if it exists but it does
+    # not register itself correctly.
+    def self.load_plugin(name)
+      h = @plugins
+      unless plugin = h[name]
+        require "roda/plugins/#{name}"
+        raise RodaError, "Plugin #{name} did not register itself correctly in Roda::RodaPlugins" unless plugin = h[name]
+      end
+      plugin
+    end
+
+    # Register the given plugin with Roda, so that it can be loaded using #plugin
+    # with a symbol.  Should be used by plugin files. Example:
+    #
+    #   Roda::RodaPlugins.register_plugin(:plugin_name, PluginModule)
+    def self.register_plugin(name, mod)
+      @plugins[name] = mod
+    end
+
+    # Deprecate the constant with the given name in the given module,
+    # if the ruby version supports it.
+    def self.deprecate_constant(mod, name)
+      # :nocov:
+      if RUBY_VERSION >= '2.3'
+        mod.deprecate_constant(name)
+      end
+      # :nocov:
+    end
+
+    if RUBY_VERSION >= '3.3'
+      # Create a new module using the block, and set the temporary name
+      # on it using the given a containing module and name.
+      def self.set_temp_name(mod)
+        mod.set_temporary_name(yield)
+        mod
+      end
+    # :nocov:
+    else
+      def self.set_temp_name(mod)
+        mod
+      end
+    end
+    # :nocov:
+  end
+end