diy_rails 0.1.0 → 0.2.0

data/vendor/bundle/ruby/3.0.0/gems/rack-2.2.4/lib/rack/common_logger.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-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\n}
-
-    # +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 = @app.call(env)
-      headers = Utils::HeaderHash[headers]
-      body = BodyProxy.new(body) { log(env, status, headers, began_at) }
-      [status, headers, body]
-    end
-
-    private
-
-    # Log the request to the configured logger.
-    def log(env, status, header, began_at)
-      length = extract_content_length(header)
-
-      msg = FORMAT % [
-        env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-",
-        env["REMOTE_USER"] || "-",
-        Time.now.strftime("%d/%b/%Y:%H:%M:%S %z"),
-        env[REQUEST_METHOD],
-        env[SCRIPT_NAME],
-        env[PATH_INFO],
-        env[QUERY_STRING].empty? ? "" : "?#{env[QUERY_STRING]}",
-        env[SERVER_PROTOCOL],
-        status.to_s[0..3],
-        length,
-        Utils.clock_time - began_at ]
-
-      msg.gsub!(/[^[:print:]\n]/) { |c| "\\x#{c.ord}" }
-
-      logger = @logger || env[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/bundle/ruby/3.0.0/gems/rack-2.2.4/lib/rack/conditional_get.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-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 = @app.call(env)
-        headers = Utils::HeaderHash[headers]
-        if status == 200 && fresh?(env, headers)
-          status = 304
-          headers.delete(CONTENT_TYPE)
-          headers.delete(CONTENT_LENGTH)
-          original_body = body
-          body = Rack::BodyProxy.new([]) do
-            original_body.close if original_body.respond_to?(:close)
-          end
-        end
-        [status, headers, body]
-      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/bundle/ruby/3.0.0/gems/rack-2.2.4/lib/rack/config.rb

@@ -1,22 +0,0 @@
-# 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

data/vendor/bundle/ruby/3.0.0/gems/rack-2.2.4/lib/rack/content_length.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-
-  # Sets the Content-Length header on responses that do not specify
-  # a Content-Length or Transfer-Encoding header.  Note that this
-  # does not fix responses that have an invalid Content-Length
-  # header specified.
-  class ContentLength
-    include Rack::Utils
-
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      status, headers, body = @app.call(env)
-      headers = HeaderHash[headers]
-
-      if !STATUS_WITH_NO_ENTITY_BODY.key?(status.to_i) &&
-         !headers[CONTENT_LENGTH] &&
-         !headers[TRANSFER_ENCODING]
-
-        obody = body
-        body, length = [], 0
-        obody.each { |part| body << part; length += part.bytesize }
-
-        body = BodyProxy.new(body) do
-          obody.close if obody.respond_to?(:close)
-        end
-
-        headers[CONTENT_LENGTH] = length.to_s
-      end
-
-      [status, headers, body]
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rack-2.2.4/lib/rack/content_type.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-
-  # Sets the Content-Type header on responses which don't have one.
-  #
-  # Builder Usage:
-  #   use Rack::ContentType, "text/plain"
-  #
-  # When no content type argument is provided, "text/html" is the
-  # default.
-  class ContentType
-    include Rack::Utils
-
-    def initialize(app, content_type = "text/html")
-      @app, @content_type = app, content_type
-    end
-
-    def call(env)
-      status, headers, body = @app.call(env)
-      headers = Utils::HeaderHash[headers]
-
-      unless STATUS_WITH_NO_ENTITY_BODY.key?(status.to_i)
-        headers[CONTENT_TYPE] ||= @content_type
-      end
-
-      [status, headers, body]
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rack-2.2.4/lib/rack/core_ext/regexp.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-# Regexp has `match?` since Ruby 2.4
-# so to support Ruby < 2.4 we need to define this method
-
-module Rack
-  module RegexpExtensions
-    refine Regexp do
-      def match?(string, pos = 0)
-        !!match(string, pos)
-      end
-    end unless //.respond_to?(:match?)
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rack-2.2.4/lib/rack/deflater.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-require "zlib"
-require "time"  # for Time.httpdate
-
-module Rack
-  # This middleware enables content encoding of http responses,
-  # usually for purposes of compression.
-  #
-  # Currently supported encodings:
-  #
-  # * gzip
-  # * identity (no transformation)
-  #
-  # This middleware automatically detects when encoding is supported
-  # and allowed. For example no encoding is made when a cache
-  # directive of 'no-transform' is present, when the response status
-  # code is one that doesn't allow an entity body, or when the body
-  # is empty.
-  #
-  # Note that despite the name, Deflater does not support the +deflate+
-  # encoding.
-  class Deflater
-    (require_relative 'core_ext/regexp'; using ::Rack::RegexpExtensions) if RUBY_VERSION < '2.4'
-
-    # Creates Rack::Deflater middleware. Options:
-    #
-    # :if :: a lambda enabling / disabling deflation based on returned boolean value
-    #        (e.g <tt>use Rack::Deflater, :if => lambda { |*, body| sum=0; body.each { |i| sum += i.length }; sum > 512 }</tt>).
-    #        However, be aware that calling `body.each` inside the block will break cases where `body.each` is not idempotent,
-    #        such as when it is an +IO+ instance.
-    # :include :: a list of content types that should be compressed. By default, all content types are compressed.
-    # :sync :: determines if the stream is going to be flushed after every chunk.  Flushing after every chunk reduces
-    #          latency for time-sensitive streaming applications, but hurts compression and throughput.
-    #          Defaults to +true+.
-    def initialize(app, options = {})
-      @app = app
-      @condition = options[:if]
-      @compressible_types = options[:include]
-      @sync = options.fetch(:sync, true)
-    end
-
-    def call(env)
-      status, headers, body = @app.call(env)
-      headers = Utils::HeaderHash[headers]
-
-      unless should_deflate?(env, status, headers, body)
-        return [status, headers, body]
-      end
-
-      request = Request.new(env)
-
-      encoding = Utils.select_best_encoding(%w(gzip identity),
-                                            request.accept_encoding)
-
-      # Set the Vary HTTP header.
-      vary = headers["Vary"].to_s.split(",").map(&:strip)
-      unless vary.include?("*") || vary.include?("Accept-Encoding")
-        headers["Vary"] = vary.push("Accept-Encoding").join(",")
-      end
-
-      case encoding
-      when "gzip"
-        headers['Content-Encoding'] = "gzip"
-        headers.delete(CONTENT_LENGTH)
-        mtime = headers["Last-Modified"]
-        mtime = Time.httpdate(mtime).to_i if mtime
-        [status, headers, GzipStream.new(body, mtime, @sync)]
-      when "identity"
-        [status, headers, body]
-      when nil
-        message = "An acceptable encoding for the requested resource #{request.fullpath} could not be found."
-        bp = Rack::BodyProxy.new([message]) { body.close if body.respond_to?(:close) }
-        [406, { CONTENT_TYPE => "text/plain", CONTENT_LENGTH => message.length.to_s }, bp]
-      end
-    end
-
-    # Body class used for gzip encoded responses.
-    class GzipStream
-      # Initialize the gzip stream.  Arguments:
-      # body :: Response body to compress with gzip
-      # mtime :: The modification time of the body, used to set the
-      #          modification time in the gzip header.
-      # sync :: Whether to flush each gzip chunk as soon as it is ready.
-      def initialize(body, mtime, sync)
-        @body = body
-        @mtime = mtime
-        @sync = sync
-      end
-
-      # Yield gzip compressed strings to the given block.
-      def each(&block)
-        @writer = block
-        gzip = ::Zlib::GzipWriter.new(self)
-        gzip.mtime = @mtime if @mtime
-        @body.each { |part|
-          # Skip empty strings, as they would result in no output,
-          # and flushing empty parts would raise Zlib::BufError.
-          next if part.empty?
-
-          gzip.write(part)
-          gzip.flush if @sync
-        }
-      ensure
-        gzip.close
-      end
-
-      # Call the block passed to #each with the the gzipped data.
-      def write(data)
-        @writer.call(data)
-      end
-
-      # Close the original body if possible.
-      def close
-        @body.close if @body.respond_to?(:close)
-      end
-    end
-
-    private
-
-    # Whether the body should be compressed.
-    def should_deflate?(env, status, headers, body)
-      # Skip compressing empty entity body responses and responses with
-      # no-transform set.
-      if Utils::STATUS_WITH_NO_ENTITY_BODY.key?(status.to_i) ||
-          /\bno-transform\b/.match?(headers['Cache-Control'].to_s) ||
-          headers['Content-Encoding']&.!~(/\bidentity\b/)
-        return false
-      end
-
-      # Skip if @compressible_types are given and does not include request's content type
-      return false if @compressible_types && !(headers.has_key?('Content-Type') && @compressible_types.include?(headers['Content-Type'][/[^;]*/]))
-
-      # Skip if @condition lambda is given and evaluates to false
-      return false if @condition && !@condition.call(env, status, headers, body)
-
-      # No point in compressing empty body, also handles usage with
-      # Rack::Sendfile.
-      return false if headers[CONTENT_LENGTH] == '0'
-
-      true
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rack-2.2.4/lib/rack/directory.rb

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-require 'time'
-
-module Rack
-  # Rack::Directory serves entries below the +root+ given, according to the
-  # path info of the Rack request. If a directory is found, the file's contents
-  # will be presented in an html based index. If a file is found, the env will
-  # be passed to the specified +app+.
-  #
-  # If +app+ is not specified, a Rack::Files of the same +root+ will be used.
-
-  class Directory
-    DIR_FILE = "<tr><td class='name'><a href='%s'>%s</a></td><td class='size'>%s</td><td class='type'>%s</td><td class='mtime'>%s</td></tr>\n"
-    DIR_PAGE_HEADER = <<-PAGE
-<html><head>
-  <title>%s</title>
-  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
-  <style type='text/css'>
-table { width:100%%; }
-.name { text-align:left; }
-.size, .mtime { text-align:right; }
-.type { width:11em; }
-.mtime { width:15em; }
-  </style>
-</head><body>
-<h1>%s</h1>
-<hr />
-<table>
-  <tr>
-    <th class='name'>Name</th>
-    <th class='size'>Size</th>
-    <th class='type'>Type</th>
-    <th class='mtime'>Last Modified</th>
-  </tr>
-    PAGE
-    DIR_PAGE_FOOTER = <<-PAGE
-</table>
-<hr />
-</body></html>
-    PAGE
-
-    # Body class for directory entries, showing an index page with links
-    # to each file.
-    class DirectoryBody < Struct.new(:root, :path, :files)
-      # Yield strings for each part of the directory entry
-      def each
-        show_path = Utils.escape_html(path.sub(/^#{root}/, ''))
-        yield(DIR_PAGE_HEADER % [ show_path, show_path ])
-
-        unless path.chomp('/') == root
-          yield(DIR_FILE % DIR_FILE_escape(files.call('..')))
-        end
-
-        Dir.foreach(path) do |basename|
-          next if basename.start_with?('.')
-          next unless f = files.call(basename)
-          yield(DIR_FILE % DIR_FILE_escape(f))
-        end
-
-        yield(DIR_PAGE_FOOTER)
-      end
-
-      private
-
-      # Escape each element in the array of html strings.
-      def DIR_FILE_escape(htmls)
-        htmls.map { |e| Utils.escape_html(e) }
-      end
-    end
-
-    # The root of the directory hierarchy.  Only requests for files and
-    # directories inside of the root directory are supported.
-    attr_reader :root
-
-    # Set the root directory and application for serving files.
-    def initialize(root, app = nil)
-      @root = ::File.expand_path(root)
-      @app = app || Files.new(@root)
-      @head = Head.new(method(:get))
-    end
-
-    def call(env)
-      # strip body if this is a HEAD call
-      @head.call env
-    end
-
-    # Internals of request handling.  Similar to call but does
-    # not remove body for HEAD requests.
-    def get(env)
-      script_name = env[SCRIPT_NAME]
-      path_info = Utils.unescape_path(env[PATH_INFO])
-
-      if client_error_response = check_bad_request(path_info) || check_forbidden(path_info)
-        client_error_response
-      else
-        path = ::File.join(@root, path_info)
-        list_path(env, path, path_info, script_name)
-      end
-    end
-
-    # Rack response to use for requests with invalid paths, or nil if path is valid.
-    def check_bad_request(path_info)
-      return if Utils.valid_path?(path_info)
-
-      body = "Bad Request\n"
-      [400, { CONTENT_TYPE => "text/plain",
-        CONTENT_LENGTH => body.bytesize.to_s,
-        "X-Cascade" => "pass" }, [body]]
-    end
-
-    # Rack response to use for requests with paths outside the root, or nil if path is inside the root.
-    def check_forbidden(path_info)
-      return unless path_info.include? ".."
-      return if ::File.expand_path(::File.join(@root, path_info)).start_with?(@root)
-
-      body = "Forbidden\n"
-      [403, { CONTENT_TYPE => "text/plain",
-        CONTENT_LENGTH => body.bytesize.to_s,
-        "X-Cascade" => "pass" }, [body]]
-    end
-
-    # Rack response to use for directories under the root.
-    def list_directory(path_info, path, script_name)
-      url_head = (script_name.split('/') + path_info.split('/')).map do |part|
-        Utils.escape_path part
-      end
-
-      # Globbing not safe as path could contain glob metacharacters
-      body = DirectoryBody.new(@root, path, ->(basename) do
-        stat = stat(::File.join(path, basename))
-        next unless stat
-
-        url = ::File.join(*url_head + [Utils.escape_path(basename)])
-        mtime = stat.mtime.httpdate
-        if stat.directory?
-          type = 'directory'
-          size = '-'
-          url << '/'
-          if basename == '..'
-            basename = 'Parent Directory'
-          else
-            basename << '/'
-          end
-        else
-          type = Mime.mime_type(::File.extname(basename))
-          size = filesize_format(stat.size)
-        end
-
-        [ url, basename, size, type, mtime ]
-      end)
-
-      [ 200, { CONTENT_TYPE => 'text/html; charset=utf-8' }, body ]
-    end
-
-    # File::Stat for the given path, but return nil for missing/bad entries.
-    def stat(path)
-      ::File.stat(path)
-    rescue Errno::ENOENT, Errno::ELOOP
-      return nil
-    end
-
-    # Rack response to use for files and directories under the root.
-    # Unreadable and non-file, non-directory entries will get a 404 response.
-    def list_path(env, path, path_info, script_name)
-      if (stat = stat(path)) && stat.readable?
-        return @app.call(env) if stat.file?
-        return list_directory(path_info, path, script_name) if stat.directory?
-      end
-
-      entity_not_found(path_info)
-    end
-
-    # Rack response to use for unreadable and non-file, non-directory entries.
-    def entity_not_found(path_info)
-      body = "Entity not found: #{path_info}\n"
-      [404, { CONTENT_TYPE => "text/plain",
-        CONTENT_LENGTH => body.bytesize.to_s,
-        "X-Cascade" => "pass" }, [body]]
-    end
-
-    # Stolen from Ramaze
-    FILESIZE_FORMAT = [
-      ['%.1fT', 1 << 40],
-      ['%.1fG', 1 << 30],
-      ['%.1fM', 1 << 20],
-      ['%.1fK', 1 << 10],
-    ]
-
-    # Provide human readable file sizes
-    def filesize_format(int)
-      FILESIZE_FORMAT.each do |format, size|
-        return format % (int.to_f / size) if int >= size
-      end
-
-      "#{int}B"
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rack-2.2.4/lib/rack/etag.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../rack'
-require 'digest/sha2'
-
-module Rack
-  # Automatically sets the ETag header on all String bodies.
-  #
-  # The ETag header is skipped if ETag or Last-Modified headers are sent or if
-  # a sendfile body (body.responds_to :to_path) is given (since such cases
-  # should be handled by apache/nginx).
-  #
-  # On initialization, you can pass two parameters: a Cache-Control directive
-  # used when Etag is absent and a directive when it is present. The first
-  # defaults to nil, while the second defaults to "max-age=0, private, must-revalidate"
-  class ETag
-    ETAG_STRING = Rack::ETAG
-    DEFAULT_CACHE_CONTROL = "max-age=0, private, must-revalidate"
-
-    def initialize(app, no_cache_control = nil, cache_control = DEFAULT_CACHE_CONTROL)
-      @app = app
-      @cache_control = cache_control
-      @no_cache_control = no_cache_control
-    end
-
-    def call(env)
-      status, headers, body = @app.call(env)
-
-      headers = Utils::HeaderHash[headers]
-
-      if etag_status?(status) && etag_body?(body) && !skip_caching?(headers)
-        original_body = body
-        digest, new_body = digest_body(body)
-        body = Rack::BodyProxy.new(new_body) do
-          original_body.close if original_body.respond_to?(:close)
-        end
-        headers[ETAG_STRING] = %(W/"#{digest}") if digest
-      end
-
-      unless headers[CACHE_CONTROL]
-        if digest
-          headers[CACHE_CONTROL] = @cache_control if @cache_control
-        else
-          headers[CACHE_CONTROL] = @no_cache_control if @no_cache_control
-        end
-      end
-
-      [status, headers, body]
-    end
-
-    private
-
-      def etag_status?(status)
-        status == 200 || status == 201
-      end
-
-      def etag_body?(body)
-        !body.respond_to?(:to_path)
-      end
-
-      def skip_caching?(headers)
-        headers.key?(ETAG_STRING) || headers.key?('Last-Modified')
-      end
-
-      def digest_body(body)
-        parts = []
-        digest = nil
-
-        body.each do |part|
-          parts << part
-          (digest ||= Digest::SHA256.new) << part unless part.empty?
-        end
-
-        [digest && digest.hexdigest.byteslice(0, 32), parts]
-      end
-  end
-end