homura-runtime 0.3.3 → 0.3.5

data/vendor/rack/body_proxy.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Rack
+  # Proxy for response bodies allowing calling a block when
+  # the response body is closed (after the response has been fully
+  # sent to the client).
+  class BodyProxy
+    # Set the response body to wrap, and the block to call when the
+    # response has been fully sent.
+    def initialize(body, &block)
+      @body = body
+      @block = block
+      @closed = false
+    end
+
+    # Return whether the wrapped body responds to the method.
+    def respond_to_missing?(method_name, include_all = false)
+      case method_name
+      when :to_str
+        false
+      else
+        super or @body.respond_to?(method_name, include_all)
+      end
+    end
+
+    # If not already closed, close the wrapped body and
+    # then call the block the proxy was initialized with.
+    def close
+      return if @closed
+      @closed = true
+      begin
+        @body.close if @body.respond_to?(:close)
+      ensure
+        @block.call
+      end
+    end
+
+    # Whether the proxy is closed.  The proxy starts as not closed,
+    # and becomes closed on the first call to close.
+    def closed?
+      @closed
+    end
+
+    # Delegate missing methods to the wrapped body.
+    def method_missing(method_name, *args, &block)
+      case method_name
+      when :to_str
+        super
+      when :to_ary
+        begin
+          @body.__send__(method_name, *args, &block)
+        ensure
+          close
+        end
+      else
+        @body.__send__(method_name, *args, &block)
+      end
+    end
+    # :nocov:
+    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+    # :nocov:
+  end
+end

data/vendor/rack/builder.rb

