tdiary 5.2.2 → 5.2.4

data/vendor/bundle/ruby/3.1.0/gems/rack-2.2.3.1/lib/rack/events.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  ### This middleware provides hooks to certain places in the request /
-  # response lifecycle.  This is so that middleware that don't need to filter
-  # the response data can safely leave it alone and not have to send messages
-  # down the traditional "rack stack".
-  #
-  # The events are:
-  #
-  # * on_start(request, response)
-  #
-  #   This event is sent at the start of the request, before the next
-  #   middleware in the chain is called.  This method is called with a request
-  #   object, and a response object.  Right now, the response object is always
-  #   nil, but in the future it may actually be a real response object.
-  #
-  # * on_commit(request, response)
-  #
-  #   The response has been committed.  The application has returned, but the
-  #   response has not been sent to the webserver yet.  This method is always
-  #   called with a request object and the response object.  The response
-  #   object is constructed from the rack triple that the application returned.
-  #   Changes may still be made to the response object at this point.
-  #
-  # * on_send(request, response)
-  #
-  #   The webserver has started iterating over the response body and presumably
-  #   has started sending data over the wire. This method is always called with
-  #   a request object and the response object.  The response object is
-  #   constructed from the rack triple that the application returned.  Changes
-  #   SHOULD NOT be made to the response object as the webserver has already
-  #   started sending data.  Any mutations will likely result in an exception.
-  #
-  # * on_finish(request, response)
-  #
-  #   The webserver has closed the response, and all data has been written to
-  #   the response socket.  The request and response object should both be
-  #   read-only at this point.  The body MAY NOT be available on the response
-  #   object as it may have been flushed to the socket.
-  #
-  # * on_error(request, response, error)
-  #
-  #   An exception has occurred in the application or an `on_commit` event.
-  #   This method will get the request, the response (if available) and the
-  #   exception that was raised.
-  #
-  # ## Order
-  #
-  # `on_start` is called on the handlers in the order that they were passed to
-  # the constructor.  `on_commit`, on_send`, `on_finish`, and `on_error` are
-  # called in the reverse order.  `on_finish` handlers are called inside an
-  # `ensure` block, so they are guaranteed to be called even if something
-  # raises an exception.  If something raises an exception in a `on_finish`
-  # method, then nothing is guaranteed.
-
-  class Events
-    module Abstract
-      def on_start(req, res)
-      end
-
-      def on_commit(req, res)
-      end
-
-      def on_send(req, res)
-      end
-
-      def on_finish(req, res)
-      end
-
-      def on_error(req, res, e)
-      end
-    end
-
-    class EventedBodyProxy < Rack::BodyProxy # :nodoc:
-      attr_reader :request, :response
-
-      def initialize(body, request, response, handlers, &block)
-        super(body, &block)
-        @request  = request
-        @response = response
-        @handlers = handlers
-      end
-
-      def each
-        @handlers.reverse_each { |handler| handler.on_send request, response }
-        super
-      end
-    end
-
-    class BufferedResponse < Rack::Response::Raw # :nodoc:
-      attr_reader :body
-
-      def initialize(status, headers, body)
-        super(status, headers)
-        @body = body
-      end
-
-      def to_a; [status, headers, body]; end
-    end
-
-    def initialize(app, handlers)
-      @app      = app
-      @handlers = handlers
-    end
-
-    def call(env)
-      request = make_request env
-      on_start request, nil
-
-      begin
-        status, headers, body = @app.call request.env
-        response = make_response status, headers, body
-        on_commit request, response
-      rescue StandardError => e
-        on_error request, response, e
-        on_finish request, response
-        raise
-      end
-
-      body = EventedBodyProxy.new(body, request, response, @handlers) do
-        on_finish request, response
-      end
-      [response.status, response.headers, body]
-    end
-
-    private
-
-    def on_error(request, response, e)
-      @handlers.reverse_each { |handler| handler.on_error request, response, e }
-    end
-
-    def on_commit(request, response)
-      @handlers.reverse_each { |handler| handler.on_commit request, response }
-    end
-
-    def on_start(request, response)
-      @handlers.each { |handler| handler.on_start request, nil }
-    end
-
-    def on_finish(request, response)
-      @handlers.reverse_each { |handler| handler.on_finish request, response }
-    end
-
-    def make_request(env)
-      Rack::Request.new env
-    end
-
-    def make_response(status, headers, body)
-      BufferedResponse.new status, headers, body
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/rack-2.2.3.1/lib/rack/file.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'files'
-
-module Rack
-  File = Files
-end

