ultra-lite-hub 0.0.1

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

@@ -0,0 +1,89 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The custom_matchers plugin supports using arbitrary objects
+    # as matchers, as long as the application has been configured
+    # to accept such objects.
+    #
+    # After loading the plugin, support for custom matchers can be
+    # configured using the +custom_matcher+ class method.  This
+    # method is generally passed the class of the object you want
+    # to use as a custom matcher, as well as a block.  The block
+    # will be called in the context of the request instance
+    # with the specific matcher used in the match method.
+    #
+    # Blocks can append to the captures in order to yield the appropriate
+    # values to match blocks, or call request methods that append to the
+    # captures.
+    #
+    # Example:
+    #
+    #   plugin :custom_matchers
+    #   method_segment = Struct.new(:request_method, :next_segment)
+    #   custom_matcher(method_segment) do |matcher|
+    #     # self is the request instance ("r" yielded in the route block below)
+    #     if matcher.request_method == self.request_method
+    #       match(matcher.next_segment)
+    #     end
+    #   end
+    #
+    #   get_foo = method_segment.new('GET', 'foo') 
+    #   post_any = method_segment.new('POST', String) 
+    #   route do |r|
+    #     r.on('baz') do
+    #       r.on(get_foo) do
+    #         # GET method, /baz/foo prefix
+    #       end
+    #
+    #       r.is(post_any) do |seg|
+    #         # for POST /baz/bar, seg is "bar"
+    #       end
+    #     end
+    #
+    #     r.on('quux') do
+    #       r.is(get_foo) do
+    #         # GET method, /quux/foo route
+    #       end
+    #
+    #       r.on(post_any) do |seg|
+    #         # for POST /quux/xyz, seg is "xyz"
+    #       end
+    #     end
+    #   end
+    module CustomMatchers
+      def self.configure(app)
+        app.opts[:custom_matchers] ||= OPTS
+      end
+
+      module ClassMethods
+        def custom_matcher(match_class, &block)
+          custom_matchers = Hash[opts[:custom_matchers]]
+          meth = custom_matchers[match_class] = custom_matchers[match_class] || :"_custom_matcher_#{match_class}"
+          opts[:custom_matchers] = custom_matchers.freeze
+          self::RodaRequest.send(:define_method, meth, &block)
+          nil
+        end
+      end
+
+      module RequestMethods
+        private
+
+        # Try custom matchers before calling super
+        def unsupported_matcher(matcher)
+          roda_class.opts[:custom_matchers].each do |match_class, meth|
+            if match_class === matcher
+              return send(meth, matcher)
+            end
+          end
+
+          super
+        end
+      end
+    end
+
+    register_plugin(:custom_matchers, CustomMatchers)
+  end
+end
+

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

