diy_rails 0.1.0 → 0.1.1

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

@@ -1,318 +0,0 @@
-# frozen_string_literal: true
-
-require 'time'
-
-module Rack
-  # Rack::Response provides a convenient interface to create a Rack
-  # response.
-  #
-  # It allows setting of headers and cookies, and provides useful
-  # defaults (an OK response with empty headers and body).
-  #
-  # You can use Response#write to iteratively generate your response,
-  # but note that this is buffered by Rack::Response until you call
-  # +finish+.  +finish+ however can take a block inside which calls to
-  # +write+ are synchronous with the Rack response.
-  #
-  # Your application's +call+ should end returning Response#finish.
-  class Response
-    def self.[](status, headers, body)
-      self.new(body, status, headers)
-    end
-
-    CHUNKED = 'chunked'
-    STATUS_WITH_NO_ENTITY_BODY = Utils::STATUS_WITH_NO_ENTITY_BODY
-
-    attr_accessor :length, :status, :body
-    attr_reader :headers
-
-    # @deprecated Use {#headers} instead.
-    alias header headers
-
-    # Initialize the response object with the specified body, status
-    # and headers.
-    #
-    # @param body [nil, #each, #to_str] the response body.
-    # @param status [Integer] the integer status as defined by the
-    # HTTP protocol RFCs.
-    # @param headers [#each] a list of key-value header pairs which
-    # conform to the HTTP protocol RFCs.
-    #
-    # Providing a body which responds to #to_str is legacy behaviour.
-    def initialize(body = nil, status = 200, headers = {})
-      @status = status.to_i
-      @headers = Utils::HeaderHash[headers]
-
-      @writer = self.method(:append)
-
-      @block = nil
-
-      # Keep track of whether we have expanded the user supplied body.
-      if body.nil?
-        @body = []
-        @buffered = true
-        @length = 0
-      elsif body.respond_to?(:to_str)
-        @body = [body]
-        @buffered = true
-        @length = body.to_str.bytesize
-      else
-        @body = body
-        @buffered = false
-        @length = 0
-      end
-
-      yield self if block_given?
-    end
-
-    def redirect(target, status = 302)
-      self.status = status
-      self.location = target
-    end
-
-    def chunked?
-      CHUNKED == get_header(TRANSFER_ENCODING)
-    end
-
-    # Generate a response array consistent with the requirements of the SPEC.
-    # @return [Array] a 3-tuple suitable of `[status, headers, body]`
-    # which is suitable to be returned from the middleware `#call(env)` method.
-    def finish(&block)
-      if STATUS_WITH_NO_ENTITY_BODY[status.to_i]
-        delete_header CONTENT_TYPE
-        delete_header CONTENT_LENGTH
-        close
-        return [@status, @headers, []]
-      else
-        if block_given?
-          @block = block
-          return [@status, @headers, self]
-        else
-          return [@status, @headers, @body]
-        end
-      end
-    end
-
-    alias to_a finish           # For *response
-
-    def each(&callback)
-      @body.each(&callback)
-      @buffered = true
-
-      if @block
-        @writer = callback
-        @block.call(self)
-      end
-    end
-
-    # Append to body and update Content-Length.
-    #
-    # NOTE: Do not mix #write and direct #body access!
-    #
-    def write(chunk)
-      buffered_body!
-
-      @writer.call(chunk.to_s)
-    end
-
-    def close
-      @body.close if @body.respond_to?(:close)
-    end
-
-    def empty?
-      @block == nil && @body.empty?
-    end
-
-    def has_header?(key);   headers.key? key;   end
-    def get_header(key);    headers[key];       end
-    def set_header(key, v); headers[key] = v;   end
-    def delete_header(key); headers.delete key; end
-
-    alias :[] :get_header
-    alias :[]= :set_header
-
-    module Helpers
-      def invalid?;             status < 100 || status >= 600;        end
-
-      def informational?;       status >= 100 && status < 200;        end
-      def successful?;          status >= 200 && status < 300;        end
-      def redirection?;         status >= 300 && status < 400;        end
-      def client_error?;        status >= 400 && status < 500;        end
-      def server_error?;        status >= 500 && status < 600;        end
-
-      def ok?;                  status == 200;                        end
-      def created?;             status == 201;                        end
-      def accepted?;            status == 202;                        end
-      def no_content?;          status == 204;                        end
-      def moved_permanently?;   status == 301;                        end
-      def bad_request?;         status == 400;                        end
-      def unauthorized?;        status == 401;                        end
-      def forbidden?;           status == 403;                        end
-      def not_found?;           status == 404;                        end
-      def method_not_allowed?;  status == 405;                        end
-      def precondition_failed?; status == 412;                        end
-      def unprocessable?;       status == 422;                        end
-
-      def redirect?;            [301, 302, 303, 307, 308].include? status; end
-
-      def include?(header)
-        has_header? header
-      end
-
-      # Add a header that may have multiple values.
-      #
-      # Example:
-      #   response.add_header 'Vary', 'Accept-Encoding'
-      #   response.add_header 'Vary', 'Cookie'
-      #
-      #   assert_equal 'Accept-Encoding,Cookie', response.get_header('Vary')
-      #
-      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2
-      def add_header(key, v)
-        if v.nil?
-          get_header key
-        elsif has_header? key
-          set_header key, "#{get_header key},#{v}"
-        else
-          set_header key, v
-        end
-      end
-
-      # Get the content type of the response.
-      def content_type
-        get_header CONTENT_TYPE
-      end
-
-      # Set the content type of the response.
-      def content_type=(content_type)
-        set_header CONTENT_TYPE, content_type
-      end
-
-      def media_type
-        MediaType.type(content_type)
-      end
-
-      def media_type_params
-        MediaType.params(content_type)
-      end
-
-      def content_length
-        cl = get_header CONTENT_LENGTH
-        cl ? cl.to_i : cl
-      end
-
-      def location
-        get_header "Location"
-      end
-
-      def location=(location)
-        set_header "Location", location
-      end
-
-      def set_cookie(key, value)
-        cookie_header = get_header SET_COOKIE
-        set_header SET_COOKIE, ::Rack::Utils.add_cookie_to_header(cookie_header, key, value)
-      end
-
-      def delete_cookie(key, value = {})
-        set_header SET_COOKIE, ::Rack::Utils.add_remove_cookie_to_header(get_header(SET_COOKIE), key, value)
-      end
-
-      def set_cookie_header
-        get_header SET_COOKIE
-      end
-
-      def set_cookie_header=(v)
-        set_header SET_COOKIE, v
-      end
-
-      def cache_control
-        get_header CACHE_CONTROL
-      end
-
-      def cache_control=(v)
-        set_header CACHE_CONTROL, v
-      end
-
-      # Specifies that the content shouldn't be cached. Overrides `cache!` if already called.
-      def do_not_cache!
-        set_header CACHE_CONTROL, "no-cache, must-revalidate"
-        set_header EXPIRES, Time.now.httpdate
-      end
-
-      # Specify that the content should be cached.
-      # @param duration [Integer] The number of seconds until the cache expires.
-      # @option directive [String] The cache control directive, one of "public", "private", "no-cache" or "no-store".
-      def cache!(duration = 3600, directive: "public")
-        unless headers[CACHE_CONTROL] =~ /no-cache/
-          set_header CACHE_CONTROL, "#{directive}, max-age=#{duration}"
-          set_header EXPIRES, (Time.now + duration).httpdate
-        end
-      end
-
-      def etag
-        get_header ETAG
-      end
-
-      def etag=(v)
-        set_header ETAG, v
-      end
-
-    protected
-
-      def buffered_body!
-        return if @buffered
-
-        if @body.is_a?(Array)
-          # The user supplied body was an array:
-          @body = @body.compact
-          @body.each do |part|
-            @length += part.to_s.bytesize
-          end
-        else
-          # Turn the user supplied body into a buffered array:
-          body = @body
-          @body = Array.new
-
-          body.each do |part|
-            @writer.call(part.to_s)
-          end
-
-          body.close if body.respond_to?(:close)
-        end
-
-        @buffered = true
-      end
-
-      def append(chunk)
-        @body << chunk
-
-        unless chunked?
-          @length += chunk.bytesize
-          set_header(CONTENT_LENGTH, @length.to_s)
-        end
-
-        return chunk
-      end
-    end
-
-    include Helpers
-
-    class Raw
-      include Helpers
-
-      attr_reader :headers
-      attr_accessor :status
-
-      def initialize(status, headers)
-        @status = status
-        @headers = headers
-      end
-
-      def has_header?(key);   headers.key? key;   end
-      def get_header(key);    headers[key];       end
-      def set_header(key, v); headers[key] = v;   end
-      def delete_header(key); headers.delete key; end
-    end
-  end
-end

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

