ultra-max-sys 0.0.1

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

@@ -0,0 +1,55 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The not_found plugin adds a +not_found+ class method which sets
+    # a block that is called whenever a 404 response with an empty body
+    # would be returned.  The usual use case for this is the desire for
+    # nice error pages if the page is not found.
+    #
+    # You can provide the block with the plugin call:
+    #
+    #   plugin :not_found do
+    #     "Where did it go?"
+    #   end
+    #   
+    # Or later via a separate call to +not_found+:
+    #
+    #   plugin :not_found
+    #
+    #   not_found do
+    #     "Where did it go?"
+    #   end
+    #
+    # Before not_found is called, any existing headers on the response
+    # will be cleared.  So if you want to be sure the headers are set
+    # even in a not_found block, you need to reset them in the
+    # not_found block.
+    #
+    # This plugin is now a wrapper around the +status_handler+ plugin and
+    # still exists mainly for backward compatibility.
+    module NotFound
+      # Require the status_handler plugin
+      def self.load_dependencies(app, &_)
+        app.plugin :status_handler
+      end
+
+      # If a block is given, install the block as the not_found handler.
+      def self.configure(app, &block)
+        if block
+          app.not_found(&block)
+        end
+      end
+
+      module ClassMethods
+        # Install the given block as the not_found handler.
+        def not_found(&block)
+          status_handler(404, &block)
+        end
+      end
+    end
+
+    register_plugin(:not_found, NotFound)
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The optimized_segment_matchers plugin adds two optimized matcher methods,
+    # +r.on_segment+ and +r.is_segment+.  +r.on_segment+ is an optimized version of
+    # +r.on String+ that accepts no arguments and yields the next segment if there
+    # is a segment. +r.is_segment+ is an optimized version of +r.is String+ that accepts
+    # no arguments and yields the next segment only if it is the last segment.
+    #
+    #   plugin :optimized_segment_matchers
+    #
+    #   route do |r|
+    #     r.on_segment do |x|
+    #       # matches any segment (e.g. /a, /b, but not /)
+    #       r.is_segment do |y|
+    #         # matches only if final segment (e.g. /a/b, /b/c, but not /c, /c/d/, /c/d/e)
+    #       end
+    #     end
+    #   end
+    module OptimizedSegmentMatchers
+      module RequestMethods
+        # Optimized version of +r.on String+ that yields the next segment if there
+        # is a segment.
+        def on_segment
+          rp = @remaining_path
+          if rp.getbyte(0) == 47
+            if last = rp.index('/', 1)
+              @remaining_path = rp[last, rp.length]
+              always{yield rp[1, last-1]}
+            elsif (len = rp.length) > 1
+              @remaining_path = ""
+              always{yield rp[1, len]}
+            end
+          end
+        end
+
+        # Optimized version of +r.is String+ that yields the next segment only if it
+        # is the final segment.
+        def is_segment
+          rp = @remaining_path
+          if rp.getbyte(0) == 47 && !rp.index('/', 1) && (len = rp.length) > 1
+            @remaining_path = ""
+            always{yield rp[1, len]}
+          end
+        end
+      end
+    end
+
+    register_plugin(:optimized_segment_matchers, OptimizedSegmentMatchers)
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The optimized_string_matchers plugin adds two optimized matcher methods,
+    # +r.on_branch+ and +r.is_exactly+.  +r.on_branch+ is an optimized version of
+    # +r.on+ that only accepts a single string, and +r.is_exactly+ is an
+    # optimized version of +r.is+ that only accepts a single string.
+    #
+    #   plugin :optimized_string_matchers
+    #
+    #   route do |r|
+    #     r.on_branch "x" do
+    #       # matches /x and paths starting with /x/
+    #       r.is_exactly "y" do
+    #         # matches /x/y
+    #       end
+    #     end
+    #   end
+    #
+    # If you are using the placeholder_string_matchers plugin, note
+    # that both of these methods only work with plain strings, not
+    # with strings with embedded colons for capturing.  Matching will work
+    # correctly in such cases, but the captures will not be yielded to the
+    # match blocks.
+    module OptimizedStringMatchers
+      module RequestMethods
+        # Optimized version of +on+ that only supports a single string.
+        def on_branch(s)
+          always{yield} if _match_string(s)
+        end
+
+        # Optimized version of +is+ that only supports a single string.
+        def is_exactly(s)
+          rp = @remaining_path
+          if _match_string(s)
+            if @remaining_path.empty?
+              always{yield}
+            else
+              @remaining_path = rp
+            end
+          end
+        end
+      end
+    end
+
+    register_plugin(:optimized_string_matchers, OptimizedStringMatchers)
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The padrino_render plugin adds rendering support that is
+    # similar to Padrino's.  While not everything Padrino's
+    # rendering supports is supported by this plugin, it
+    # currently handles enough to be a drop in replacement for
+    # some applications.
+    # 
+    #   plugin :padrino_render, views: 'path/2/views'
+    # 
+    # Most notably, this makes the +render+ method default to
+    # using the layout, similar to how the +view+ method works
+    # in the render plugin.  If you want to call render and not
+    # use a layout, you can use the <tt>layout: false</tt>
+    # option:
+    #
+    #   render('test')                 # layout
+    #   render('test', layout: false)  # no layout
+    #
+    # Note that this plugin loads the :partials plugin.
+    module PadrinoRender
+      # Depend on the render plugin, since this overrides
+      # some of its methods.
+      def self.load_dependencies(app, opts=OPTS)
+        app.plugin :partials, opts
+      end
+
+      module InstanceMethods
+        # Call view with the given arguments, so that render
+        # uses a layout by default.
+        def render(template, opts=OPTS)
+          view(template, opts)
+        end
+      end
+    end
+
+    register_plugin(:padrino_render, PadrinoRender)
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The param_matchers plugin adds hash matchers that operate
+    # on the request's params.
+    #
+    # It adds a :param matcher for matching on any param with the
+    # same name, yielding the value of the param:
+    #
+    #   r.on param: 'foo' do |foo|
+    #     # Matches '?foo=bar', '?foo='
+    #     # Doesn't match '?bar=foo'
+    #   end
+    #
+    # It adds a :param! matcher for matching on any non-empty param
+    # with the same name, yielding the value of the param:
+    #
+    #   r.on(param!: 'foo') do |foo|
+    #     # Matches '?foo=bar'
+    #     # Doesn't match '?foo=', '?bar=foo'
+    #   end
+    #
+    # It also adds :params and :params! matchers, for matching multiple
+    # params at the same time:
+    #
+    #   r.on params: ['foo', 'baz'] do |foo, baz|
+    #     # Matches '?foo=bar&baz=quuz', '?foo=&baz='
+    #     # Doesn't match '?foo=bar', '?baz='
+    #   end
+    #
+    #   r.on params!: ['foo', 'baz'] do |foo, baz|
+    #     # Matches '?foo=bar&baz=quuz'
+    #     # Doesn't match '?foo=bar', '?baz=', '?foo=&baz=', '?foo=bar&baz='
+    #   end
+    #
+    # Because users have some control over the types of submitted parameters,
+    # it is recommended that you explicitly force the correct type for values
+    # yielded by the block:
+    #
+    #   r.get(:param=>'foo') do |foo|
+    #     foo = foo.to_s
+    #   end
+    module ParamMatchers
+      module RequestMethods
+        # Match the given parameter if present, even if the parameter is empty.
+        # Adds match to the captures.
+        def match_param(key)
+          if v = params[key.to_s]
+            @captures << v
+          end
+        end
+
+        # Match the given parameter if present and not empty.
+        # Adds match to the captures.
+        def match_param!(key)
+          if (v = params[key.to_s]) && !v.empty?
+            @captures << v
+          end
+        end
+
+        # Match all given parameters if present, even if any/all parameters is empty.
+        # Adds all matches to the captures.
+        def match_params(keys)
+          keys.each do |key|
+            return false unless match_param(key)
+          end
+        end
+
+        # Match all given parameters if present and not empty.
+        # Adds all matches to the captures.
+        def match_params!(keys)
+          keys.each do |key|
+            return false unless match_param!(key)
+          end
+        end
+      end
+    end
+
+    register_plugin(:param_matchers, ParamMatchers)
+  end
+end

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