@@ -0,0 +1,64 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The default_headers plugin accepts a hash of headers,
+    # and overrides the default_headers method in the
+    # response class to be a copy of the headers.
+    #
+    # Note that when using this module, you should not
+    # attempt to mutate of the values set in the default
+    # headers hash.
+    #
+    # Example:
+    #
+    #   plugin :default_headers, 'Content-Type'=>'text/csv'
+    #
+    # You can modify the default headers later by loading the
+    # plugin again:
+    #
+    #   plugin :default_headers, 'Foo'=>'bar'
+    #   plugin :default_headers, 'Bar'=>'baz'
+    module DefaultHeaders
+      # Merge the given headers into the existing default headers, if any.
+      def self.configure(app, headers={})
+        app.opts[:default_headers] = (app.default_headers || app::RodaResponse::DEFAULT_HEADERS).merge(headers).freeze
+      end 
+
+      module ClassMethods
+        # The default response headers to use for the current class.
+        def default_headers
+          opts[:default_headers]
+        end
+
+        # Optimize the response class set_default_headers method if it hasn't been
+        # overridden and all default headers are strings.
+        def freeze
+          if (headers = opts[:default_headers]).all?{|k, v| k.is_a?(String) && v.is_a?(String)} &&
+             (self::RodaResponse.instance_method(:set_default_headers).owner == Base::ResponseMethods)
+            self::RodaResponse.class_eval(<<-END, __FILE__, __LINE__+1)
+              private
+
+              def set_default_headers
+                h = @headers
+                #{headers.map{|k,v| "h[#{k.inspect}] ||= #{v.inspect}"}.join('; ')}
+              end
+            END
+          end
+
+          super
+        end
+      end
+
+      module ResponseMethods
+        # Get the default headers from the related roda class.
+        def default_headers
+          roda_class.default_headers
+        end
+      end
+    end
+
+    register_plugin(:default_headers, DefaultHeaders)
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The default_status plugin accepts a block which should
+    # return a response status integer. This integer will be used as
+    # the default response status (usually 200) if the body has been
+    # written to, and you have not explicitly set a response status.
+    #
+    # Example:
+    #
+    #   # Use 201 default response status for all requests
+    #   plugin :default_status do
+    #     201
+    #   end
+    module DefaultStatus
+      def self.configure(app, &block)
+        raise RodaError, "default_status plugin requires a block" unless block
+        if check_arity = app.opts.fetch(:check_arity, true)
+          unless block.arity == 0
+            if check_arity == :warn
+              RodaPlugins.warn "Arity mismatch in block passed to plugin :default_status. Expected Arity 0, but arguments required for #{block.inspect}"
+            end
+            b = block
+            block = lambda{instance_exec(&b)} # Fallback
+          end
+        end
+        app::RodaResponse.send(:define_method, :default_status, &block)
+      end
+    end
+
+    register_plugin(:default_status, DefaultStatus)
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    module DelayBuild
+      module ClassMethods
+        # No-op for backwards compatibility
+        def build!
+        end
+      end
+    end
+
+    # RODA4: Remove plugin
+    # Only available for backwards compatibility, no longer needed
+    register_plugin(:delay_build, DelayBuild)
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The delegate plugin allows you to easily setup instance methods in
+    # the scope of the route block that call methods on the related
+    # request, response, or class which may offer a simpler API in some cases.
+    # Roda doesn't automatically setup such delegate methods because
+    # it pollutes the application's method namespace, but this plugin
+    # allows the user to do so.
+    #
+    # Here's an example based on the README's initial example, using the
+    # request_delegate method to simplify the DSL:
+    #
+    #   plugin :delegate
+    #   request_delegate :root, :on, :is, :get, :post, :redirect
+    #
+    #   route do |r|
+    #     # GET / request
+    #     root do
+    #       redirect "/hello"
+    #     end
+    #
+    #     # /hello branch
+    #     on "hello" do
+    #       # Set variable for all routes in /hello branch
+    #       @greeting = 'Hello'
+    #
+    #       # GET /hello/world request
+    #       get "world" do
+    #         "#{@greeting} world!"
+    #       end
+    #
+    #       # /hello request
+    #       is do
+    #         # GET /hello request
+    #         get do
+    #           "#{@greeting}!"
+    #         end
+    #
+    #         # POST /hello request
+    #         post do
+    #           puts "Someone said #{@greeting}!"
+    #           redirect
+    #         end
+    #       end
+    #     end
+    #   end
+    module Delegate
+      module ClassMethods
+        # Delegate the given methods to the class
+        def class_delegate(*meths)
+          meths.each do |meth|
+            define_method(meth){|*a, &block| self.class.public_send(meth, *a, &block)}
+          end
+        end
+
+        # Delegate the given methods to the request
+        def request_delegate(*meths)
+          meths.each do |meth|
+            define_method(meth){|*a, &block| @_request.public_send(meth, *a, &block)}
+          end
+        end
+
+        # Delegate the given methods to the response
+        def response_delegate(*meths)
+          meths.each do |meth|
+            define_method(meth){|*a, &block| @_response.public_send(meth, *a, &block)}
+          end
+        end
+      end
+    end
+
+    register_plugin(:delegate, Delegate)
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The delete_empty_headers plugin deletes any headers whose
+    # value is set to the empty string.  Because of how default headers are
+    # set in Roda, if you have a default header but don't want
+    # to set it for a specific request, you need to use this plugin
+    # and set the header value to the empty string, and Roda will automatically
+    # delete the header.
+    module DeleteEmptyHeaders
+      module ResponseMethods
+        # Delete any empty headers when calling finish
+        def finish
+          delete_empty_headers(super)
+        end
+
+        # Delete any empty headers when calling finish_with_body
+        def finish_with_body(_)
+          delete_empty_headers(super)
+        end
+
+        private
+
+        # Delete any empty headers from response
+        def delete_empty_headers(res)
+          res[1].delete_if{|_, v| v.is_a?(String) && v.empty?}
+          res
+        end
+      end
+    end
+
+    register_plugin(:delete_empty_headers, DeleteEmptyHeaders)
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The direct_call plugin makes the call class method skip the middleware stack
+    # (app.call will still call the middleware).
+    # This can be used as an optimization, as the Roda class itself can be used
+    # as the callable, which is faster than using a lambda.
+    module DirectCall
+      def self.configure(app)
+        app.send(:build_rack_app)
+      end
+
+      module ClassMethods
+        # Call the application without middlware.
+        def call(env)
+          new(env)._roda_handle_main_route
+        end
+
+        private
+
+        # If new_api is true, use the receiver as the base rack app for better
+        # performance.
+        def base_rack_app_callable(new_api=true)
+          if new_api
+            self
+          else
+            super
+          end
+        end
+      end
+    end
+
+    register_plugin(:direct_call, DirectCall)
+  end
+end
+

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