@@ -1,94 +0,0 @@
-# -*- encoding: binary -*-
-# frozen_string_literal: true
-
-require 'tempfile'
-
-module Rack
-  # Class which can make any IO object rewindable, including non-rewindable ones. It does
-  # this by buffering the data into a tempfile, which is rewindable.
-  #
-  # rack.input is required to be rewindable, so if your input stream IO is non-rewindable
-  # by nature (e.g. a pipe or a socket) then you can wrap it in an object of this class
-  # to easily make it rewindable.
-  #
-  # Don't forget to call #close when you're done. This frees up temporary resources that
-  # RewindableInput uses, though it does *not* close the original IO object.
-  class RewindableInput
-    def initialize(io)
-      @io = io
-      @rewindable_io = nil
-      @unlinked = false
-    end
-
-    def gets
-      make_rewindable unless @rewindable_io
-      @rewindable_io.gets
-    end
-
-    def read(*args)
-      make_rewindable unless @rewindable_io
-      @rewindable_io.read(*args)
-    end
-
-    def each(&block)
-      make_rewindable unless @rewindable_io
-      @rewindable_io.each(&block)
-    end
-
-    def rewind
-      make_rewindable unless @rewindable_io
-      @rewindable_io.rewind
-    end
-
-    # Closes this RewindableInput object without closing the originally
-    # wrapped IO object. Cleans up any temporary resources that this RewindableInput
-    # has created.
-    #
-    # This method may be called multiple times. It does nothing on subsequent calls.
-    def close
-      if @rewindable_io
-        if @unlinked
-          @rewindable_io.close
-        else
-          @rewindable_io.close!
-        end
-        @rewindable_io = nil
-      end
-    end
-
-    private
-
-    def make_rewindable
-      # Buffer all data into a tempfile. Since this tempfile is private to this
-      # RewindableInput object, we chmod it so that nobody else can read or write
-      # it. On POSIX filesystems we also unlink the file so that it doesn't
-      # even have a file entry on the filesystem anymore, though we can still
-      # access it because we have the file handle open.
-      @rewindable_io = Tempfile.new('RackRewindableInput')
-      @rewindable_io.chmod(0000)
-      @rewindable_io.set_encoding(Encoding::BINARY) if @rewindable_io.respond_to?(:set_encoding)
-      @rewindable_io.binmode
-      if filesystem_has_posix_semantics?
-        raise 'Unlink failed. IO closed.' if @rewindable_io.closed?
-        @unlinked = true
-      end
-
-      buffer = "".dup
-      while @io.read(1024 * 4, buffer)
-        entire_buffer_written_out = false
-        while !entire_buffer_written_out
-          written = @rewindable_io.write(buffer)
-          entire_buffer_written_out = written == buffer.bytesize
-          if !entire_buffer_written_out
-            buffer.slice!(0 .. written - 1)
-          end
-        end
-      end
-      @rewindable_io.rewind
-    end
-
-    def filesystem_has_posix_semantics?
-      RUBY_PLATFORM !~ /(mswin|mingw|cygwin|java)/
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  # Sets an "X-Runtime" response header, indicating the response
-  # time of the request, in seconds
-  #
-  # You can put it right before the application to see the processing
-  # time, or before all the other middlewares to include time for them,
-  # too.
-  class Runtime
-    FORMAT_STRING = "%0.6f" # :nodoc:
-    HEADER_NAME = "X-Runtime" # :nodoc:
-
-    def initialize(app, name = nil)
-      @app = app
-      @header_name = HEADER_NAME
-      @header_name += "-#{name}" if name
-    end
-
-    def call(env)
-      start_time = Utils.clock_time
-      status, headers, body = @app.call(env)
-      headers = Utils::HeaderHash[headers]
-
-      request_time = Utils.clock_time - start_time
-
-      unless headers.key?(@header_name)
-        headers[@header_name] = FORMAT_STRING % request_time
-      end
-
-      [status, headers, body]
-    end
-  end
-end

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