@@ -0,0 +1,118 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The params_capturing plugin makes symbol matchers
+    # update the request params with the value of the captured segments,
+    # using the matcher as the key:
+    #
+    #   plugin :params_capturing
+    #
+    #   route do |r|
+    #     # GET /foo/123/abc/67
+    #     r.on("foo", :bar, :baz, :quux) do
+    #       r.params['bar'] #=> '123'
+    #       r.params['baz'] #=> 'abc'
+    #       r.params['quux'] #=> '67'
+    #     end
+    #   end
+    #
+    # Note that this updating of the request params using the matcher as
+    # the key is only done if all arguments to the matcher are symbols
+    # or strings.
+    #
+    # All matchers will update the request params by adding all
+    # captured segments to the +captures+ key:
+    #
+    #   r.on(:x, /(\d+)\/(\w+)/, :y) do
+    #     r.params['x'] #=> nil
+    #     r.params['y'] #=> nil
+    #     r.params['captures'] #=> ["foo", "123", "abc", "67"]
+    #   end
+    #
+    # Note that the request params +captures+ entry will be appended to with
+    # each nested match:
+    #
+    #   r.on(:w) do
+    #     r.on(:x) do
+    #       r.on(:y) do
+    #         r.on(:z) do
+    #           r.params['captures'] # => ["foo", "123", "abc", "67"]
+    #         end
+    #       end
+    #     end
+    #   end
+    #
+    # Note that any existing params captures entry will be overwritten
+    # by this plugin.  You can use +r.GET+ or +r.POST+ to get the underlying
+    # entry, depending on how it was submitted.
+    #
+    # This plugin will also handle string matchers with placeholders if
+    # the placeholder_string_matchers plugin is loaded before this plugin.
+    #
+    # Also note that this plugin will not work correctly if you are using
+    # the symbol_matchers plugin with custom symbol matching and are using
+    # symbols that capture multiple values or no values.
+    module ParamsCapturing
+      REQUEST_INSTANCE_VARIABLES = [:@_params_captures].freeze
+
+      module RequestMethods
+        # Lazily initialize captures entry when params is called.
+        def params
+          ret = super
+          ret['captures'] ||= []
+          ret
+        end
+
+        private
+
+        # Add the capture names from this string to list of param
+        # capture names if param capturing.
+        def _match_string(str)
+          cap_len = @captures.length
+
+          if (ret = super) && (pc = @_params_captures) && (cap_len != @captures.length)
+            # Handle use with placeholder_string_matchers plugin
+            pc.concat(str.scan(/(?<=:)\w+/))
+          end
+
+          ret
+        end
+
+        # Add the symbol to the list of param capture names if param capturing.
+        def _match_symbol(sym)
+          if pc = @_params_captures
+            pc << sym.to_s
+          end
+          super
+        end
+
+        # If all arguments are strings or symbols, turn on param capturing during
+        # the matching, but turn it back off before yielding to the block.  Add
+        # any captures to the params based on the param capture names added by
+        # the matchers.
+        def if_match(args)
+          params = self.params
+
+          if args.all?{|x| x.is_a?(String) || x.is_a?(Symbol)}
+            pc = @_params_captures = []
+          end
+
+          super do |*a|
+            if pc
+              @_params_captures = nil
+              pc.zip(a).each do |k,v|
+                params[k] = v
+              end
+            end
+            params['captures'].concat(a) 
+            yield(*a)
+          end
+        end
+      end
+    end
+
+    register_plugin(:params_capturing, ParamsCapturing)
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The part plugin adds a part method, which is a
+    # render-like method that treats all keywords as locals.
+    #
+    #   # Can replace this:
+    #   render(:template, locals: {foo: 'bar'})
+    #
+    #   # With this:
+    #   part(:template, foo: 'bar')
+    #
+    # On Ruby 2.7+, the part method takes a keyword splat, so you
+    # must pass keywords and not a positional hash for the locals.
+    #
+    # If you are using the :assume_fixed_locals render plugin option,
+    # template caching is enabled, you are using Ruby 3+, and you
+    # are freezing your Roda application, in addition to providing a
+    # simpler API, this also provides a significant performance
+    # improvement (more significant on Ruby 3.4+).
+    module Part
+      def self.load_dependencies(app)
+        app.plugin :render
+      end
+
+      module ClassMethods
+        # When freezing, optimize the part method if assuming fixed locals
+        # and caching templates.
+        def freeze
+          if render_opts[:assume_fixed_locals] && !render_opts[:check_template_mtime]
+            include AssumeFixedLocalsInstanceMethods
+          end
+
+          super
+        end
+      end
+
+      module InstanceMethods
+        if RUBY_VERSION >= '2.7'
+          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def part(template, **locals, &block)
+              render(template, :locals=>locals, &block)
+            end
+          RUBY
+        # :nocov:
+        else
+          def part(template, locals=OPTS, &block)
+            render(template, :locals=>locals, &block)
+          end
+        end
+        # :nocov:
+      end
+
+      module AssumeFixedLocalsInstanceMethods
+        # :nocov:
+        if RUBY_VERSION >= '3.0'
+        # :nocov:
+          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def part(template, ...)
+              if optimized_method = _optimized_render_method_for_locals(template, OPTS)
+                send(optimized_method[0], ...)
+              else
+                super
+              end
+            end
+          RUBY
+        end
+      end
+    end
+
+    register_plugin(:part, Part)
+  end
+end
+

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