@@ -0,0 +1,38 @@
+# frozen-string-literal: true
+
+raise LoadError, "disallow_file_uploads plugin not supported on Rack <1.6" if Rack.release < '1.6'
+
+#
+class Roda
+  module RodaPlugins
+    # The disallow_file_uploads plugin raises a Roda::RodaPlugins::DisallowFileUploads::Error
+    # if there is an attempt to upload a file.  This plugin is useful for applications where
+    # multipart file uploads are not expected and you want to remove the ability for rack
+    # to create temporary files.  Example:
+    #
+    #   plugin :disallow_file_uploads
+    #
+    # This plugin is only supported on Rack 1.6+.  This plugin does not technically
+    # block users from uploading files, it only blocks the parsing of request bodies containing
+    # multipart file uploads.  So if you do not call +r.POST+ (or something that calls it such as
+    # +r.params+), then Roda will not attempt to parse the request body, and an exception will not
+    # be raised.
+    module DisallowFileUploads
+      # Exception class used when a multipart file upload is attempted.
+      class Error < RodaError; end
+
+      NO_TEMPFILE = lambda{|_,_| raise Error, "Support for uploading files has been disabled"}
+
+      module RequestMethods
+        # HTML escape the input and return the escaped version.
+        def initialize(_, env)
+          env['rack.multipart.tempfile_factory'] = NO_TEMPFILE
+          super
+        end
+      end
+    end
+
+    register_plugin(:disallow_file_uploads, DisallowFileUploads)
+  end
+end
+

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

