ultra-lite-hub 0.0.1

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

@@ -0,0 +1,86 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The status_handler plugin adds a +status_handler+ method which sets a
+    # block that is called whenever a response with the relevant response code
+    # with an empty body would be returned.
+    #
+    # This plugin does not support providing the blocks with the plugin call;
+    # you must provide them to status_handler calls afterwards:
+    #
+    #   plugin :status_handler
+    #
+    #   status_handler(403) do
+    #     "You are forbidden from seeing that!"
+    #   end
+    #
+    #   status_handler(404) do
+    #     "Where did it go?"
+    #   end
+    #
+    #   status_handler(405, keep_headers: ['Accept']) do
+    #     "Use a different method!"
+    #   end
+    #
+    # Before a block is called, any existing headers on the response will be
+    # cleared, unless the +:keep_headers+ option is used.  If the +:keep_headers+
+    # option is used, the value should be an array, and only the headers listed
+    # in the array will be kept.
+    module StatusHandler
+      CLEAR_HEADERS = :clear.to_proc
+      private_constant :CLEAR_HEADERS
+
+      def self.configure(app)
+        app.opts[:status_handler] ||= {}
+      end
+
+      module ClassMethods
+        # Install the given block as a status handler for the given HTTP response code.
+        def status_handler(code, opts=OPTS, &block)
+          # For backwards compatibility, pass request argument if block accepts argument
+          arity = block.arity == 0 ? 0 : 1
+          handle_headers = case keep_headers = opts[:keep_headers]
+          when nil, false
+            CLEAR_HEADERS
+          when Array
+            if Rack.release >= '3'
+              keep_headers = keep_headers.map(&:downcase)
+            end
+            lambda{|headers| headers.delete_if{|k,_| !keep_headers.include?(k)}}
+          else
+            raise RodaError, "Invalid :keep_headers option"
+          end
+
+          meth = define_roda_method(:"_roda_status_handler__#{code}", arity, &block)
+          self.opts[:status_handler][code] = define_roda_method(:"_roda_status_handler_#{code}", 1) do |result|
+            res = @_response
+            res.status = result[0]
+            handle_headers.call(res.headers)
+            result.replace(_roda_handle_route{arity == 1 ? send(meth, @_request) : send(meth)})
+          end
+        end
+
+        # Freeze the hash of status handlers so that there can be no thread safety issues at runtime.
+        def freeze
+          opts[:status_handler].freeze
+          super
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # If routing returns a response we have a handler for, call that handler.
+        def _roda_after_20__status_handler(result)
+          if result && (meth = opts[:status_handler][result[0]]) && (v = result[2]).is_a?(Array) && v.empty?
+            send(meth, result)
+          end
+        end
+      end
+    end
+
+    register_plugin(:status_handler, StatusHandler)
+  end
+end

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

