ultra-lite-hub 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fbbe1c7f2a3c43738c8c98358cc1ec12d792d3eef166171033f72c9404e5ae13
+  data.tar.gz: bb3d4c405cc6934a3f226af3bf21922b5d9ed39b33df4560cadc00eac183f0d9
+SHA512:
+  metadata.gz: a4ee47127536f906c9ac92d330a60201444777884dd3055a798828994f4136911f6d0fd6b3c0d33fd4f62e066234d66e4cfaef9ab4101527a3571a4f2a858a7a
+  data.tar.gz: 9e85f412c5e1681ae67b2b26469525752b2fe4548abd8f53e7151bd18491ee150eae77b4812165b8ac6e9a680aed05abec3c2e43906ced905bb1e36f50b833fd

data/roda-3.105.0/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2014-2026 Jeremy Evans and contributors
+Copyright (c) 2010-2014 Michel Martens, Damian Janowski and Cyril David
+Copyright (c) 2008-2009 Christian Neukirchen
+
+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.

data/roda-3.105.0/lib/roda/cache.rb

@@ -0,0 +1,42 @@
+# frozen-string-literal: true
+
+require "thread"
+
+class Roda
+  # A thread safe cache class, offering only #[] and #[]= methods,
+  # each protected by a mutex.
+  class RodaCache
+    # Create a new thread safe cache.
+    def initialize
+      @mutex = Mutex.new
+      @hash = {}
+    end
+
+    # Make getting value from underlying hash thread safe.
+    def [](key)
+      @mutex.synchronize{@hash[key]}
+    end
+
+    # Make setting value in underlying hash thread safe.
+    def []=(key, value)
+      @mutex.synchronize{@hash[key] = value}
+    end
+
+    # Return the frozen internal hash.  The internal hash can then
+    # be accessed directly since it is frozen and there are no
+    # thread safety issues.
+    def freeze
+      @hash.freeze
+    end
+
+    private
+
+    # Create a copy of the cache with a separate mutex.
+    def initialize_copy(other)
+      @mutex = Mutex.new
+      other.instance_variable_get(:@mutex).synchronize do
+        @hash = other.instance_variable_get(:@hash).dup
+      end
+    end
+  end
+end

data/roda-3.105.0/lib/roda/plugins/Integer_matcher_max.rb

@@ -0,0 +1,55 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The Integer_matcher_max plugin sets the maximum integer value
+    # value that the Integer class matcher will match by default.
+    # By default, loading this plugin sets the maximum value to
+    # 2**63-1, the largest signed 64-bit integer value:
+    #
+    #   plugin :Integer_matcher_max
+    #   route do |r|
+    #     r.is Integer do
+    #       # Matches /9223372036854775807
+    #       # Does not match /9223372036854775808
+    #     end
+    #   end
+    #
+    # To specify a different maximum value, you can pass a different
+    # maximum value when loading the plugin:
+    # 
+    #   plugin :Integer_matcher_max, 2**64-1
+    module IntegerMatcherMax
+      def self.configure(app, max=nil)
+        if max
+          app.class_eval do
+            meth = :_max_value_convert_class_Integer
+            define_method(meth){max}
+            alias_method meth, meth
+            private meth
+          end
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # Do not have the Integer matcher max when over the maximum
+        # configured Integer value.
+        def _convert_class_Integer(value)
+          value = super
+          value if value <= _max_value_convert_class_Integer
+        end
+
+        # Use 2**63-1 as the default maximum value for the Integer
+        # matcher.
+        def _max_value_convert_class_Integer
+          9223372036854775807
+        end
+      end
+    end
+
+    register_plugin(:Integer_matcher_max, IntegerMatcherMax)
+  end
+end

data/roda-3.105.0/lib/roda/plugins/_after_hook.rb

@@ -0,0 +1,11 @@
+# frozen-string-literal: true
+
+require_relative 'error_handler'
+
+#
+class Roda
+  module RodaPlugins
+    # RODA4: Remove
+    register_plugin(:_after_hook, ErrorHandler)
+  end
+end

data/roda-3.105.0/lib/roda/plugins/_base64.rb

@@ -0,0 +1,34 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    module Base64_
+      class << self
+        if RUBY_VERSION >= '2.4'
+          def decode64(str)
+            str.unpack1("m0")
+          end
+        # :nocov:
+        else
+          def decode64(str)
+            str.unpack("m0")[0]
+          end
+        # :nocov:
+        end
+
+        def urlsafe_encode64(bin)
+          str = [bin].pack("m0")
+          str.tr!("+/", "-_")
+          str
+        end
+
+        def urlsafe_decode64(str)
+          decode64(str.tr("-_", "+/"))
+        end
+      end
+    end
+
+    register_plugin(:_base64, Base64_)
+  end
+end