@@ -1,162 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-
-  # = Sendfile
-  #
-  # The Sendfile middleware intercepts responses whose body is being
-  # served from a file and replaces it with a server specific X-Sendfile
-  # header. The web server is then responsible for writing the file contents
-  # to the client. This can dramatically reduce the amount of work required
-  # by the Ruby backend and takes advantage of the web server's optimized file
-  # delivery code.
-  #
-  # In order to take advantage of this middleware, the response body must
-  # respond to +to_path+ and the request must include an X-Sendfile-Type
-  # header. Rack::Files and other components implement +to_path+ so there's
-  # rarely anything you need to do in your application. The X-Sendfile-Type
-  # header is typically set in your web servers configuration. The following
-  # sections attempt to document
-  #
-  # === Nginx
-  #
-  # Nginx supports the X-Accel-Redirect header. This is similar to X-Sendfile
-  # but requires parts of the filesystem to be mapped into a private URL
-  # hierarchy.
-  #
-  # The following example shows the Nginx configuration required to create
-  # a private "/files/" area, enable X-Accel-Redirect, and pass the special
-  # X-Sendfile-Type and X-Accel-Mapping headers to the backend:
-  #
-  #   location ~ /files/(.*) {
-  #     internal;
-  #     alias /var/www/$1;
-  #   }
-  #
-  #   location / {
-  #     proxy_redirect     off;
-  #
-  #     proxy_set_header   Host                $host;
-  #     proxy_set_header   X-Real-IP           $remote_addr;
-  #     proxy_set_header   X-Forwarded-For     $proxy_add_x_forwarded_for;
-  #
-  #     proxy_set_header   X-Sendfile-Type     X-Accel-Redirect;
-  #     proxy_set_header   X-Accel-Mapping     /var/www/=/files/;
-  #
-  #     proxy_pass         http://127.0.0.1:8080/;
-  #   }
-  #
-  # Note that the X-Sendfile-Type header must be set exactly as shown above.
-  # The X-Accel-Mapping header should specify the location on the file system,
-  # followed by an equals sign (=), followed name of the private URL pattern
-  # that it maps to. The middleware performs a simple substitution on the
-  # resulting path.
-  #
-  # See Also: https://www.nginx.com/resources/wiki/start/topics/examples/xsendfile
-  #
-  # === lighttpd
-  #
-  # Lighttpd has supported some variation of the X-Sendfile header for some
-  # time, although only recent version support X-Sendfile in a reverse proxy
-  # configuration.
-  #
-  #   $HTTP["host"] == "example.com" {
-  #      proxy-core.protocol = "http"
-  #      proxy-core.balancer = "round-robin"
-  #      proxy-core.backends = (
-  #        "127.0.0.1:8000",
-  #        "127.0.0.1:8001",
-  #        ...
-  #      )
-  #
-  #      proxy-core.allow-x-sendfile = "enable"
-  #      proxy-core.rewrite-request = (
-  #        "X-Sendfile-Type" => (".*" => "X-Sendfile")
-  #      )
-  #    }
-  #
-  # See Also: http://redmine.lighttpd.net/wiki/lighttpd/Docs:ModProxyCore
-  #
-  # === Apache
-  #
-  # X-Sendfile is supported under Apache 2.x using a separate module:
-  #
-  # https://tn123.org/mod_xsendfile/
-  #
-  # Once the module is compiled and installed, you can enable it using
-  # XSendFile config directive:
-  #
-  #   RequestHeader Set X-Sendfile-Type X-Sendfile
-  #   ProxyPassReverse / http://localhost:8001/
-  #   XSendFile on
-  #
-  # === Mapping parameter
-  #
-  # The third parameter allows for an overriding extension of the
-  # X-Accel-Mapping header. Mappings should be provided in tuples of internal to
-  # external. The internal values may contain regular expression syntax, they
-  # will be matched with case indifference.
-
-  class Sendfile
-    def initialize(app, variation = nil, mappings = [])
-      @app = app
-      @variation = variation
-      @mappings = mappings.map do |internal, external|
-        [/^#{internal}/i, external]
-      end
-    end
-
-    def call(env)
-      status, headers, body = @app.call(env)
-      if body.respond_to?(:to_path)
-        case type = variation(env)
-        when 'X-Accel-Redirect'
-          path = ::File.expand_path(body.to_path)
-          if url = map_accel_path(env, path)
-            headers[CONTENT_LENGTH] = '0'
-            # '?' must be percent-encoded because it is not query string but a part of path
-            headers[type] = ::Rack::Utils.escape_path(url).gsub('?', '%3F')
-            obody = body
-            body = Rack::BodyProxy.new([]) do
-              obody.close if obody.respond_to?(:close)
-            end
-          else
-            env[RACK_ERRORS].puts "X-Accel-Mapping header missing"
-          end
-        when 'X-Sendfile', 'X-Lighttpd-Send-File'
-          path = ::File.expand_path(body.to_path)
-          headers[CONTENT_LENGTH] = '0'
-          headers[type] = path
-          obody = body
-          body = Rack::BodyProxy.new([]) do
-            obody.close if obody.respond_to?(:close)
-          end
-        when '', nil
-        else
-          env[RACK_ERRORS].puts "Unknown x-sendfile variation: '#{type}'.\n"
-        end
-      end
-      [status, headers, body]
-    end
-
-    private
-    def variation(env)
-      @variation ||
-        env['sendfile.type'] ||
-        env['HTTP_X_SENDFILE_TYPE']
-    end
-
-    def map_accel_path(env, path)
-      if mapping = @mappings.find { |internal, _| internal =~ path }
-        path.sub(*mapping)
-      elsif mapping = env['HTTP_X_ACCEL_MAPPING']
-        mapping.split(',').map(&:strip).each do |m|
-          internal, external = m.split('=', 2).map(&:strip)
-          new_path = path.sub(/^#{internal}/i, external)
-          return new_path unless path == new_path
-        end
-        path
-      end
-    end
-  end
-end