data/vendor/bundle/ruby/3.1.0/gems/rack-2.2.3.1/lib/rack/files.rb

@@ -1,218 +0,0 @@
-# frozen_string_literal: true
-
-require 'time'
-
-module Rack
-  # Rack::Files serves files below the +root+ directory given, according to the
-  # path info of the Rack request.
-  # e.g. when Rack::Files.new("/etc") is used, you can access 'passwd' file
-  # as http://localhost:9292/passwd
-  #
-  # Handlers can detect if bodies are a Rack::Files, and use mechanisms
-  # like sendfile on the +path+.
-
-  class Files
-    ALLOWED_VERBS = %w[GET HEAD OPTIONS]
-    ALLOW_HEADER = ALLOWED_VERBS.join(', ')
-    MULTIPART_BOUNDARY = 'AaB03x'
-
-    # @todo remove in 3.0
-    def self.method_added(name)
-      if name == :response_body
-        raise "#{self.class}\#response_body is no longer supported."
-      end
-      super
-    end
-
-    attr_reader :root
-
-    def initialize(root, headers = {}, default_mime = 'text/plain')
-      @root = (::File.expand_path(root) if root)
-      @headers = headers
-      @default_mime = default_mime
-      @head = Rack::Head.new(lambda { |env| get env })
-    end
-
-    def call(env)
-      # HEAD requests drop the response body, including 4xx error messages.
-      @head.call env
-    end
-
-    def get(env)
-      request = Rack::Request.new env
-      unless ALLOWED_VERBS.include? request.request_method
-        return fail(405, "Method Not Allowed", { 'Allow' => ALLOW_HEADER })
-      end
-
-      path_info = Utils.unescape_path request.path_info
-      return fail(400, "Bad Request") unless Utils.valid_path?(path_info)
-
-      clean_path_info = Utils.clean_path_info(path_info)
-      path = ::File.join(@root, clean_path_info)
-
-      available = begin
-        ::File.file?(path) && ::File.readable?(path)
-      rescue SystemCallError
-        # Not sure in what conditions this exception can occur, but this
-        # is a safe way to handle such an error.
-        # :nocov:
-        false
-        # :nocov:
-      end
-
-      if available
-        serving(request, path)
-      else
-        fail(404, "File not found: #{path_info}")
-      end
-    end
-
-    def serving(request, path)
-      if request.options?
-        return [200, { 'Allow' => ALLOW_HEADER, CONTENT_LENGTH => '0' }, []]
-      end
-      last_modified = ::File.mtime(path).httpdate
-      return [304, {}, []] if request.get_header('HTTP_IF_MODIFIED_SINCE') == last_modified
-
-      headers = { "Last-Modified" => last_modified }
-      mime_type = mime_type path, @default_mime
-      headers[CONTENT_TYPE] = mime_type if mime_type
-
-      # Set custom headers
-      headers.merge!(@headers) if @headers
-
-      status = 200
-      size = filesize path
-
-      ranges = Rack::Utils.get_byte_ranges(request.get_header('HTTP_RANGE'), size)
-      if ranges.nil?
-        # No ranges:
-        ranges = [0..size - 1]
-      elsif ranges.empty?
-        # Unsatisfiable. Return error, and file size:
-        response = fail(416, "Byte range unsatisfiable")
-        response[1]["Content-Range"] = "bytes */#{size}"
-        return response
-      elsif ranges.size >= 1
-        # Partial content
-        partial_content = true
-
-        if ranges.size == 1
-          range = ranges[0]
-          headers["Content-Range"] = "bytes #{range.begin}-#{range.end}/#{size}"
-        else
-          headers[CONTENT_TYPE] = "multipart/byteranges; boundary=#{MULTIPART_BOUNDARY}"
-        end
-
-        status = 206
-        body = BaseIterator.new(path, ranges, mime_type: mime_type, size: size)
-        size = body.bytesize
-      end
-
-      headers[CONTENT_LENGTH] = size.to_s
-
-      if request.head?
-        body = []
-      elsif !partial_content
-        body = Iterator.new(path, ranges, mime_type: mime_type, size: size)
-      end
-
-      [status, headers, body]
-    end
-
-    class BaseIterator
-      attr_reader :path, :ranges, :options
-
-      def initialize(path, ranges, options)
-        @path = path
-        @ranges = ranges
-        @options = options
-      end
-
-      def each
-        ::File.open(path, "rb") do |file|
-          ranges.each do |range|
-            yield multipart_heading(range) if multipart?
-
-            each_range_part(file, range) do |part|
-              yield part
-            end
-          end
-
-          yield "\r\n--#{MULTIPART_BOUNDARY}--\r\n" if multipart?
-        end
-      end
-
-      def bytesize
-        size = ranges.inject(0) do |sum, range|
-          sum += multipart_heading(range).bytesize if multipart?
-          sum += range.size
-        end
-        size += "\r\n--#{MULTIPART_BOUNDARY}--\r\n".bytesize if multipart?
-        size
-      end
-
-      def close; end
-
-      private
-
-      def multipart?
-        ranges.size > 1
-      end
-
-      def multipart_heading(range)
-<<-EOF
-\r
---#{MULTIPART_BOUNDARY}\r
-Content-Type: #{options[:mime_type]}\r
-Content-Range: bytes #{range.begin}-#{range.end}/#{options[:size]}\r
-\r
-EOF
-      end
-
-      def each_range_part(file, range)
-        file.seek(range.begin)
-        remaining_len = range.end - range.begin + 1
-        while remaining_len > 0
-          part = file.read([8192, remaining_len].min)
-          break unless part
-          remaining_len -= part.length
-
-          yield part
-        end
-      end
-    end
-
-    class Iterator < BaseIterator
-      alias :to_path :path
-    end
-
-    private
-
-    def fail(status, body, headers = {})
-      body += "\n"
-
-      [
-        status,
-        {
-          CONTENT_TYPE   => "text/plain",
-          CONTENT_LENGTH => body.size.to_s,
-          "X-Cascade" => "pass"
-        }.merge!(headers),
-        [body]
-      ]
-    end
-
-    # The MIME type for the contents of the file located at @path
-    def mime_type(path, default_mime)
-      Mime.mime_type(::File.extname(path), default_mime)
-    end
-
-    def filesize(path)
-      #   We check via File::size? whether this file provides size info
-      #   via stat (e.g. /proc files often don't), otherwise we have to
-      #   figure it out by reading the whole file into memory.
-      ::File.size?(path) || ::File.read(path).bytesize
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/rack-2.2.3.1/lib/rack/handler/cgi.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  module Handler
-    class CGI
-      def self.run(app, **options)
-        $stdin.binmode
-        serve app
-      end
-
-      def self.serve(app)
-        env = ENV.to_hash
-        env.delete "HTTP_CONTENT_LENGTH"
-
-        env[SCRIPT_NAME] = ""  if env[SCRIPT_NAME] == "/"
-
-        env.update(
-          RACK_VERSION      => Rack::VERSION,
-          RACK_INPUT        => Rack::RewindableInput.new($stdin),
-          RACK_ERRORS       => $stderr,
-          RACK_MULTITHREAD  => false,
-          RACK_MULTIPROCESS => true,
-          RACK_RUNONCE      => true,
-          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(ENV[HTTPS]) ? "https" : "http"
-        )
-
-        env[QUERY_STRING] ||= ""
-        env[HTTP_VERSION] ||= env[SERVER_PROTOCOL]
-        env[REQUEST_PATH] ||= "/"
-
-        status, headers, body = app.call(env)
-        begin
-          send_headers status, headers
-          send_body body
-        ensure
-          body.close  if body.respond_to? :close
-        end
-      end
-
-      def self.send_headers(status, headers)
-        $stdout.print "Status: #{status}\r\n"
-        headers.each { |k, vs|
-          vs.split("\n").each { |v|
-            $stdout.print "#{k}: #{v}\r\n"
-          }
-        }
-        $stdout.print "\r\n"
-        $stdout.flush
-      end
-
-      def self.send_body(body)
-        body.each { |part|
-          $stdout.print part
-          $stdout.flush
-        }
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/rack-2.2.3.1/lib/rack/handler/fastcgi.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require 'fcgi'
-require 'socket'
-
-if defined? FCGI::Stream
-  class FCGI::Stream
-    alias _rack_read_without_buffer read
-
-    def read(n, buffer = nil)
-      buf = _rack_read_without_buffer n
-      buffer.replace(buf.to_s)  if buffer
-      buf
-    end
-  end
-end
-
-module Rack
-  module Handler
-    class FastCGI
-      def self.run(app, **options)
-        if options[:File]
-          STDIN.reopen(UNIXServer.new(options[:File]))
-        elsif options[:Port]
-          STDIN.reopen(TCPServer.new(options[:Host], options[:Port]))
-        end
-        FCGI.each { |request|
-          serve request, app
-        }
-      end
-
-      def self.valid_options
-        environment  = ENV['RACK_ENV'] || 'development'
-        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
-
-        {
-          "Host=HOST" => "Hostname to listen on (default: #{default_host})",
-          "Port=PORT" => "Port to listen on (default: 8080)",
-          "File=PATH" => "Creates a Domain socket at PATH instead of a TCP socket. Ignores Host and Port if set.",
-        }
-      end
-
-      def self.serve(request, app)
-        env = request.env
-        env.delete "HTTP_CONTENT_LENGTH"
-
-        env[SCRIPT_NAME] = ""  if env[SCRIPT_NAME] == "/"
-
-        rack_input = RewindableInput.new(request.in)
-
-        env.update(
-          RACK_VERSION      => Rack::VERSION,
-          RACK_INPUT        => rack_input,
-          RACK_ERRORS       => request.err,
-          RACK_MULTITHREAD  => false,
-          RACK_MULTIPROCESS => true,
-          RACK_RUNONCE      => false,
-          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(env[HTTPS]) ? "https" : "http"
-        )
-
-        env[QUERY_STRING] ||= ""
-        env[HTTP_VERSION] ||= env[SERVER_PROTOCOL]
-        env[REQUEST_PATH] ||= "/"
-        env.delete "CONTENT_TYPE"  if env["CONTENT_TYPE"] == ""
-        env.delete "CONTENT_LENGTH"  if env["CONTENT_LENGTH"] == ""
-
-        begin
-          status, headers, body = app.call(env)
-          begin
-            send_headers request.out, status, headers
-            send_body request.out, body
-          ensure
-            body.close  if body.respond_to? :close
-          end
-        ensure
-          rack_input.close
-          request.finish
-        end
-      end
-
-      def self.send_headers(out, status, headers)
-        out.print "Status: #{status}\r\n"
-        headers.each { |k, vs|
-          vs.split("\n").each { |v|
-            out.print "#{k}: #{v}\r\n"
-          }
-        }
-        out.print "\r\n"
-        out.flush
-      end
-
-      def self.send_body(out, body)
-        body.each { |part|
-          out.print part
-          out.flush
-        }
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/rack-2.2.3.1/lib/rack/handler/lsws.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require 'lsapi'
-
-module Rack
-  module Handler
-    class LSWS
-      def self.run(app, **options)
-        while LSAPI.accept != nil
-          serve app
-        end
-      end
-      def self.serve(app)
-        env = ENV.to_hash
-        env.delete "HTTP_CONTENT_LENGTH"
-        env[SCRIPT_NAME] = "" if env[SCRIPT_NAME] == "/"
-
-        rack_input = RewindableInput.new($stdin.read.to_s)
-
-        env.update(
-          RACK_VERSION      => Rack::VERSION,
-          RACK_INPUT        => rack_input,
-          RACK_ERRORS       => $stderr,
-          RACK_MULTITHREAD  => false,
-          RACK_MULTIPROCESS => true,
-          RACK_RUNONCE      => false,
-          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(ENV[HTTPS]) ? "https" : "http"
-        )
-
-        env[QUERY_STRING] ||= ""
-        env[HTTP_VERSION] ||= env[SERVER_PROTOCOL]
-        env[REQUEST_PATH] ||= "/"
-        status, headers, body = app.call(env)
-        begin
-          send_headers status, headers
-          send_body body
-        ensure
-          body.close if body.respond_to? :close
-        end
-      ensure
-        rack_input.close
-      end
-      def self.send_headers(status, headers)
-        print "Status: #{status}\r\n"
-        headers.each { |k, vs|
-          vs.split("\n").each { |v|
-            print "#{k}: #{v}\r\n"
-          }
-        }
-        print "\r\n"
-        STDOUT.flush
-      end
-      def self.send_body(body)
-        body.each { |part|
-          print part
-          STDOUT.flush
-        }
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/rack-2.2.3.1/lib/rack/handler/scgi.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require 'scgi'
-require 'stringio'
-
-module Rack
-  module Handler
-    class SCGI < ::SCGI::Processor
-      attr_accessor :app
-
-      def self.run(app, **options)
-        options[:Socket] = UNIXServer.new(options[:File]) if options[:File]
-        new(options.merge(app: app,
-                          host: options[:Host],
-                          port: options[:Port],
-                          socket: options[:Socket])).listen
-      end
-
-      def self.valid_options
-        environment  = ENV['RACK_ENV'] || 'development'
-        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
-
-        {
-          "Host=HOST" => "Hostname to listen on (default: #{default_host})",
-          "Port=PORT" => "Port to listen on (default: 8080)",
-        }
-      end
-
-      def initialize(settings = {})
-        @app = settings[:app]
-        super(settings)
-      end
-
-      def process_request(request, input_body, socket)
-        env = Hash[request]
-        env.delete "HTTP_CONTENT_TYPE"
-        env.delete "HTTP_CONTENT_LENGTH"
-        env[REQUEST_PATH], env[QUERY_STRING] = env["REQUEST_URI"].split('?', 2)
-        env[HTTP_VERSION] ||= env[SERVER_PROTOCOL]
-        env[PATH_INFO] = env[REQUEST_PATH]
-        env[QUERY_STRING] ||= ""
-        env[SCRIPT_NAME] = ""
-
-        rack_input = StringIO.new(input_body)
-        rack_input.set_encoding(Encoding::BINARY)
-
-        env.update(
-          RACK_VERSION      => Rack::VERSION,
-          RACK_INPUT        => rack_input,
-          RACK_ERRORS       => $stderr,
-          RACK_MULTITHREAD  => true,
-          RACK_MULTIPROCESS => true,
-          RACK_RUNONCE      => false,
-          RACK_URL_SCHEME   => ["yes", "on", "1"].include?(env[HTTPS]) ? "https" : "http"
-        )
-
-        status, headers, body = app.call(env)
-        begin
-          socket.write("Status: #{status}\r\n")
-          headers.each do |k, vs|
-            vs.split("\n").each { |v| socket.write("#{k}: #{v}\r\n")}
-          end
-          socket.write("\r\n")
-          body.each {|s| socket.write(s)}
-        ensure
-          body.close if body.respond_to? :close
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/rack-2.2.3.1/lib/rack/handler/thin.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require "thin"
-require "thin/server"
-require "thin/logging"
-require "thin/backends/tcp_server"
-
-module Rack
-  module Handler
-    class Thin
-      def self.run(app, **options)
-        environment  = ENV['RACK_ENV'] || 'development'
-        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
-
-        host = options.delete(:Host) || default_host
-        port = options.delete(:Port) || 8080
-        args = [host, port, app, options]
-        # Thin versions below 0.8.0 do not support additional options
-        args.pop if ::Thin::VERSION::MAJOR < 1 && ::Thin::VERSION::MINOR < 8
-        server = ::Thin::Server.new(*args)
-        yield server if block_given?
-        server.start
-      end
-
-      def self.valid_options
-        environment  = ENV['RACK_ENV'] || 'development'
-        default_host = environment == 'development' ? 'localhost' : '0.0.0.0'
-
-        {
-          "Host=HOST" => "Hostname to listen on (default: #{default_host})",
-          "Port=PORT" => "Port to listen on (default: 8080)",
-        }
-      end
-    end
-  end
-end