@@ -0,0 +1,170 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The streaming plugin adds support for streaming responses
+    # from roda using the +stream+ method:
+    #
+    #   plugin :streaming
+    #
+    #   route do |r|
+    #     stream do |out|
+    #       ['a', 'b', 'c'].each{|v| out << v; sleep 1}
+    #     end
+    #   end
+    #
+    # In order for streaming to work, any webservers used in
+    # front of the roda app must not buffer responses.
+    #
+    # The stream method takes the following options:
+    #
+    # :callback :: A callback proc to call when the connection is closed.
+    # :loop :: Whether to call the stream block continuously until the connection is closed.
+    # :async :: Whether to call the stream block in a separate thread (default: false). Only supported on Ruby 2.3+.
+    # :queue :: A queue object to use for asynchronous streaming (default: `SizedQueue.new(10)`).
+    #
+    # If the :loop option is used, you can override the
+    # handle_stream_error method to change how exceptions
+    # are handled during streaming. This method is passed the
+    # exception and the stream.  By default, this method
+    # just reraises the exception, but you can choose to output
+    # the an error message to the stream, before raising:
+    #
+    #   def handle_stream_error(e, out)
+    #     out << 'ERROR!'
+    #     raise e
+    #   end
+    #
+    # Ignore errors completely while streaming:
+    #
+    #   def handle_stream_error(e, out)
+    #   end
+    #
+    # or handle the errors in some other way.
+    module Streaming
+      # Class of the response body in case you use #stream.
+      class Stream
+        include Enumerable
+
+        # Handle streaming options, see Streaming for details.
+        def initialize(opts=OPTS, &block)
+          @block = block
+          @out = nil
+          @callback = opts[:callback]
+          @closed = false
+        end
+
+        # Add output to the streaming response body. Returns number of bytes written.
+        def write(data)
+          data = data.to_s
+          @out.call(data)
+          data.bytesize
+        end
+
+        # Add output to the streaming response body. Returns self.
+        def <<(data)
+          write(data)
+          self
+        end
+
+        # If not already closed, close the connection, and call
+        # any callbacks.
+        def close
+          return if closed?
+          @closed = true
+          @callback.call if @callback
+        end
+
+        # Whether the connection has already been closed.
+        def closed?
+          @closed
+        end
+
+        # Yield values to the block as they are passed in via #<<.
+        def each(&out)
+          @out = out
+          @block.call(self)
+        ensure
+          close
+        end
+      end
+
+      # Class of the response body if you use #stream with :async set to true.
+      # Uses a separate thread that pushes streaming results to a queue, so that
+      # data can be streamed to clients while it is being prepared by the application.
+      class AsyncStream
+        include Enumerable
+
+        # Handle streaming options, see Streaming for details.
+        def initialize(opts=OPTS, &block)
+          @stream = Stream.new(opts, &block)
+          @queue = opts[:queue] || SizedQueue.new(10) # have some default backpressure
+          @thread = Thread.new { enqueue_chunks }
+        end
+
+        # Continue streaming data until the stream is finished.
+        def each(&out)
+          dequeue_chunks(&out)
+          @thread.join
+        end
+
+        # Stop streaming.
+        def close
+          @queue.close # terminate the producer thread
+          @stream.close
+        end
+
+        private
+
+        # Push each streaming chunk onto the queue.
+        def enqueue_chunks
+          @stream.each do |chunk|
+            @queue.push(chunk)
+          end
+        rescue ClosedQueueError
+          # connection was closed
+        ensure
+          @queue.close
+        end
+
+        # Pop each streaming chunk from the queue and yield it.
+        def dequeue_chunks
+          while chunk = @queue.pop
+            yield chunk
+          end
+        end
+      end
+
+      module InstanceMethods
+        # Immediately return a streaming response using the current response
+        # status and headers, calling the block to get the streaming response.
+        # See Streaming for details.
+        def stream(opts=OPTS, &block)
+          if opts[:loop]
+            block = proc do |out|
+              until out.closed?
+                begin
+                  yield(out)
+                rescue => e
+                  handle_stream_error(e, out)
+                end
+              end
+            end
+          end
+
+          stream_class = (opts[:async] && RUBY_VERSION >= '2.3') ? AsyncStream : Stream
+
+          throw :halt, @_response.finish_with_body(stream_class.new(opts, &block))
+        end
+
+        # Handle exceptions raised while streaming when using :loop
+        def handle_stream_error(e, out)
+          raise e
+        end
+      end
+    end
+
+    register_plugin(:streaming, Streaming)
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The strip_path_prefix plugin makes Roda strip a given prefix off internal absolute paths,
+    # turning them to relative paths.  Roda by default stores internal paths as absolute paths.
+    # The main reason to use this plugin is when the internal absolute path could change at
+    # runtime, either due to a symlink change or chroot call, or you really want to use
+    # relative paths instead of absolute paths.
+    # 
+    # Examples:
+    #
+    #   plugin :strip_path_prefix # Defaults to Dir.pwd
+    #   plugin :strip_path_prefix, File.dirname(Dir.pwd)
+    module StripPathPrefix
+      # Set the regexp to use when stripping prefixes from internal paths.
+      def self.configure(app, prefix=Dir.pwd)
+        prefix += '/' unless prefix.end_with?("/")
+        app.opts[:strip_path_prefix] = /\A#{Regexp.escape(prefix)}/
+      end
+
+      module ClassMethods
+        # Strip the path prefix from the gien path if it starts with the prefix.
+        def expand_path(path, root=opts[:root])
+          super.sub(opts[:strip_path_prefix], '')
+        end
+      end
+    end
+
+    register_plugin(:strip_path_prefix, StripPathPrefix)
+  end
+end

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