data/roda-3.105.0/lib/roda/plugins/_before_hook.rb

@@ -0,0 +1,41 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # Internal before hook module, not for external use.
+    # Allows for plugins to configure the order in which
+    # before processing is done by using _roda_before_*
+    # private instance methods that are called in sorted order.
+    # Loaded automatically by the base library if any _roda_before_*
+    # methods are defined.
+    module BeforeHook # :nodoc:
+      module InstanceMethods
+        # Run internal before hooks - Old Dispatch API.
+        def call(&block)
+          # RODA4: Remove
+          super do
+            _roda_before
+            instance_exec(@_request, &block) # call Fallback
+          end
+        end
+
+        # Run internal before hooks before running the main
+        # roda route.
+        def _roda_run_main_route(r)
+          _roda_before
+          super
+        end
+
+        private
+
+        # Default empty implementation of _roda_before, usually
+        # overridden by Roda.def_roda_before.
+        def _roda_before
+        end
+      end
+    end
+
+    register_plugin(:_before_hook, BeforeHook)
+  end
+end

data/roda-3.105.0/lib/roda/plugins/_optimized_matching.rb

@@ -0,0 +1,227 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The _optimized_matching plugin is automatically used internally to speed
+    # up matching when a single argument String instance, String class, Integer
+    # class, or Regexp matcher is passed to +r.on+, +r.is_+, or a verb method
+    # such as +r.get+ or +r.post+.
+    # 
+    # The optimization works by avoiding the +if_match+ method if possible.
+    # Instead of clearing the captures array on every call, and having the
+    # matching append to the captures, it checks directly for the match,
+    # and on succesful match, it yields directly to the block without using
+    # the captures array.
+    module OptimizedMatching 
+      TERM = Base::RequestMethods::TERM
+
+      module RequestMethods
+        # Optimize the r.is method handling of a single string, String, Integer,
+        # regexp, or true, argument.
+        def is(*args, &block)
+          case args.length
+          when 1
+            _is1(args, &block)
+          when 0
+            always(&block) if @remaining_path.empty?
+          else
+            if_match(args << TERM, &block)
+          end
+        end
+
+        # Optimize the r.on method handling of a single string, String, Integer,
+        # or regexp argument.  Inline the related matching code to avoid the
+        # need to modify @captures.
+        def on(*args, &block)
+          case args.length
+          when 1
+            case matcher = args[0]
+            when String
+              always{yield} if _match_string(matcher)
+            when Class
+              if matcher == String
+                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
+              elsif matcher == Integer
+                rp = @remaining_path
+                if /\A\/(\d{1,100})(?=\/|\z)/.match?(rp)
+                  if last = rp.index('/', 1)
+                    value = rp[1, last-1]
+                    rp = rp[last, rp.length]
+                  else
+                    value = rp[1, rp.length]
+                    rp = ""
+                  end
+
+                  if value = scope.send(:_convert_class_Integer, value)
+                    @remaining_path = rp
+                    always{yield(value)}
+                  end
+                end
+              else
+                path = @remaining_path
+                captures = @captures.clear
+                meth = :"_match_class_#{matcher}"
+                if respond_to?(meth, true)
+                  # Allow calling private methods, as match methods are generally private
+                  if send(meth, &block)
+                    block_result(yield(*captures))
+                    throw :halt, response.finish
+                  else
+                    @remaining_path = path
+                    false
+                  end
+                else
+                  unsupported_matcher(matcher)
+                end
+              end
+            when Regexp
+              if matchdata = self.class.cached_matcher(matcher){matcher}.match(@remaining_path)
+                @remaining_path = matchdata.post_match
+                always{yield(*matchdata.captures)}
+              end
+            when true
+              always(&block)
+            when false, nil
+              # nothing
+            else
+              path = @remaining_path
+              captures = @captures.clear
+
+              matched = case matcher
+              when Array
+                _match_array(matcher)
+              when Hash
+                _match_hash(matcher)
+              when Symbol
+                _match_symbol(matcher)
+              when Proc
+                matcher.call
+              else
+                unsupported_matcher(matcher)
+              end
+
+              if matched
+                block_result(yield(*captures))
+                throw :halt, response.finish
+              else
+                @remaining_path = path
+                false
+              end
+            end
+          when 0
+            always(&block)
+          else
+            if_match(args, &block)
+          end
+        end
+
+        private
+
+        # Optimize the r.get/r.post method handling of a single string, String, Integer,
+        # regexp, or true, argument.
+        def _verb(args, &block)
+          case args.length
+          when 0
+            always(&block)
+          when 1
+            _is1(args, &block)
+          else
+            if_match(args << TERM, &block)
+          end
+        end
+
+        # Internals of r.is/r.get/r.post optimization.  Inline the related matching
+        # code to avoid the need to modify @captures.
+        def _is1(args, &block)
+          case matcher = args[0]
+          when String
+            rp = @remaining_path
+            if _match_string(matcher)
+              if @remaining_path.empty?
+                always{yield}
+              else
+                @remaining_path = rp
+                nil
+              end
+            end
+          when Class
+            if matcher == String
+              rp = @remaining_path
+              if rp.getbyte(0) == 47 && !rp.index('/', 1) && (len = rp.length) > 1
+                @remaining_path = ''
+                always{yield rp[1, len]}
+              end
+            elsif matcher == Integer
+                rp = @remaining_path
+                if /\A\/(\d{1,100})\z/.match?(rp) && (value = scope.send(:_convert_class_Integer, rp[1, 101])) 
+                  @remaining_path = ''
+                  always{yield(value)}
+                end
+            else
+              path = @remaining_path
+              captures = @captures.clear
+              meth = :"_match_class_#{matcher}"
+              if respond_to?(meth, true)
+                # Allow calling private methods, as match methods are generally private
+                if send(meth, &block) && @remaining_path.empty?
+                  block_result(yield(*captures))
+                  throw :halt, response.finish
+                else
+                  @remaining_path = path
+                  false
+                end
+              else
+                unsupported_matcher(matcher)
+              end
+            end
+          when Regexp
+            if (matchdata = self.class.cached_matcher(matcher){matcher}.match(@remaining_path)) && matchdata.post_match.empty?
+              @remaining_path = ''
+              always{yield(*matchdata.captures)}
+            end
+          when true
+            always(&block) if @remaining_path.empty?
+          when false, nil
+            # nothing
+          else
+            path = @remaining_path
+            captures = @captures.clear
+
+            matched = case matcher
+            when Array
+              _match_array(matcher)
+            when Hash
+              _match_hash(matcher)
+            when Symbol
+              _match_symbol(matcher)
+            when Proc
+              matcher.call
+            else
+              unsupported_matcher(matcher)
+            end
+
+            if matched && @remaining_path.empty?
+              block_result(yield(*captures))
+              throw :halt, response.finish
+            else
+              @remaining_path = path
+              false
+            end
+          end
+        end
+      end
+    end
+
+    register_plugin(:_optimized_matching, OptimizedMatching)
+  end
+end

