tdiary 5.2.4 → 5.3.0

data/vendor/bundle/ruby/3.1.0/gems/rack-3.0.1/lib/rack/chunked.rb

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'constants'
-require_relative 'utils'
-
-module Rack
-  warn "Rack::Chunked is deprecated and will be removed in Rack 3.1", uplevel: 1
-
-  # Middleware that applies chunked transfer encoding to response bodies
-  # when the response does not include a content-length header.
-  #
-  # This supports the trailer response header to allow the use of trailing
-  # headers in the chunked encoding.  However, using this requires you manually
-  # specify a response body that supports a +trailers+ method.  Example:
-  #
-  #   [200, { 'trailer' => 'expires'}, ["Hello", "World"]]
-  #   # error raised
-  #
-  #   body = ["Hello", "World"]
-  #   def body.trailers
-  #     { 'expires' => Time.now.to_s }
-  #   end
-  #   [200, { 'trailer' => 'expires'}, body]
-  #   # No exception raised
-  class Chunked
-    include Rack::Utils
-
-    # A body wrapper that emits chunked responses.
-    class Body
-      TERM = "\r\n"
-      TAIL = "0#{TERM}"
-
-      # Store the response body to be chunked.
-      def initialize(body)
-        @body = body
-      end
-
-      # For each element yielded by the response body, yield
-      # the element in chunked encoding.
-      def each(&block)
-        term = TERM
-        @body.each do |chunk|
-          size = chunk.bytesize
-          next if size == 0
-
-          yield [size.to_s(16), term, chunk.b, term].join
-        end
-        yield TAIL
-        yield_trailers(&block)
-        yield term
-      end
-
-      # Close the response body if the response body supports it.
-      def close
-        @body.close if @body.respond_to?(:close)
-      end
-
-      private
-
-      # Do nothing as this class does not support trailer headers.
-      def yield_trailers
-      end
-    end
-
-    # A body wrapper that emits chunked responses and also supports
-    # sending Trailer headers.  Note that the response body provided to
-    # initialize must have a +trailers+ method that returns a hash
-    # of trailer headers, and the rack response itself should have a
-    # Trailer header listing the headers that the +trailers+ method
-    # will return.
-    class TrailerBody < Body
-      private
-
-      # Yield strings for each trailer header.
-      def yield_trailers
-        @body.trailers.each_pair do |k, v|
-          yield "#{k}: #{v}\r\n"
-        end
-      end
-    end
-
-    def initialize(app)
-      @app = app
-    end
-
-    # Whether the HTTP version supports chunked encoding (HTTP 1.1 does).
-    def chunkable_version?(ver)
-      case ver
-      # pre-HTTP/1.0 (informally "HTTP/0.9") HTTP requests did not have
-      # a version (nor response headers)
-      when 'HTTP/1.0', nil, 'HTTP/0.9'
-        false
-      else
-        true
-      end
-    end
-
-    # If the rack app returns a response that should have a body,
-    # but does not have content-length or transfer-encoding headers,
-    # modify the response to use chunked transfer-encoding.
-    def call(env)
-      status, headers, body = response = @app.call(env)
-
-      if chunkable_version?(env[SERVER_PROTOCOL]) &&
-         !STATUS_WITH_NO_ENTITY_BODY.key?(status.to_i) &&
-         !headers[CONTENT_LENGTH] &&
-         !headers[TRANSFER_ENCODING]
-
-        headers[TRANSFER_ENCODING] = 'chunked'
-        if headers['trailer']
-          response[2] = TrailerBody.new(body)
-        else
-          response[2] = Body.new(body)
-        end
-      end
-
-      response
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/rack-3.0.1/lib/rack/common_logger.rb

@@ -1,88 +0,0 @@
-# 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\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 = 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)
-
-      msg.gsub!(/[^[:print:]\n]/) { |c| sprintf("\\x%x", c.ord) }
-
-      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/bundle/ruby/3.1.0/gems/rack-3.0.1/lib/rack/conditional_get.rb