@@ -0,0 +1,315 @@
+# backtick_javascript: true
+# frozen_string_literal: true
+
+require_relative 'urlmap'
+
+module Rack; end
+Rack::BUILDER_TOPLEVEL_BINDING = ->(builder){builder.instance_eval{binding}}
+
+module Rack
+  # Rack::Builder provides a domain-specific language (DSL) to construct Rack
+  # applications. It is primarily used to parse +config.ru+ files which
+  # instantiate several middleware and a final application which are hosted
+  # by a Rack-compatible web server.
+  #
+  # Example:
+  #
+  #   app = Rack::Builder.new do
+  #     use Rack::CommonLogger
+  #     map "/ok" do
+  #       run lambda { |env| [200, {'content-type' => 'text/plain'}, ['OK']] }
+  #     end
+  #   end
+  #
+  #   run app
+  #
+  # Or
+  #
+  #   app = Rack::Builder.app do
+  #     use Rack::CommonLogger
+  #     run lambda { |env| [200, {'content-type' => 'text/plain'}, ['OK']] }
+  #   end
+  #
+  #   run app
+  #
+  # +use+ adds middleware to the stack, +run+ dispatches to an application.
+  # You can use +map+ to construct a Rack::URLMap in a convenient way.
+  class Builder
+
+    # https://stackoverflow.com/questions/2223882/whats-the-difference-between-utf-8-and-utf-8-without-bom
+    UTF_8_BOM = '\xef\xbb\xbf'
+
+    # Parse the given config file to get a Rack application.
+    #
+    # If the config file ends in +.ru+, it is treated as a
+    # rackup file and the contents will be treated as if
+    # specified inside a Rack::Builder block.
+    #
+    # If the config file does not end in +.ru+, it is
+    # required and Rack will use the basename of the file
+    # to guess which constant will be the Rack application to run.
+    #
+    # Examples:
+    #
+    #   Rack::Builder.parse_file('config.ru')
+    #   # Rack application built using Rack::Builder.new
+    #
+    #   Rack::Builder.parse_file('app.rb')
+    #   # requires app.rb, which can be anywhere in Ruby's
+    #   # load path. After requiring, assumes App constant
+    #   # is a Rack application
+    #
+    #   Rack::Builder.parse_file('./my_app.rb')
+    #   # requires ./my_app.rb, which should be in the
+    #   # process's current directory.  After requiring,
+    #   # assumes MyApp constant is a Rack application
+    def self.parse_file(path, **options)
+      if path.end_with?('.ru')
+        return self.load_file(path, **options)
+      else
+        require path
+        return Object.const_get(::File.basename(path, '.rb').split('_').map(&:capitalize).join(''))
+      end
+    end
+
+    # Load the given file as a rackup file, treating the
+    # contents as if specified inside a Rack::Builder block.
+    #
+    # Ignores content in the file after +__END__+, so that
+    # use of +__END__+ will not result in a syntax error.
+    #
+    # Example config.ru file:
+    #
+    #   $ cat config.ru
+    #
+    #   use Rack::ContentLength
+    #   require './app.rb'
+    #   run App
+    def self.load_file(path, **options)
+      config = ::File.read(path)
+      config.slice!(/\A#{UTF_8_BOM}/) if config.encoding == Encoding::UTF_8
+
+      if config[/^#\\(.*)/]
+        fail "Parsing options from the first comment line is no longer supported: #{path}"
+      end
+
+      config.sub!(/^__END__\n.*\Z/m, '')
+
+      return new_from_string(config, path, **options)
+    end
+
+    # Evaluate the given +builder_script+ string in the context of
+    # a Rack::Builder block, returning a Rack application.
+    def self.new_from_string(builder_script, path = "(rackup)", **options)
+      builder = self.new(**options)
+
+      # We want to build a variant of TOPLEVEL_BINDING with self as a Rack::Builder instance.
+      # We cannot use instance_eval(String) as that would resolve constants differently.
+      binding = BUILDER_TOPLEVEL_BINDING.call(builder)
+      eval(builder_script, binding, path)
+
+      return builder.to_app
+    end
+
+    # Initialize a new Rack::Builder instance.  +default_app+ specifies the
+    # default application if +run+ is not called later.  If a block
+    # is given, it is evaluated in the context of the instance.
+    def initialize(default_app = nil, **options, &block)
+      @use = []
+      @map = nil
+      @run = default_app
+      @warmup = nil
+      @freeze_app = false
+      @options = options
+
+      instance_eval(&block) if block_given?
+    end
+
+    # Any options provided to the Rack::Builder instance at initialization.
+    # These options can be server-specific. Some general options are:
+    #
+    # * +:isolation+: One of +process+, +thread+ or +fiber+. The execution
+    #   isolation model to use.
+    attr :options
+
+    # Create a new Rack::Builder instance and return the Rack application
+    # generated from it.
+    def self.app(default_app = nil, &block)
+      self.new(default_app, &block).to_app
+    end
+
+    # Specifies middleware to use in a stack.
+    #
+    #   class Middleware
+    #     def initialize(app)
+    #       @app = app
+    #     end
+    #
+    #     def call(env)
+    #       env["rack.some_header"] = "setting an example"
+    #       @app.call(env)
+    #     end
+    #   end
+    #
+    #   use Middleware
+    #   run lambda { |env| [200, { "content-type" => "text/plain" }, ["OK"]] }
+    #
+    # All requests through to this application will first be processed by the middleware class.
+    # The +call+ method in this example sets an additional environment key which then can be
+    # referenced in the application if required.
+    def use(middleware, *args, &block)
+      if @map
+        mapping, @map = @map, nil
+        @use << proc { |app| generate_map(app, mapping) }
+      end
+      @use << proc { |app| middleware.new(app, *args, &block) }
+
+      nil
+    end
+    # :nocov:
+    ruby2_keywords(:use) if respond_to?(:ruby2_keywords, true)
+    # :nocov:
+
+    # Takes a block or argument that is an object that responds to #call and
+    # returns a Rack response.
+    #
+    # You can use a block:
+    #
+    #   run do |env|
+    #     [200, { "content-type" => "text/plain" }, ["Hello World!"]]
+    #   end
+    #
+    # You can also provide a lambda:
+    #
+    #   run lambda { |env| [200, { "content-type" => "text/plain" }, ["OK"]] }
+    #
+    # You can also provide a class instance:
+    #
+    #   class Heartbeat
+    #     def call(env)
+    #      [200, { "content-type" => "text/plain" }, ["OK"]]
+    #     end
+    #   end
+    #
+    #   run Heartbeat.new
+    #
+    def run(app = nil, &block)
+      raise ArgumentError, "Both app and block given!" if app && block_given?
+
+      @run = app || block
+
+      nil
+    end
+
+    # Takes a lambda or block that is used to warm-up the application. This block is called
+    # before the Rack application is returned by to_app.
+    #
+    #   warmup do |app|
+    #     client = Rack::MockRequest.new(app)
+    #     client.get('/')
+    #   end
+    #
+    #   use SomeMiddleware
+    #   run MyApp
+    def warmup(prc = nil, &block)
+      @warmup = prc || block
+    end
+
+    # Creates a route within the application.  Routes under the mapped path will be sent to
+    # the Rack application specified by run inside the block.  Other requests will be sent to the
+    # default application specified by run outside the block.
+    #
+    #   class App
+    #     def call(env)
+    #       [200, {'content-type' => 'text/plain'}, ["Hello World"]]
+    #     end
+    #   end
+    #
+    #   class Heartbeat
+    #     def call(env)
+    #       [200, { "content-type" => "text/plain" }, ["OK"]]
+    #     end
+    #   end
+    #
+    #   app = Rack::Builder.app do
+    #     map '/heartbeat' do
+    #       run Heartbeat.new
+    #     end
+    #     run App.new
+    #   end
+    #
+    #   run app
+    #
+    # The +use+ method can also be used inside the block to specify middleware to run under a specific path:
+    #
+    #   app = Rack::Builder.app do
+    #     map '/heartbeat' do
+    #       use Middleware
+    #       run Heartbeat.new
+    #     end
+    #     run App.new
+    #   end
+    #
+    # This example includes a piece of middleware which will run before +/heartbeat+ requests hit +Heartbeat+.
+    #
+    # Note that providing a +path+ of +/+ will ignore any default application given in a +run+ statement
+    # outside the block.
+    def map(path, &block)
+      @map ||= {}
+      @map[path] = block
+
+      nil
+    end
+
+    # Freeze the app (set using run) and all middleware instances when building the application
+    # in to_app.
+    def freeze_app
+      @freeze_app = true
+    end
+
+    # Return the Rack application generated by this instance.
+    def to_app
+      app = @map ? generate_map(@run, @map) : @run
+      fail "missing run or map statement" unless app
+      app.freeze if @freeze_app
+      # homura patch: neither Array#inject nor an `each` block with
+      # a closured local variable reliably threads the middleware
+      # accumulator through the chain on Opal (the closure copy of
+      # `acc` does not propagate). Use an index-based loop so the
+      # accumulator lives in a single function scope without closures.
+      list = @use.reverse
+      app = wrap_middleware_chain(list, app)
+      @warmup.call(app) if @warmup
+      app
+    end
+
+    def wrap_middleware_chain(list, initial)
+      acc = initial
+      i = 0
+      n = list.length
+      while i < n
+        acc = list[i].call(acc)
+        acc.freeze if @freeze_app
+        i += 1
+      end
+      acc
+    end
+
+    # Call the Rack application generated by this builder instance. Note that
+    # this rebuilds the Rack application and runs the warmup code (if any)
+    # every time it is called, so it should not be used if performance is important.
+    def call(env)
+      to_app.call(env)
+    end
+
+    private
+
+    # Generate a URLMap instance by generating new Rack applications for each
+    # map block in this instance.
+    def generate_map(default_app, mapping)
+      mapped = default_app ? { '/' => default_app } : {}
+      mapping.each { |r, b| mapped[r] = self.class.new(default_app, &b).to_app }
+      URLMap.new(mapped)
+    end
+  end
+end

data/vendor/rack/cascade.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative 'constants'
+
+module Rack
+  # Rack::Cascade tries a request on several apps, and returns the
+  # first response that is not 404 or 405 (or in a list of configured
+  # status codes).  If all applications tried return one of the configured
+  # status codes, return the last response.
+
+  class Cascade
+    # An array of applications to try in order.
+    attr_reader :apps
+
+    # Set the apps to send requests to, and what statuses result in
+    # cascading.  Arguments:
+    #
+    # apps: An enumerable of rack applications.
+    # cascade_for: The statuses to use cascading for.  If a response is received
+    #              from an app, the next app is tried.
+    def initialize(apps, cascade_for = [404, 405])
+      @apps = []
+      apps.each { |app| add app }
+
+      @cascade_for = {}
+      [*cascade_for].each { |status| @cascade_for[status] = true }
+    end
+
+    # Call each app in order.  If the responses uses a status that requires
+    # cascading, try the next app.  If all responses require cascading,
+    # return the response from the last app.
+    def call(env)
+      return [404, { CONTENT_TYPE => "text/plain" }, []] if @apps.empty?
+      result = nil
+      last_body = nil
+
+      @apps.each do |app|
+        # The SPEC says that the body must be closed after it has been iterated
+        # by the server, or if it is replaced by a middleware action. Cascade
+        # replaces the body each time a cascade happens. It is assumed that nil
+        # does not respond to close, otherwise the previous application body
+        # will be closed. The final application body will not be closed, as it
+        # will be passed to the server as a result.
+        last_body.close if last_body.respond_to? :close
+
+        result = app.call(env)
+        return result unless @cascade_for.include?(result[0].to_i)
+        last_body = result[2]
+      end
+
+      result
+    end
+
+    # Append an app to the list of apps to cascade.  This app will
+    # be tried last.
+    def add(app)
+      @apps << app
+    end
+
+    # Whether the given app is one of the apps to cascade to.
+    def include?(app)
+      @apps.include?(app)
+    end
+
+    alias_method :<<, :add
+  end
+end

data/vendor/rack/common_logger.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative 'constants'
+require_relative 'utils'
+require_relative 'body_proxy'
+require_relative 'request'
+
+module Rack
+  # Rack::CommonLogger forwards every request to the given +app+, and
+  # logs a line in the
+  # {Apache common log format}[http://httpd.apache.org/docs/1.3/logs.html#common]
+  # to the configured logger.
+  class CommonLogger
+    # Common Log Format: http://httpd.apache.org/docs/1.3/logs.html#common
+    #
+    #   lilith.local - - [07/Aug/2006 23:58:02 -0400] "GET / HTTP/1.1" 500 -
+    #
+    #   %{%s - %s [%s] "%s %s%s %s" %d %s\n} %
+    #
+    # The actual format is slightly different than the above due to the
+    # separation of SCRIPT_NAME and PATH_INFO, and because the elapsed
+    # time in seconds is included at the end.
+    FORMAT = %{%s - %s [%s] "%s %s%s%s %s" %d %s %0.4f }
+
+    # +logger+ can be any object that supports the +write+ or +<<+ methods,
+    # which includes the standard library Logger.  These methods are called
+    # with a single string argument, the log message.
+    # If +logger+ is nil, CommonLogger will fall back <tt>env['rack.errors']</tt>.
+    def initialize(app, logger = nil)
+      @app = app
+      @logger = logger
+    end
+
+    # Log all requests in common_log format after a response has been
+    # returned.  Note that if the app raises an exception, the request
+    # will not be logged, so if exception handling middleware are used,
+    # they should be loaded after this middleware.  Additionally, because
+    # the logging happens after the request body has been fully sent, any
+    # exceptions raised during the sending of the response body will
+    # cause the request not to be logged.
+    def call(env)
+      began_at = Utils.clock_time
+      status, headers, body = response = @app.call(env)
+
+      response[2] = BodyProxy.new(body) { log(env, status, headers, began_at) }
+      response
+    end
+
+    private
+
+    # Log the request to the configured logger.
+    def log(env, status, response_headers, began_at)
+      request = Rack::Request.new(env)
+      length = extract_content_length(response_headers)
+
+      msg = sprintf(FORMAT,
+        request.ip || "-",
+        request.get_header("REMOTE_USER") || "-",
+        Time.now.strftime("%d/%b/%Y:%H:%M:%S %z"),
+        request.request_method,
+        request.script_name,
+        request.path_info,
+        request.query_string.empty? ? "" : "?#{request.query_string}",
+        request.get_header(SERVER_PROTOCOL),
+        status.to_s[0..3],
+        length,
+        Utils.clock_time - began_at)
+
+      # homura: Opal Strings are immutable, so use non-mutating gsub +
+      # chomp + concat instead of `gsub!` / `String#[]=`. Behaviour
+      # identical on MRI; required to keep CommonLogger usable when
+      # Sinatra default-middleware is active under the Workers + Opal
+      # stack.
+      msg = msg.gsub(/[^[:print:]]/) { |c| sprintf("\\x%x", c.ord) }
+      msg = msg.chomp + "\n"
+
+      logger = @logger || request.get_header(RACK_ERRORS)
+      # Standard library logger doesn't support write but it supports << which actually
+      # calls to write on the log device without formatting
+      if logger.respond_to?(:write)
+        logger.write(msg)
+      else
+        logger << msg
+      end
+    end
+
+    # Attempt to determine the content length for the response to
+    # include it in the logged data.
+    def extract_content_length(headers)
+      value = headers[CONTENT_LENGTH]
+      !value || value.to_s == '0' ? '-' : value
+    end
+  end
+end

data/vendor/rack/conditional_get.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative 'constants'
+require_relative 'utils'
+require_relative 'body_proxy'
+
+module Rack
+
+  # Middleware that enables conditional GET using if-none-match and
+  # if-modified-since. The application should set either or both of the
+  # last-modified or etag response headers according to RFC 2616. When
+  # either of the conditions is met, the response body is set to be zero
+  # length and the response status is set to 304 Not Modified.
+  #
+  # Applications that defer response body generation until the body's each
+  # message is received will avoid response body generation completely when
+  # a conditional GET matches.
+  #
+  # Adapted from Michael Klishin's Merb implementation:
+  # https://github.com/wycats/merb/blob/master/merb-core/lib/merb-core/rack/middleware/conditional_get.rb
+  class ConditionalGet
+    def initialize(app)
+      @app = app
+    end
+
+    # Return empty 304 response if the response has not been
+    # modified since the last request.
+    def call(env)
+      case env[REQUEST_METHOD]
+      when "GET", "HEAD"
+        status, headers, body = response = @app.call(env)
+
+        if status == 200 && fresh?(env, headers)
+          response[0] = 304
+          headers.delete(CONTENT_TYPE)
+          headers.delete(CONTENT_LENGTH)
+
+          # We are done with the body:
+          body.close if body.respond_to?(:close)
+          response[2] = []
+        end
+        response
+      else
+        @app.call(env)
+      end
+    end
+
+  private
+
+    # Return whether the response has not been modified since the
+    # last request.
+    def fresh?(env, headers)
+      # if-none-match has priority over if-modified-since per RFC 7232
+      if none_match = env['HTTP_IF_NONE_MATCH']
+        etag_matches?(none_match, headers)
+      elsif (modified_since = env['HTTP_IF_MODIFIED_SINCE']) && (modified_since = to_rfc2822(modified_since))
+        modified_since?(modified_since, headers)
+      end
+    end
+
+    # Whether the etag response header matches the if-none-match request header.
+    # If so, the request has not been modified.
+    def etag_matches?(none_match, headers)
+      headers[ETAG] == none_match
+    end
+
+    # Whether the last-modified response header matches the if-modified-since
+    # request header.  If so, the request has not been modified.
+    def modified_since?(modified_since, headers)
+      last_modified = to_rfc2822(headers['last-modified']) and
+        modified_since >= last_modified
+    end
+
+    # Return a Time object for the given string (which should be in RFC2822
+    # format), or nil if the string cannot be parsed.
+    def to_rfc2822(since)
+      # shortest possible valid date is the obsolete: 1 Nov 97 09:55 A
+      # anything shorter is invalid, this avoids exceptions for common cases
+      # most common being the empty string
+      if since && since.length >= 16
+        # NOTE: there is no trivial way to write this in a non exception way
+        #   _rfc2822 returns a hash but is not that usable
+        Time.rfc2822(since) rescue nil
+      end
+    end
+  end
+end

data/vendor/rack/config.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Rack
+  # Rack::Config modifies the environment using the block given during
+  # initialization.
+  #
+  # Example:
+  #     use Rack::Config do |env|
+  #       env['my-key'] = 'some-value'
+  #     end
+  class Config
+    def initialize(app, &block)
+      @app = app
+      @block = block
+    end
+
+    def call(env)
+      @block.call(env)
+      @app.call(env)
+    end
+  end
+end