data/roda-3.105.0/lib/roda/plugins/_symbol_class_matchers.rb

@@ -0,0 +1,108 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    module SymbolClassMatchers_
+      module ClassMethods
+        private
+
+        # Backend of symbol_matcher and class_matcher.
+        def _symbol_class_matcher(expected_class, obj, matcher, block, options=OPTS, &request_class_block)
+          unless obj.is_a?(expected_class)
+            raise RodaError, "Invalid type passed to class_matcher or symbol_matcher: #{matcher.inspect}"
+          end
+
+          if obj.is_a?(Symbol)
+            type = "symbol"
+            meth = :"match_symbol_#{obj}"
+          else
+            type = "class"
+            meth = :"_match_class_#{obj}"
+          end
+
+          case matcher
+          when Regexp
+            regexp = matcher
+            consume_regexp = self::RodaRequest.send(:consume_pattern, regexp)
+          when Symbol
+            unless opts[:symbol_matchers]
+              raise RodaError, "cannot provide Symbol matcher to class_matcher unless using symbol_matchers plugin: #{matcher.inspect}"
+            end
+
+            regexp, consume_regexp, convert_meth, consume_meth = opts[:symbol_matchers][matcher]
+
+            unless regexp
+              raise RodaError, "unregistered symbol matcher given to #{type}_matcher: #{matcher.inspect}"
+            end
+
+            block = _merge_matcher_blocks(type, obj, block, convert_meth)
+          when Class
+            unless opts[:class_matchers]
+              raise RodaError, "cannot provide Class matcher to symbol_matcher unless using class_matchers plugin: #{matcher.inspect}"
+            end
+
+            regexp, consume_regexp, convert_meth, consume_meth = opts[:class_matchers][matcher]
+            unless regexp
+              raise RodaError, "unregistered class matcher given to #{type}_matcher: #{matcher.inspect}"
+            end
+            block = _merge_matcher_blocks(type, obj, block, convert_meth)
+          else
+            raise RodaError, "unsupported matcher given to #{type}_matcher: #{matcher.inspect}"
+          end
+
+          if block.is_a?(Symbol)
+            convert_meth = block
+          elsif block
+            convert_meth = :"_convert_#{type}_#{obj}"
+            define_method(convert_meth, &block)
+            private convert_meth
+          end
+
+          consume_meth ||= options[:segment] ? :_consume_single_segment : :consume
+          array = opts[:"#{type}_matchers"][obj] = [regexp, consume_regexp, convert_meth, consume_meth].freeze
+
+          self::RodaRequest.class_eval do
+            class_exec(meth, array, &request_class_block)
+            private meth
+          end
+
+          nil
+        end
+
+        # If both block and convert_meth are given, 
+        # define a method for block, and then return a
+        # proc that calls convert_meth first, and only calls
+        # the newly defined method with the return values of convert_meth
+        # if matcher_method returns a truthy value.
+        # Otherwise, return convert_meth or block.
+        def _merge_matcher_blocks(type, obj, block, convert_meth)
+          if convert_meth
+            if block
+              convert_merge_meth = :"_convert_merge_#{type}_#{obj}"
+              define_method(convert_merge_meth, &block)
+              private convert_merge_meth
+
+              proc do |*a|
+                if captures = send(convert_meth, *a)
+                  if captures.is_a?(Array)
+                    send(convert_merge_meth, *captures)
+                  else
+                    send(convert_merge_meth, captures)
+                  end
+                end
+              end
+            else
+              convert_meth
+            end
+          else
+            block
+          end
+        end
+      end
+    end
+
+    register_plugin(:_symbol_class_matchers, SymbolClassMatchers_)
+  end
+end
+

