diy_rails 0.1.0 → 0.2.0

data/vendor/bundle/ruby/3.0.0/gems/rack-2.2.4/lib/rack/auth/digest/nonce.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require 'digest/md5'
-require 'base64'
-
-module Rack
-  module Auth
-    module Digest
-      # Rack::Auth::Digest::Nonce is the default nonce generator for the
-      # Rack::Auth::Digest::MD5 authentication handler.
-      #
-      # +private_key+ needs to set to a constant string.
-      #
-      # +time_limit+ can be optionally set to an integer (number of seconds),
-      # to limit the validity of the generated nonces.
-
-      class Nonce
-
-        class << self
-          attr_accessor :private_key, :time_limit
-        end
-
-        def self.parse(string)
-          new(*Base64.decode64(string).split(' ', 2))
-        end
-
-        def initialize(timestamp = Time.now, given_digest = nil)
-          @timestamp, @given_digest = timestamp.to_i, given_digest
-        end
-
-        def to_s
-          Base64.encode64("#{@timestamp} #{digest}").strip
-        end
-
-        def digest
-          ::Digest::MD5.hexdigest("#{@timestamp}:#{self.class.private_key}")
-        end
-
-        def valid?
-          digest == @given_digest
-        end
-
-        def stale?
-          !self.class.time_limit.nil? && (Time.now.to_i - @timestamp) > self.class.time_limit
-        end
-
-        def fresh?
-          !stale?
-        end
-
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rack-2.2.4/lib/rack/auth/digest/params.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  module Auth
-    module Digest
-      class Params < Hash
-
-        def self.parse(str)
-          Params[*split_header_value(str).map do |param|
-            k, v = param.split('=', 2)
-            [k, dequote(v)]
-          end.flatten]
-        end
-
-        def self.dequote(str) # From WEBrick::HTTPUtils
-          ret = (/\A"(.*)"\Z/ =~ str) ? $1 : str.dup
-          ret.gsub!(/\\(.)/, "\\1")
-          ret
-        end
-
-        def self.split_header_value(str)
-          str.scan(/\w+\=(?:"[^\"]+"|[^,]+)/n)
-        end
-
-        def initialize
-          super()
-
-          yield self if block_given?
-        end
-
-        def [](k)
-          super k.to_s
-        end
-
-        def []=(k, v)
-          super k.to_s, v.to_s
-        end
-
-        UNQUOTED = ['nc', 'stale']
-
-        def to_s
-          map do |k, v|
-            "#{k}=#{(UNQUOTED.include?(k) ? v.to_s : quote(v))}"
-          end.join(', ')
-        end
-
-        def quote(str) # From WEBrick::HTTPUtils
-          '"' + str.gsub(/[\\\"]/o, "\\\1") + '"'
-        end
-
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rack-2.2.4/lib/rack/auth/digest/request.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../abstract/request'
-require_relative 'params'
-require_relative 'nonce'
-
-module Rack
-  module Auth
-    module Digest
-      class Request < Auth::AbstractRequest
-        def method
-          @env[RACK_METHODOVERRIDE_ORIGINAL_METHOD] || @env[REQUEST_METHOD]
-        end
-
-        def digest?
-          "digest" == scheme
-        end
-
-        def correct_uri?
-          request.fullpath == uri
-        end
-
-        def nonce
-          @nonce ||= Nonce.parse(params['nonce'])
-        end
-
-        def params
-          @params ||= Params.parse(parts.last)
-        end
-
-        def respond_to?(sym, *)
-          super or params.has_key? sym.to_s
-        end
-
-        def method_missing(sym, *args)
-          return super unless params.has_key?(key = sym.to_s)
-          return params[key] if args.size == 0
-          raise ArgumentError, "wrong number of arguments (#{args.size} for 0)"
-        end
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-# 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)
-      super or @body.respond_to?(method_name, include_all)
-    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)
-      @body.__send__(method_name, *args, &block)
-    end
-    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
-  end
-end

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

@@ -1,257 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-  # Rack::Builder implements a small DSL to iteratively construct Rack
-  # applications.
-  #
-  # Example:
-  #
-  #  require 'rack/lobster'
-  #  app = Rack::Builder.new do
-  #    use Rack::CommonLogger
-  #    use Rack::ShowExceptions
-  #    map "/lobster" do
-  #      use Rack::Lint
-  #      run Rack::Lobster.new
-  #    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, using the given
-    # options.
-    #
-    # 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.
-    # The options given will be ignored in this case.
-    #
-    # 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
-    #   # contains 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 contains Rack application
-    def self.parse_file(config, opts = Server::Options.new)
-      if config.end_with?('.ru')
-        return self.load_file(config, opts)
-      else
-        require config
-        app = Object.const_get(::File.basename(config, '.rb').split('_').map(&:capitalize).join(''))
-        return app, {}
-      end
-    end
-
-    # Load the given file as a rackup file, treating the
-    # contents as if specified inside a Rack::Builder block.
-    #
-    # Treats the first comment at the beginning of a line
-    # that starts with a backslash as options similar to
-    # options passed on a rackup command line.
-    #
-    # 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
-    #
-    #   #\ -p 9393
-    #
-    #   use Rack::ContentLength
-    #   require './app.rb'
-    #   run App
-    def self.load_file(path, opts = Server::Options.new)
-      options = {}
-
-      cfgfile = ::File.read(path)
-      cfgfile.slice!(/\A#{UTF_8_BOM}/) if cfgfile.encoding == Encoding::UTF_8
-
-      if cfgfile[/^#\\(.*)/] && opts
-        warn "Parsing options from the first comment line is deprecated!"
-        options = opts.parse! $1.split(/\s+/)
-      end
-
-      cfgfile.sub!(/^__END__\n.*\Z/m, '')
-      app = new_from_string cfgfile, path
-
-      return app, 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, file = "(rackup)")
-      # 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.eval('Rack::Builder.new.instance_eval { [binding, self] }')
-      eval builder_script, binding, file
-      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 evaluted in the context of the instance.
-    def initialize(default_app = nil, &block)
-      @use, @map, @run, @warmup, @freeze_app = [], nil, default_app, nil, false
-      instance_eval(&block) if block_given?
-    end
-
-    # 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) }
-    end
-    ruby2_keywords(:use) if respond_to?(:ruby2_keywords, true)
-
-    # Takes an argument that is an object that responds to #call and returns a Rack response.
-    # The simplest form of this is a lambda object:
-    #
-    #   run lambda { |env| [200, { "Content-Type" => "text/plain" }, ["OK"]] }
-    #
-    # However this could also be a class:
-    #
-    #   class Heartbeat
-    #     def self.call(env)
-    #      [200, { "Content-Type" => "text/plain" }, ["OK"]]
-    #     end
-    #   end
-    #
-    #   run Heartbeat
-    def run(app)
-      @run = app
-    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.
-    #
-    #   Rack::Builder.app do
-    #     map '/heartbeat' do
-    #       run Heartbeat
-    #     end
-    #     run App
-    #   end
-    #
-    # The +use+ method can also be used inside the block to specify middleware to run under a specific path:
-    #
-    #   Rack::Builder.app do
-    #     map '/heartbeat' do
-    #       use Middleware
-    #       run Heartbeat
-    #     end
-    #     run App
-    #   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
-    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
-      app = @use.reverse.inject(app) { |a, e| e[a].tap { |x| x.freeze if @freeze_app } }
-      @warmup.call(app) if @warmup
-      app
-    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/bundle/ruby/3.0.0/gems/rack-2.2.4/lib/rack/cascade.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-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
-    # deprecated, no longer used
-    NotFound = [404, { CONTENT_TYPE => "text/plain" }, []]
-
-    # 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/bundle/ruby/3.0.0/gems/rack-2.2.4/lib/rack/chunked.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-
-  # 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 = @app.call(env)
-      headers = HeaderHash[headers]
-
-      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']
-          body = TrailerBody.new(body)
-        else
-          body = Body.new(body)
-        end
-      end
-
-      [status, headers, body]
-    end
-  end
-end