@@ -0,0 +1,188 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The symbol_matchers plugin allows you do define custom regexps to use
+    # for specific symbols.  For example, if you have a route such as:
+    #
+    #   r.on :username do |username|
+    #     # ...
+    #   end
+    #
+    # By default this will match all nonempty segments.  However, if your usernames
+    # must be 6-20 characters, and can only contain +a-z+ and +0-9+, you can do:
+    #
+    #   plugin :symbol_matchers
+    #   symbol_matcher :username, /([a-z0-9]{6,20})/
+    #
+    # Then the route will only if the path is +/foobar123+, but not if it is
+    # +/foo+, +/FooBar123+, or +/foobar_123+.
+    #
+    # You can provide a <tt>segment: true</tt> option to symbol_matcher to speed up
+    # the matching on Ruby 2.4+:
+    #
+    #   symbol_matcher :username, /([a-z0-9]{6,20})/, segment: true
+    #
+    # Use of <tt>segment: true</tt> requires that the regexp not match more than
+    # one segment (i.e. it cannot match +/+). Additionally, the entire segment will
+    # be captured, so any capture groups in the regexp will be ignored.
+    #
+    # By default, this plugin sets up the following symbol matchers:
+    #
+    # :d :: <tt>/(\d+)/</tt>, a decimal segment
+    # :rest :: <tt>/(.*)/</tt>, all remaining characters, if any
+    # :w :: <tt>/(\w+)/</tt>, an alphanumeric segment
+    #
+    # If the placeholder_string_matchers plugin is loaded, this feature also applies to
+    # placeholders in strings, so the following:
+    #
+    #   r.on "users/:username" do |username|
+    #     # ...
+    #   end
+    #
+    # Would match +/users/foobar123+, but not +/users/foo+, +/users/FooBar123+,
+    # or +/users/foobar_123+.
+    #
+    # If using this plugin with the params_capturing plugin, this plugin should
+    # be loaded first.
+    #
+    # You can provide a block when calling +symbol_matcher+, and it will be called
+    # for all matches to allow for type conversion:
+    #
+    #   symbol_matcher(:date, /(\d\d\d\d)-(\d\d)-(\d\d)/) do |y, m, d|
+    #     Date.new(y.to_i, m.to_i, d.to_i)
+    #   end
+    #
+    #   route do |r|
+    #     r.on :date do |date|
+    #       # date is an instance of Date
+    #     end
+    #   end
+    #
+    # If you have a segment match the passed regexp, but decide during block
+    # processing that you do not want to treat it as a match, you can have the
+    # block return nil or false.  This is useful if you want to make sure you
+    # are using valid data:
+    #
+    #   symbol_matcher(:date, /(\d\d\d\d)-(\d\d)-(\d\d)/) do |y, m, d|
+    #     y = y.to_i
+    #     m = m.to_i
+    #     d = d.to_i
+    #     Date.new(y, m, d) if Date.valid_date?(y, m, d)
+    #   end
+    #
+    # You can have the block return an array to yield multiple captures.
+    #
+    # The second argument to symbol_matcher can be a symbol already registered
+    # as a symbol matcher. This can DRY up code that wants a conversion
+    # performed by an existing class matcher or to use the same regexp:
+    #
+    #   symbol_matcher :employee_id, :d do |id|
+    #     id.to_i
+    #   end
+    #   symbol_matcher :employee, :employee_id do |id|
+    #     Employee[id]
+    #   end
+    #
+    # With the above example, the :d matcher matches only decimal strings, but
+    # yields them as string.  The registered :employee_id matcher converts the
+    # decimal string to an integer.  The registered :employee matcher builds
+    # on that and uses the integer to lookup the related employee.  If there is
+    # no employee with that id, then the :employee matcher will not match.
+    #
+    # If using the class_matchers plugin, you can provide a recognized class
+    # matcher as the second argument to symbol_matcher, and it will work in
+    # a similar manner:
+    #
+    #   symbol_matcher :employee, Integer do |id|
+    #     Employee[id]
+    #   end
+    #
+    # Blocks passed to the symbol matchers plugin are evaluated in route
+    # block context.
+    #
+    # If providing a block to the symbol_matchers plugin, the symbol may 
+    # not work with the params_capturing plugin. Note that the use of
+    # symbol matchers inside strings when using the placeholder_string_matchers
+    # plugin only uses the regexp, it does not respect the conversion blocks
+    # registered with the symbols.
+    module SymbolMatchers
+      def self.load_dependencies(app)
+        app.plugin :_symbol_regexp_matchers
+        app.plugin :_symbol_class_matchers
+      end
+
+      def self.configure(app)
+        app.opts[:symbol_matchers] ||= {}
+        app.symbol_matcher(:d, /(\d+)/, segment: true)
+        app.symbol_matcher(:w, /(\w+)/, segment: true)
+        app.symbol_matcher(:rest, /(.*)/)
+      end
+
+      module ClassMethods
+        # Set the matcher and block to use for the given class.
+        # The matcher can be a regexp, registered symbol matcher, or registered class
+        # matcher (if using the class_matchers plugin).
+        #
+        # If providing a regexp, the block given will be called with all regexp captures.
+        # If providing a registered symbol or class, the block will be called with the
+        # captures returned by the block for the registered symbol or class, or the regexp
+        # captures if no block was registered with the symbol or class. In either case,
+        # if a block is given, it should return an array with the captures to yield to
+        # the match block.
+        def symbol_matcher(s, matcher, opts=OPTS, &block)
+          _symbol_class_matcher(Symbol, s, matcher, block, opts) do |meth, array|
+            define_method(meth){array}
+          end
+
+          nil
+        end
+
+        # Freeze the class_matchers hash when freezing the app.
+        def freeze
+          opts[:symbol_matchers].freeze
+          super
+        end
+      end
+
+      module RequestMethods
+        private
+
+        # Use regular expressions to the symbol-specific regular expression
+        # if the symbol is registered.  Otherwise, call super for the default
+        # behavior.
+        def _match_symbol(s)
+          meth = :"match_symbol_#{s}"
+          if respond_to?(meth, true)
+            # Allow calling private match methods
+            _, re, convert_meth, consume_meth = send(meth)
+            if re
+              send(consume_meth, re, convert_meth)
+            else
+              # defined in class_matchers plugin
+              _consume_segment(convert_meth)
+            end
+          else
+            super
+          end
+        end
+
+        # Return the symbol-specific regular expression if one is registered.
+        # Otherwise, call super for the default behavior.
+        def _match_symbol_regexp(s)
+          meth = :"match_symbol_#{s}"
+          if respond_to?(meth, true)
+            # Allow calling private match methods
+            re, = send(meth)
+            re
+          else
+            super
+          end
+        end
+      end
+    end
+
+    register_plugin(:symbol_matchers, SymbolMatchers)
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen-string-literal: true
+
+require 'rack/utils'
+
+class Roda
+  module RodaPlugins
+    # The symbol_status plugin patches the +status=+ response method to
+    # accept the status name as a symbol.  If given an integer value,
+    # the default behaviour is used.
+    #
+    # Examples:
+    #   r.is "needs_authorization" do
+    #     response.status = :unauthorized
+    #   end
+    #   r.is "nothing" do
+    #     response.status = :no_content
+    #   end
+    #
+    # The conversion is done through <tt>Rack::Utils.status_code</tt>.
+    module SymbolStatus
+      module ResponseMethods
+        # Sets the response status code by fixnum or symbol name
+        def status=(code)
+          code = Rack::Utils.status_code(code) if code.is_a?(Symbol)
+          super(code)
+        end
+      end
+    end
+
+    register_plugin(:symbol_status, SymbolStatus)
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The symbol_views plugin allows match blocks to return
+    # symbols, and consider those symbols as views to use for the
+    # response body.  So you can take code like:
+    #
+    #   r.root do
+    #     view :index
+    #   end
+    #   r.is "foo" do
+    #     view :foo
+    #   end
+    #
+    # and DRY it up:
+    #
+    #   r.root do
+    #     :index
+    #   end
+    #   r.is "foo" do
+    #     :foo
+    #   end
+    module SymbolViews
+      def self.load_dependencies(app)
+        app.plugin :custom_block_results
+      end
+
+      def self.configure(app)
+        app.opts[:custom_block_results][Symbol] = :view
+      end
+    end
+
+    register_plugin(:symbol_views, SymbolViews)
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The timestamp_public plugin adds a +timestamp_path+ method for constructing
+    # timestamp paths, and a +r.timestamp_public+ routing method to serve static files
+    # from a directory (using the public plugin).  This plugin is useful when you want
+    # to modify the path to static files when the modify timestamp on the file changes,
+    # ensuring that requests for the static file will not be cached.
+    #
+    # Note that while this plugin will not serve files outside of the public directory,
+    # for performance reasons it does not check the path of the file is inside the public
+    # directory when getting the modify timestamp.  If the +timestamp_path+ method is
+    # called with untrusted input, it is possible for an attacker to get the modify
+    # timestamp for any file on the file system.
+    #
+    # Examples:
+    #
+    #   # Use public folder as location of files, and static as the path prefix
+    #   plugin :timestamp_public
+    #
+    #   # Use /path/to/app/static as location of files, and public as the path prefix
+    #   opts[:root] = '/path/to/app'
+    #   plugin :public, root: 'static', prefix: 'public'
+    #
+    #   # Assuming public is the location of files, and static is the path prefix
+    #   route do
+    #     # Make GET /static/1238099123/images/foo.png look for public/images/foo.png 
+    #     r.timestamp_public
+    #
+    #     r.get "example" do
+    #       # "/static/1238099123/images/foo.png"
+    #       timestamp_path("images/foo.png")
+    #     end
+    #   end
+    module TimestampPublic
+      def self.load_dependencies(app, opts=OPTS)
+        app.plugin :public, opts
+      end
+
+      # Use options given to setup timestamped file serving.  The following option is
+      # recognized by the plugin:
+      #
+      # :prefix :: The prefix for paths, before the timestamp segment
+      #
+      # The options given are also passed to the public plugin.
+      def self.configure(app, opts=OPTS)
+        app.opts[:timestamp_public_prefix] = (opts[:prefix] || app.opts[:timestamp_public_prefix] || "static").dup.freeze
+      end
+
+      module InstanceMethods
+        # Return a path to the static file that could be served by r.timestamp_public.
+        # This does not check the file is inside the directory for performance reasons,
+        # so this should not be called with untrusted input.
+        def timestamp_path(file)
+          mtime = File.mtime(File.join(opts[:public_root], file))
+          "/#{opts[:timestamp_public_prefix]}/#{sprintf("%i%06i", mtime.to_i, mtime.usec)}/#{file}"
+        end
+      end
+
+      module RequestMethods
+        # Serve files from the public directory if the file exists,
+        # it includes the timestamp_public prefix segment followed by
+        # a integer segment for the timestamp, and this is a GET request.
+        def timestamp_public
+          if is_get?
+            on roda_class.opts[:timestamp_public_prefix], Integer do |_|
+              public
+            end
+          end
+        end
+      end
+    end
+
+    register_plugin(:timestamp_public, TimestampPublic)
+  end
+end