data/roda-3.105.0/lib/roda/plugins/_symbol_regexp_matchers.rb

@@ -0,0 +1,24 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The _symbol_regexp_matchers plugin is designed for internal use by other plugins,
+    # for the historical behavior of a symbol matching an arbitrary segment by default
+    # using a regexp.
+    module SymbolRegexpMatchers
+      module RequestMethods
+        private
+
+        # The regular expression to use for matching symbols.  By default, any non-empty
+        # segment matches.
+        def _match_symbol_regexp(s)
+          "([^\\/]+)"
+        end
+      end
+    end
+
+    register_plugin(:_symbol_regexp_matchers, SymbolRegexpMatchers)
+  end
+end
+

data/roda-3.105.0/lib/roda/plugins/additional_render_engines.rb

@@ -0,0 +1,61 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The additional_render_engines plugin allows for specifying additional render
+    # engines to consider for templates.  When rendering a template, it will
+    # first try the default template engine specified in the render plugin.  If the
+    # template file to be rendered does not exist, it will try each additional render
+    # engine specified in this plugin, in order, using the path to the first
+    # template file that exists in the file system.  If no such path is found, it
+    # uses the default path specified by the render plugin.
+    #
+    # Example:
+    #
+    #   plugin :render # default engine is 'erb'
+    #   plugin :additional_render_engines, ['haml', 'str']
+    #
+    #   route do |r|
+    #     # Will check the following in order, using path for first
+    #     # template file that exists:
+    #     # * views/t.erb
+    #     # * views/t.haml
+    #     # * views/t.str
+    #     render :t
+    #   end
+    module AdditionalRenderEngines
+      def self.load_dependencies(app, render_engines)
+        app.plugin :render
+      end
+
+      # Set the additional render engines to consider.
+      def self.configure(app, render_engines)
+        app.opts[:additional_render_engines] = render_engines.dup.freeze
+      end
+
+      module InstanceMethods
+        private
+
+        # If the template path does not exist, try looking for the template
+        # using each of the render engines, in order, returning
+        # the first path that exists. If no template path exists for the
+        # default any or any additional engines, return the original path.
+        def template_path(opts)
+          orig_path = super
+
+          unless File.file?(orig_path)
+            self.opts[:additional_render_engines].each do |engine|
+              path = super(opts.merge(:engine=>engine))
+              return path if File.file?(path)
+            end
+          end
+
+          orig_path
+        end
+      end
+    end
+
+    register_plugin(:additional_render_engines, AdditionalRenderEngines)
+  end
+end