@@ -0,0 +1,43 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The drop_body plugin automatically drops the body and
+    # Content-Type/Content-Length headers from the response if
+    # the response status indicates that the response should
+    # not include a body (response statuses 100, 101, 102, 204,
+    # and 304).  For response status 205, the body and Content-Type
+    # headers are dropped, but the Content-length header is set to
+    # '0' instead of being dropped.
+    module DropBody
+      module ResponseMethods
+        DROP_BODY_STATUSES = [100, 101, 102, 204, 205, 304].freeze
+        RodaPlugins.deprecate_constant(self, :DROP_BODY_STATUSES)
+
+        DROP_BODY_RANGE = 100..199
+        private_constant :DROP_BODY_RANGE
+
+        # If the response status indicates a body should not be
+        # returned, use an empty body and remove the Content-Length
+        # and Content-Type headers.
+        def finish
+          r = super
+          case r[0]
+          when DROP_BODY_RANGE, 204, 304
+            r[2] = EMPTY_ARRAY
+            h = r[1]
+            h.delete(RodaResponseHeaders::CONTENT_LENGTH)
+            h.delete(RodaResponseHeaders::CONTENT_TYPE)
+          when 205
+            r[2] = EMPTY_ARRAY
+            empty_205_headers(r[1])
+          end
+          r
+        end
+      end
+    end
+
+    register_plugin(:drop_body, DropBody)
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The each_part plugin adds an each_part method, which is a
+    # render_each-like method that treats all keywords as locals.
+    #
+    #   # Can replace this:
+    #   render_each(enum, :template, locals: {foo: 'bar'})
+    #
+    #   # With this:
+    #   each_part(enum, :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 performance improvement.
+    module EachPart
+      def self.load_dependencies(app)
+        app.plugin :render_each
+      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 each_part(enum, template, **locals, &block)
+              render_each(enum, template, :locals=>locals, &block)
+            end
+          RUBY
+        # :nocov:
+        else
+          def each_part(enum, template, locals=OPTS, &block)
+            render_each(enum, template, :locals=>locals, &block)
+          end
+        end
+        # :nocov:
+      end
+
+      module AssumeFixedLocalsInstanceMethods
+        # :nocov:
+        if RUBY_VERSION >= '3.0'
+        # :nocov:
+          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def each_part(enum, template, **locals, &block)
+              if optimized_method = _cached_render_each_template_method(template)
+                optimized_method = optimized_method[0]
+                as = render_each_default_local(template)
+                if defined?(yield)
+                  enum.each do |v|
+                    locals[as] = v
+                    yield send(optimized_method, **locals)
+                  end
+                  nil
+                else
+                  enum.map do |v|
+                    locals[as] = v
+                    send(optimized_method, **locals)
+                  end.join
+                end
+              else
+                render_each(enum, template, :locals=>locals, &block)
+              end
+            end
+          RUBY
+        end
+      end
+    end
+
+    register_plugin(:each_part, EachPart)
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The early_hints plugin allows sending 103 Early Hints responses
+    # using the rack.early_hints environment variable.
+    # Early hints allow clients to preload necessary files before receiving
+    # the response.
+    module EarlyHints
+      module InstanceMethods
+        # Send given hash of Early Hints using the rack.early_hints environment variable,
+        # currenly only supported by puma.  hash given should generally have the single
+        # key 'Link', and a string or array of strings for each of the early hints.
+        def send_early_hints(hash)
+          if eh_proc = env['rack.early_hints']
+            eh_proc.call(hash)
+          end
+        end
+      end
+    end
+
+    register_plugin(:early_hints, EarlyHints)
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The empty_root plugin makes +r.root+ match both on +/+ and
+    # on the empty string.  This is mostly useful when using multiple
+    # rack applications, where the initial PATH_INFO has been moved
+    # to SCRIPT_NAME.  For example, if you have the following
+    # applications:
+    #
+    #   class App1 < Roda
+    #     on "albums" do
+    #       run App2
+    #     end
+    #   end
+    #
+    #   class App2 < Roda
+    #     plugin :empty_root
+    #
+    #     route do |r|
+    #       r.root do
+    #         "root"
+    #       end
+    #     end
+    #   end
+    #
+    # Then requests for both +/albums/+ and +/albums+ will return
+    # "root".  Without this plugin loaded into App2, only requests
+    # for +/albums/+ will return "root", since by default, +r.root+
+    # matches only when the current PATH_INFO is +/+ and not when
+    # it is empty.
+    module EmptyRoot
+      module RequestMethods
+        # Match when the remaining path is the empty string,
+        # in addition to the default behavior of matching when
+        # the remaining path is +/+.
+        def root(&block)
+          super
+          if remaining_path.empty? && is_get?
+            always(&block)
+          end
+        end
+      end
+    end
+
+    register_plugin(:empty_root, EmptyRoot)
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The environments plugin adds a environment class accessor to get
+    # the environment for the application, 3 predicate class methods
+    # to check for the current environment (development?, test? and
+    # production?), and a class configure method that takes environment(s)
+    # and yields to the block if the given environment(s) match the
+    # current environment.
+    #
+    # The default environment for the application is based on
+    # <tt>ENV['RACK_ENV']</tt>.
+    #
+    # Example:
+    #
+    #   class Roda
+    #     plugin :environments
+    #
+    #     environment  # => :development
+    #     development? # => true
+    #     test?        # => false
+    #     production?  # => false
+    #
+    #     # Set the environment for the application
+    #     self.environment = :test 
+    #     test?        # => true
+    #
+    #     configure do
+    #       # called, as no environments given
+    #     end
+    #
+    #     configure :development, :production do
+    #       # not called, as no environments match
+    #     end
+    #
+    #     configure :test do
+    #       # called, as environment given matches current environment
+    #     end
+    #   end
+    module Environments
+      # Set the environment to use for the app.  Default to ENV['RACK_ENV']
+      # if no environment is given.  If ENV['RACK_ENV'] is not set and
+      # no environment is given, assume the development environment.
+      def self.configure(app, env=ENV["RACK_ENV"])
+        app.environment = (env || 'development').to_sym
+      end
+
+      module ClassMethods
+        # If no environments are given or one of the given environments
+        # matches the current environment, yield the receiver to the block.
+        def configure(*envs)
+          if envs.empty? || envs.any?{|s| s == environment}
+            yield self
+          end
+        end
+
+        # The current environment for the application, which should be stored
+        # as a symbol.
+        def environment
+          opts[:environment]
+        end
+
+        # Override the environment for the application, instead of using
+        # RACK_ENV.
+        def environment=(v)
+          opts[:environment] = v
+        end
+
+        [:development, :test, :production].each do |env|
+          define_method("#{env}?"){environment == env}
+        end
+      end
+    end
+
+    register_plugin(:environments, Environments)
+  end
+end