@@ -1,86 +0,0 @@
-# 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)
-          response[2] = Rack::BodyProxy.new([]) do
-            body.close if body.respond_to?(:close)
-          end
-        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/bundle/ruby/3.1.0/gems/rack-3.0.1/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.1.0/gems/rack-3.0.1/lib/rack/constants.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  # Request env keys
-  HTTP_HOST         = 'HTTP_HOST'
-  HTTP_PORT         = 'HTTP_PORT'
-  HTTPS             = 'HTTPS'
-  PATH_INFO         = 'PATH_INFO'
-  REQUEST_METHOD    = 'REQUEST_METHOD'
-  REQUEST_PATH      = 'REQUEST_PATH'
-  SCRIPT_NAME       = 'SCRIPT_NAME'
-  QUERY_STRING      = 'QUERY_STRING'
-  SERVER_PROTOCOL   = 'SERVER_PROTOCOL'
-  SERVER_NAME       = 'SERVER_NAME'
-  SERVER_PORT       = 'SERVER_PORT'
-  HTTP_COOKIE       = 'HTTP_COOKIE'
-  
-  # Response Header Keys
-  CACHE_CONTROL     = 'cache-control'
-  CONTENT_LENGTH    = 'content-length'
-  CONTENT_TYPE      = 'content-type'
-  ETAG              = 'etag'
-  EXPIRES           = 'expires'
-  SET_COOKIE        = 'set-cookie'
-  TRANSFER_ENCODING = 'transfer-encoding'
-
-  # HTTP method verbs
-  GET     = 'GET'
-  POST    = 'POST'
-  PUT     = 'PUT'
-  PATCH   = 'PATCH'
-  DELETE  = 'DELETE'
-  HEAD    = 'HEAD'
-  OPTIONS = 'OPTIONS'
-  LINK    = 'LINK'
-  UNLINK  = 'UNLINK'
-  TRACE   = 'TRACE'
-
-  # Rack environment variables
-  RACK_VERSION                        = 'rack.version'
-  RACK_TEMPFILES                      = 'rack.tempfiles'
-  RACK_ERRORS                         = 'rack.errors'
-  RACK_LOGGER                         = 'rack.logger'
-  RACK_INPUT                          = 'rack.input'
-  RACK_SESSION                        = 'rack.session'
-  RACK_SESSION_OPTIONS                = 'rack.session.options'
-  RACK_SHOWSTATUS_DETAIL              = 'rack.showstatus.detail'
-  RACK_URL_SCHEME                     = 'rack.url_scheme'
-  RACK_HIJACK                         = 'rack.hijack'
-  RACK_IS_HIJACK                      = 'rack.hijack?'
-  RACK_RECURSIVE_INCLUDE              = 'rack.recursive.include'
-  RACK_MULTIPART_BUFFER_SIZE          = 'rack.multipart.buffer_size'
-  RACK_MULTIPART_TEMPFILE_FACTORY     = 'rack.multipart.tempfile_factory'
-  RACK_RESPONSE_FINISHED              = 'rack.response_finished'
-  RACK_REQUEST_FORM_INPUT             = 'rack.request.form_input'
-  RACK_REQUEST_FORM_HASH              = 'rack.request.form_hash'
-  RACK_REQUEST_FORM_VARS              = 'rack.request.form_vars'
-  RACK_REQUEST_COOKIE_HASH            = 'rack.request.cookie_hash'
-  RACK_REQUEST_COOKIE_STRING          = 'rack.request.cookie_string'
-  RACK_REQUEST_QUERY_HASH             = 'rack.request.query_hash'
-  RACK_REQUEST_QUERY_STRING           = 'rack.request.query_string'
-  RACK_METHODOVERRIDE_ORIGINAL_METHOD = 'rack.methodoverride.original_method'
-end

data/vendor/bundle/ruby/3.1.0/gems/rack-3.0.1/lib/rack/content_length.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'constants'
-require_relative 'utils'
-
-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 = response = @app.call(env)
-
-      if !STATUS_WITH_NO_ENTITY_BODY.key?(status.to_i) &&
-         !headers[CONTENT_LENGTH] &&
-         !headers[TRANSFER_ENCODING] &&
-         body.respond_to?(:to_ary)
-
-        response[2] = body = body.to_ary
-        headers[CONTENT_LENGTH] = body.sum(&:bytesize).to_s
-      end
-
-      response
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/rack-3.0.1/lib/rack/content_type.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'constants'
-require_relative 'utils'
-
-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 = app
-      @content_type = content_type
-    end
-
-    def call(env)
-      status, headers, _ = response = @app.call(env)
-
-      unless STATUS_WITH_NO_ENTITY_BODY.key?(status.to_i)
-        headers[CONTENT_TYPE] ||= @content_type
-      end
-
-      response
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/rack-3.0.1/lib/rack/deflater.rb

@@ -1,158 +0,0 @@
-# frozen_string_literal: true
-
-require "zlib"
-require "time"  # for Time.httpdate
-
-require_relative 'constants'
-require_relative 'utils'
-require_relative 'request'
-require_relative 'body_proxy'
-
-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
-    # 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 = response = @app.call(env)
-
-      unless should_deflate?(env, status, headers, body)
-        return response
-      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.any?{|v| v.downcase == '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
-        response[2] = GzipStream.new(body, mtime, @sync)
-        response
-      when "identity"
-        response
-      else # when nil
-        # Only possible encoding values here are 'gzip', 'identity', and 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
-
-      BUFFER_LENGTH = 128 * 1_024
-
-      # 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 is equivalent to @body.gets (slow)
-        if @body.is_a? ::File # XXX: Should probably be ::IO
-          while part = @body.read(BUFFER_LENGTH)
-            gzip.write(part)
-            gzip.flush if @sync
-          end
-        else
-          @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
-          }
-        end
-      ensure
-        gzip.finish
-      end
-
-      # Call the block passed to #each with 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