@@ -0,0 +1,74 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The partials plugin adds a +partial+ method, which renders 
+    # templates without the layout.
+    # 
+    #   plugin :partials, views: 'path/2/views'
+    # 
+    # Template files are prefixed with an underscore:
+    #
+    #   partial('test')     # uses _test.erb
+    #   partial('dir/test') # uses dir/_test.erb
+    #
+    # This is basically equivalent to:
+    #
+    #   render('_test')
+    #   render('dir/_test')
+    #
+    # To render the same template once for each object in an enumerable,
+    # you can use the +render_partials+ method:
+    #
+    #   each_partial([1,2,3], :foo) # uses _foo.erb
+    #
+    # This is basically equivalent to:
+    #
+    #   render_each([1,2,3], "_foo", local: :foo)
+    #
+    # This plugin depends on the render and render_each plugins.
+    module Partials
+      # Depend on the render plugin, passing received options to it.
+      # Also depend on the render_each plugin.
+      def self.load_dependencies(app, opts=OPTS)
+        app.plugin :render, opts
+        app.plugin :render_each
+      end
+
+      module InstanceMethods
+        # For each object in the given enumerable, render the given
+        # template (prefixing the template filename with an underscore).
+        def each_partial(enum, template, opts=OPTS)
+          unless opts.has_key?(:local)
+            opts = Hash[opts]
+            opts[:local] = render_each_default_local(template)
+          end
+          render_each(enum, partial_template_name(template.to_s), opts)
+        end
+
+        # Renders the given template without a layout, but
+        # prefixes the template filename to use with an 
+        # underscore.
+        def partial(template, opts=OPTS)
+          opts = parse_template_opts(template, opts)
+          if opts[:template]
+            opts[:template] = partial_template_name(opts[:template])
+          end
+          render_template(opts)
+        end
+
+        private
+
+        # Prefix the template base filename with an underscore.
+        def partial_template_name(template)
+          segments = template.split('/')
+          segments[-1] = "_#{segments[-1]}"
+          segments.join('/')
+        end
+      end
+    end
+
+    register_plugin(:partials, Partials)
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The pass plugin adds a request +pass+ method to skip the current match
+    # block as if it did not match.
+    #
+    #   plugin :pass
+    #
+    #   route do |r|
+    #     r.on "foo", :bar do |bar|
+    #       r.pass if bar == 'baz'
+    #       "/foo/#{bar} (not baz)"
+    #     end
+    #
+    #     r.on "foo/baz" do
+    #       "/foo/baz"
+    #     end
+    #   end
+    module Pass
+      module RequestMethods
+        # Skip the current match block as if it did not match.
+        def pass
+          throw :pass
+        end
+
+        private
+
+        # Handle passing inside the match block.
+        def always
+          catch(:pass){super}
+        end
+
+        # Handle passing inside the match block.
+        def if_match(_)
+          rp = @remaining_path
+          ret = catch(:pass){super}
+          @remaining_path = rp
+          ret
+        end
+      end
+    end
+
+    register_plugin(:pass, Pass)
+  end
+end