diy_rails 0.1.0 → 0.1.1

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

@@ -1,187 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-
-  # The Rack::Static middleware intercepts requests for static files
-  # (javascript files, images, stylesheets, etc) based on the url prefixes or
-  # route mappings passed in the options, and serves them using a Rack::Files
-  # object. This allows a Rack stack to serve both static and dynamic content.
-  #
-  # Examples:
-  #
-  # Serve all requests beginning with /media from the "media" folder located
-  # in the current directory (ie media/*):
-  #
-  #     use Rack::Static, :urls => ["/media"]
-  #
-  # Same as previous, but instead of returning 404 for missing files under
-  # /media, call the next middleware:
-  #
-  #     use Rack::Static, :urls => ["/media"], :cascade => true
-  #
-  # Serve all requests beginning with /css or /images from the folder "public"
-  # in the current directory (ie public/css/* and public/images/*):
-  #
-  #     use Rack::Static, :urls => ["/css", "/images"], :root => "public"
-  #
-  # Serve all requests to / with "index.html" from the folder "public" in the
-  # current directory (ie public/index.html):
-  #
-  #     use Rack::Static, :urls => {"/" => 'index.html'}, :root => 'public'
-  #
-  # Serve all requests normally from the folder "public" in the current
-  # directory but uses index.html as default route for "/"
-  #
-  #     use Rack::Static, :urls => [""], :root => 'public', :index =>
-  #     'index.html'
-  #
-  # Set custom HTTP Headers for based on rules:
-  #
-  #     use Rack::Static, :root => 'public',
-  #         :header_rules => [
-  #           [rule, {header_field => content, header_field => content}],
-  #           [rule, {header_field => content}]
-  #         ]
-  #
-  #  Rules for selecting files:
-  #
-  #  1) All files
-  #     Provide the :all symbol
-  #     :all => Matches every file
-  #
-  #  2) Folders
-  #     Provide the folder path as a string
-  #     '/folder' or '/folder/subfolder' => Matches files in a certain folder
-  #
-  #  3) File Extensions
-  #     Provide the file extensions as an array
-  #     ['css', 'js'] or %w(css js) => Matches files ending in .css or .js
-  #
-  #  4) Regular Expressions / Regexp
-  #     Provide a regular expression
-  #     %r{\.(?:css|js)\z} => Matches files ending in .css or .js
-  #     /\.(?:eot|ttf|otf|woff2|woff|svg)\z/ => Matches files ending in
-  #       the most common web font formats (.eot, .ttf, .otf, .woff2, .woff, .svg)
-  #       Note: This Regexp is available as a shortcut, using the :fonts rule
-  #
-  #  5) Font Shortcut
-  #     Provide the :fonts symbol
-  #     :fonts => Uses the Regexp rule stated right above to match all common web font endings
-  #
-  #  Rule Ordering:
-  #    Rules are applied in the order that they are provided.
-  #    List rather general rules above special ones.
-  #
-  #  Complete example use case including HTTP header rules:
-  #
-  #     use Rack::Static, :root => 'public',
-  #         :header_rules => [
-  #           # Cache all static files in public caches (e.g. Rack::Cache)
-  #           #  as well as in the browser
-  #           [:all, {'Cache-Control' => 'public, max-age=31536000'}],
-  #
-  #           # Provide web fonts with cross-origin access-control-headers
-  #           #  Firefox requires this when serving assets using a Content Delivery Network
-  #           [:fonts, {'Access-Control-Allow-Origin' => '*'}]
-  #         ]
-  #
-  class Static
-    (require_relative 'core_ext/regexp'; using ::Rack::RegexpExtensions) if RUBY_VERSION < '2.4'
-
-    def initialize(app, options = {})
-      @app = app
-      @urls = options[:urls] || ["/favicon.ico"]
-      @index = options[:index]
-      @gzip = options[:gzip]
-      @cascade = options[:cascade]
-      root = options[:root] || Dir.pwd
-
-      # HTTP Headers
-      @header_rules = options[:header_rules] || []
-      # Allow for legacy :cache_control option while prioritizing global header_rules setting
-      @header_rules.unshift([:all, { CACHE_CONTROL => options[:cache_control] }]) if options[:cache_control]
-
-      @file_server = Rack::Files.new(root)
-    end
-
-    def add_index_root?(path)
-      @index && route_file(path) && path.end_with?('/')
-    end
-
-    def overwrite_file_path(path)
-      @urls.kind_of?(Hash) && @urls.key?(path) || add_index_root?(path)
-    end
-
-    def route_file(path)
-      @urls.kind_of?(Array) && @urls.any? { |url| path.index(url) == 0 }
-    end
-
-    def can_serve(path)
-      route_file(path) || overwrite_file_path(path)
-    end
-
-    def call(env)
-      path = env[PATH_INFO]
-
-      if can_serve(path)
-        if overwrite_file_path(path)
-          env[PATH_INFO] = (add_index_root?(path) ? path + @index : @urls[path])
-        elsif @gzip && env['HTTP_ACCEPT_ENCODING'] && /\bgzip\b/.match?(env['HTTP_ACCEPT_ENCODING'])
-          path = env[PATH_INFO]
-          env[PATH_INFO] += '.gz'
-          response = @file_server.call(env)
-          env[PATH_INFO] = path
-
-          if response[0] == 404
-            response = nil
-          elsif response[0] == 304
-            # Do nothing, leave headers as is
-          else
-            if mime_type = Mime.mime_type(::File.extname(path), 'text/plain')
-              response[1][CONTENT_TYPE] = mime_type
-            end
-            response[1]['Content-Encoding'] = 'gzip'
-          end
-        end
-
-        path = env[PATH_INFO]
-        response ||= @file_server.call(env)
-
-        if @cascade && response[0] == 404
-          return @app.call(env)
-        end
-
-        headers = response[1]
-        applicable_rules(path).each do |rule, new_headers|
-          new_headers.each { |field, content| headers[field] = content }
-        end
-
-        response
-      else
-        @app.call(env)
-      end
-    end
-
-    # Convert HTTP header rules to HTTP headers
-    def applicable_rules(path)
-      @header_rules.find_all do |rule, new_headers|
-        case rule
-        when :all
-          true
-        when :fonts
-          /\.(?:ttf|otf|eot|woff2|woff|svg)\z/.match?(path)
-        when String
-          path = ::Rack::Utils.unescape(path)
-          path.start_with?(rule) || path.start_with?('/' + rule)
-        when Array
-          /\.(#{rule.join('|')})\z/.match?(path)
-        when Regexp
-          rule.match?(path)
-        else
-          false
-        end
-      end
-    end
-
-  end
-end

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Rack
-
-  # Middleware tracks and cleans Tempfiles created throughout a request (i.e. Rack::Multipart)
-  # Ideas/strategy based on posts by Eric Wong and Charles Oliver Nutter
-  # https://groups.google.com/forum/#!searchin/rack-devel/temp/rack-devel/brK8eh-MByw/sw61oJJCGRMJ
-  class TempfileReaper
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      env[RACK_TEMPFILES] ||= []
-      status, headers, body = @app.call(env)
-      body_proxy = BodyProxy.new(body) do
-        env[RACK_TEMPFILES].each(&:close!) unless env[RACK_TEMPFILES].nil?
-      end
-      [status, headers, body_proxy]
-    end
-  end
-end

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

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-
-module Rack
-  # Rack::URLMap takes a hash mapping urls or paths to apps, and
-  # dispatches accordingly.  Support for HTTP/1.1 host names exists if
-  # the URLs start with <tt>http://</tt> or <tt>https://</tt>.
-  #
-  # URLMap modifies the SCRIPT_NAME and PATH_INFO such that the part
-  # relevant for dispatch is in the SCRIPT_NAME, and the rest in the
-  # PATH_INFO.  This should be taken care of when you need to
-  # reconstruct the URL in order to create links.
-  #
-  # URLMap dispatches in such a way that the longest paths are tried
-  # first, since they are most specific.
-
-  class URLMap
-    def initialize(map = {})
-      remap(map)
-    end
-
-    def remap(map)
-      @known_hosts = Set[]
-      @mapping = map.map { |location, app|
-        if location =~ %r{\Ahttps?://(.*?)(/.*)}
-          host, location = $1, $2
-          @known_hosts << host
-        else
-          host = nil
-        end
-
-        unless location[0] == ?/
-          raise ArgumentError, "paths need to start with /"
-        end
-
-        location = location.chomp('/')
-        match = Regexp.new("^#{Regexp.quote(location).gsub('/', '/+')}(.*)", nil, 'n')
-
-        [host, location, match, app]
-      }.sort_by do |(host, location, _, _)|
-        [host ? -host.size : Float::INFINITY, -location.size]
-      end
-    end
-
-    def call(env)
-      path        = env[PATH_INFO]
-      script_name = env[SCRIPT_NAME]
-      http_host   = env[HTTP_HOST]
-      server_name = env[SERVER_NAME]
-      server_port = env[SERVER_PORT]
-
-      is_same_server = casecmp?(http_host, server_name) ||
-                       casecmp?(http_host, "#{server_name}:#{server_port}")
-
-      is_host_known = @known_hosts.include? http_host
-
-      @mapping.each do |host, location, match, app|
-        unless casecmp?(http_host, host) \
-            || casecmp?(server_name, host) \
-            || (!host && is_same_server) \
-            || (!host && !is_host_known) # If we don't have a matching host, default to the first without a specified host
-          next
-        end
-
-        next unless m = match.match(path.to_s)
-
-        rest = m[1]
-        next unless !rest || rest.empty? || rest[0] == ?/
-
-        env[SCRIPT_NAME] = (script_name + location)
-        env[PATH_INFO] = rest
-
-        return app.call(env)
-      end
-
-      [404, { CONTENT_TYPE => "text/plain", "X-Cascade" => "pass" }, ["Not Found: #{path}"]]
-
-    ensure
-      env[PATH_INFO]   = path
-      env[SCRIPT_NAME] = script_name
-    end
-
-    private
-    def casecmp?(v1, v2)
-      # if both nil, or they're the same string
-      return true if v1 == v2
-
-      # if either are nil... (but they're not the same)
-      return false if v1.nil?
-      return false if v2.nil?
-
-      # otherwise check they're not case-insensitive the same
-      v1.casecmp(v2).zero?
-    end
-  end
-end