ultra-lite-hub 0.0.1

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

@@ -0,0 +1,221 @@
+# frozen-string-literal: true
+
+begin
+  require 'rack/headers'
+rescue LoadError
+end
+
+class Roda
+  # Contains constants for response headers.  This approach is used so that all
+  # headers used internally by Roda can be lower case on Rack 3, so that it is
+  # possible to use a plain hash of response headers instead of using Rack::Headers.
+  module RodaResponseHeaders
+    downcase = defined?(Rack::Headers) && Rack::Headers.is_a?(Class)
+
+    %w'Allow Cache-Control Content-Disposition Content-Encoding Content-Length
+       Content-Security-Policy Content-Security-Policy-Report-Only Content-Type
+       ETag Expires Last-Modified Link Location Set-Cookie Transfer-Encoding Vary
+       Permissions-Policy Permissions-Policy-Report-Only Strict-Transport-Security'.
+      each do |value|
+        value = value.downcase if downcase
+        const_set(value.tr('-', '_').upcase!.to_sym, value.freeze)
+      end
+  end
+
+  # Base class used for Roda responses.  The instance methods for this
+  # class are added by Roda::RodaPlugins::Base::ResponseMethods, the class
+  # methods are added by Roda::RodaPlugins::Base::ResponseClassMethods.
+  class RodaResponse
+    @roda_class = ::Roda
+  end
+
+  module RodaPlugins
+    module Base
+      # Class methods for RodaResponse
+      module ResponseClassMethods
+        # Reference to the Roda class related to this response class.
+        attr_accessor :roda_class
+
+        # Since RodaResponse is anonymously subclassed when Roda is subclassed,
+        # and then assigned to a constant of the Roda subclass, make inspect
+        # reflect the likely name for the class.
+        def inspect
+          "#{roda_class.inspect}::RodaResponse"
+        end
+      end
+
+      # Instance methods for RodaResponse
+      module ResponseMethods
+        # The body for the current response.
+        attr_reader :body
+
+        # The hash of response headers for the current response.
+        attr_reader :headers
+
+        # The status code to use for the response.  If none is given, will use 200
+        # code for non-empty responses and a 404 code for empty responses.
+        attr_accessor :status
+
+        # Set the default headers when creating a response.
+        def initialize
+          @headers = _initialize_headers
+          @body    = []
+          @length  = 0
+        end
+
+        # Return the response header with the given key. Example:
+        #
+        #   response['Content-Type'] # => 'text/html'
+        def [](key)
+          @headers[key]
+        end
+
+        # Set the response header with the given key to the given value.
+        #
+        #   response['Content-Type'] = 'application/json'
+        def []=(key, value)
+          @headers[key] = value
+        end
+
+        # The default headers to use for responses.
+        def default_headers
+          DEFAULT_HEADERS
+        end
+
+        # Whether the response body has been written to yet.  Note
+        # that writing an empty string to the response body marks
+        # the response as not empty. Example:
+        #
+        #   response.empty? # => true
+        #   response.write('a')
+        #   response.empty? # => false
+        def empty?
+          @body.empty?
+        end
+
+        # Return the rack response array of status, headers, and body
+        # for the current response.  If the status has not been set,
+        # uses the return value of default_status if the body has
+        # been written to, otherwise uses a 404 status.
+        # Adds the Content-Length header to the size of the response body.
+        #
+        # Example:
+        #
+        #   response.finish
+        #   #  => [200,
+        #   #      {'Content-Type'=>'text/html', 'Content-Length'=>'0'},
+        #   #      []]
+        def finish
+          b = @body
+          set_default_headers
+          h = @headers
+
+          if b.empty?
+            s = @status || 404
+            if (s == 304 || s == 204 || (s >= 100 && s <= 199))
+              h.delete(RodaResponseHeaders::CONTENT_TYPE)
+            elsif s == 205
+              empty_205_headers(h)
+            else
+              h[RodaResponseHeaders::CONTENT_LENGTH] ||= '0'
+            end
+          else
+            s = @status || default_status
+            h[RodaResponseHeaders::CONTENT_LENGTH] ||= @length.to_s
+          end
+
+          [s, h, b]
+        end
+
+        # Return the rack response array using a given body.  Assumes a
+        # 200 response status unless status has been explicitly set,
+        # and doesn't add the Content-Length header or use the existing
+        # body.
+        def finish_with_body(body)
+          set_default_headers
+          [@status || default_status, @headers, body]
+        end
+
+        # Return the default response status to be used when the body
+        # has been written to. This is split out to make overriding
+        # easier in plugins.
+        def default_status
+          200
+        end
+
+        # Show response class, status code, response headers, and response body
+        def inspect
+          "#<#{self.class.inspect} #{@status.inspect} #{@headers.inspect} #{@body.inspect}>"
+        end
+
+        # Set the Location header to the given path, and the status
+        # to the given status.  Example:
+        #
+        #   response.redirect('foo', 301)
+        #   response.redirect('bar')
+        def redirect(path, status = 302)
+          @headers[RodaResponseHeaders::LOCATION] = path
+          @status  = status
+          nil
+        end
+
+        # Return the Roda class related to this response.
+        def roda_class
+          self.class.roda_class
+        end
+
+        # Write to the response body.  Returns nil.
+        #
+        #   response.write('foo')
+        def write(str)
+          s = str.to_s
+          @length += s.bytesize
+          @body << s
+          nil
+        end
+
+        private
+
+        if defined?(Rack::Headers) && Rack::Headers.is_a?(Class)
+          DEFAULT_HEADERS = Rack::Headers[{RodaResponseHeaders::CONTENT_TYPE => "text/html".freeze}].freeze
+
+          # Use Rack::Headers for headers by default on Rack 3
+          def _initialize_headers
+            Rack::Headers.new
+          end
+        else
+          DEFAULT_HEADERS = {RodaResponseHeaders::CONTENT_TYPE => "text/html".freeze}.freeze
+
+          # Use plain hash for headers by default on Rack 1-2
+          def _initialize_headers
+            {}
+          end
+        end
+
+        if Rack.release < '2.0.2'
+          # Don't use a content length for empty 205 responses on
+          # rack 1, as it violates Rack::Lint in that version.
+          def empty_205_headers(headers)
+            headers.delete(RodaResponseHeaders::CONTENT_TYPE)
+            headers.delete(RodaResponseHeaders::CONTENT_LENGTH)
+          end
+        else
+          # Set the content length for empty 205 responses to 0
+          def empty_205_headers(headers)
+            headers.delete(RodaResponseHeaders::CONTENT_TYPE)
+            headers[RodaResponseHeaders::CONTENT_LENGTH] = '0'
+          end
+        end
+
+        # For each default header, if a header has not already been set for the
+        # response, set the header in the response.
+        def set_default_headers
+          h = @headers
+          default_headers.each do |k,v|
+            h[k] ||= v
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,183 @@
+# frozen-string-literal: true
+
+require_relative '../roda'
+require_relative 'plugins/sessions'
+
+# Session middleware that can be used in any Rack application
+# that uses Roda's sessions plugin for encrypted and signed cookies.
+# See Roda::RodaPlugins::Sessions for details on options.
+class RodaSessionMiddleware
+  # Class to hold session data.  This is designed to mimic the API
+  # of Rack::Session::Abstract::SessionHash, but is simpler and faster.
+  # Undocumented methods operate the same as hash methods, but load the
+  # session from the cookie if it hasn't been loaded yet, and convert
+  # keys to strings.
+  #
+  # One difference between SessionHash and Rack::Session::Abstract::SessionHash
+  # is that SessionHash does not attempt to setup a session id, since
+  # one is not needed for cookie-based sessions, only for sessions
+  # that are loaded out of a database.  If you need to have a session id
+  # for other reasons, manually create a session id using a randomly generated
+  # string.
+  class SessionHash
+    # The Roda::RodaRequest subclass instance related to the session.
+    attr_reader :req
+
+    # The underlying data hash, or nil if the session has not yet been
+    # loaded.
+    attr_reader :data
+
+    def initialize(req)
+      @req = req
+    end
+
+    # The Roda sessions plugin options used by the middleware for this
+    # session hash.
+    def options
+      @req.roda_class.opts[:sessions]
+    end
+
+    def each(&block)
+      load!
+      @data.each(&block)
+    end
+
+    def [](key)
+      load!
+      @data[key.to_s]
+    end
+
+    def fetch(key, default = (no_default = true), &block)
+      load!
+      if no_default
+        @data.fetch(key.to_s, &block)
+      else
+        @data.fetch(key.to_s, default, &block)
+      end
+    end
+
+    def has_key?(key)
+      load!
+      @data.has_key?(key.to_s)
+    end
+    alias :key? :has_key?
+    alias :include? :has_key?
+
+    def []=(key, value)
+      load!
+      @data[key.to_s] = value
+    end
+    alias :store :[]=
+
+    # Clear the session, also removing a couple of roda session
+    # keys from the environment so that the related cookie will
+    # either be set or cleared in the rack response.
+    def clear
+      load!
+      env = @req.env
+      env.delete('roda.session.created_at')
+      env.delete('roda.session.updated_at')
+      @data.clear
+    end
+    alias :destroy :clear
+
+    def to_hash
+      load!
+      @data.dup
+    end
+
+    def update(hash)
+      load!
+      hash.each do |key, value|
+        @data[key.to_s] = value
+      end
+      @data
+    end
+    alias :merge! :update
+
+    def replace(hash)
+      load!
+      @data.clear
+      update(hash)
+    end
+
+    def delete(key)
+      load!
+      @data.delete(key.to_s)
+    end
+
+    # If the session hasn't been loaded, display that.
+    def inspect
+      if loaded?
+        @data.inspect
+      else
+        "#<#{self.class}:0x#{self.object_id.to_s(16)} not yet loaded>"
+      end
+    end
+
+    # Return whether the session cookie already exists.
+    # If this is false, then the session was set to an empty hash.
+    def exists?
+      load!
+      req.env.has_key?('roda.session.serialized')
+    end
+
+    # Whether the session has already been loaded from the cookie yet.
+    def loaded?
+      !!defined?(@data)
+    end
+
+    def empty?
+      load!
+      @data.empty?
+    end
+
+    def keys
+      load!
+      @data.keys
+    end
+
+    def values
+      load!
+      @data.values
+    end
+
+    private
+
+    # Load the session from the cookie.
+    def load!
+      @data ||= @req.send(:_load_session)
+    end
+  end
+
+  module RequestMethods
+    # Work around for if type_routing plugin is loaded into Roda class itself.
+    def _remaining_path(_)
+    end
+  end
+
+  # Setup the middleware, passing +opts+ as the Roda sessions plugin options.
+  def initialize(app, opts)
+    mid = Class.new(Roda)
+    Roda::RodaPlugins.set_temp_name(mid){"RodaSessionMiddleware::_RodaSubclass"}
+    mid.plugin :sessions, opts
+    @req_class = mid::RodaRequest
+    @req_class.send(:include, RequestMethods)
+    @app = app
+  end
+
+  # Initialize the session hash in the environment before calling the next
+  # application, and if the session has been loaded after the result has been
+  # returned, then persist the session in the cookie.
+  def call(env)
+    session = env['rack.session'] = SessionHash.new(@req_class.new(nil, env))
+
+    res = @app.call(env)
+
+    if session.loaded?
+      session.req.persist_session(res[1], session.data)
+    end
+
+    res
+  end
+end

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

@@ -0,0 +1,18 @@
+class Roda
+  # The major version of Roda, updated only for major changes that are
+  # likely to require modification to Roda apps.
+  RodaMajorVersion = 3
+
+  # The minor version of Roda, updated for new feature releases of Roda.
+  RodaMinorVersion = 105
+
+  # The patch version of Roda, updated only for bug fixes from the last
+  # feature release.
+  RodaPatchVersion = 0
+
+  # The full version of Roda as a string.
+  RodaVersion = "#{RodaMajorVersion}.#{RodaMinorVersion}.#{RodaPatchVersion}".freeze
+
+  # The full version of Roda as a number (3.7.0 => 30070)
+  RodaVersionNumber = RodaMajorVersion*10000 + RodaMinorVersion*10 + RodaPatchVersion
+end