sprokovuln 0.2.0

data/vendor/ruby/gems/rack-2.0.5/lib/rack/mock.rb

@@ -0,0 +1,196 @@
+require 'uri'
+require 'stringio'
+require 'rack'
+require 'rack/lint'
+require 'rack/utils'
+require 'rack/response'
+
+module Rack
+  # Rack::MockRequest helps testing your Rack application without
+  # actually using HTTP.
+  #
+  # After performing a request on a URL with get/post/put/patch/delete, it
+  # returns a MockResponse with useful helper methods for effective
+  # testing.
+  #
+  # You can pass a hash with additional configuration to the
+  # get/post/put/patch/delete.
+  # <tt>:input</tt>:: A String or IO-like to be used as rack.input.
+  # <tt>:fatal</tt>:: Raise a FatalWarning if the app writes to rack.errors.
+  # <tt>:lint</tt>:: If true, wrap the application in a Rack::Lint.
+
+  class MockRequest
+    class FatalWarning < RuntimeError
+    end
+
+    class FatalWarner
+      def puts(warning)
+        raise FatalWarning, warning
+      end
+
+      def write(warning)
+        raise FatalWarning, warning
+      end
+
+      def flush
+      end
+
+      def string
+        ""
+      end
+    end
+
+    DEFAULT_ENV = {
+      RACK_VERSION      => Rack::VERSION,
+      RACK_INPUT        => StringIO.new,
+      RACK_ERRORS       => StringIO.new,
+      RACK_MULTITHREAD  => true,
+      RACK_MULTIPROCESS => true,
+      RACK_RUNONCE      => false,
+    }.freeze
+
+    def initialize(app)
+      @app = app
+    end
+
+    def get(uri, opts={})     request(GET, uri, opts)     end
+    def post(uri, opts={})    request(POST, uri, opts)    end
+    def put(uri, opts={})     request(PUT, uri, opts)     end
+    def patch(uri, opts={})   request(PATCH, uri, opts)   end
+    def delete(uri, opts={})  request(DELETE, uri, opts)  end
+    def head(uri, opts={})    request(HEAD, uri, opts)    end
+    def options(uri, opts={}) request(OPTIONS, uri, opts) end
+
+    def request(method=GET, uri="", opts={})
+      env = self.class.env_for(uri, opts.merge(:method => method))
+
+      if opts[:lint]
+        app = Rack::Lint.new(@app)
+      else
+        app = @app
+      end
+
+      errors = env[RACK_ERRORS]
+      status, headers, body  = app.call(env)
+      MockResponse.new(status, headers, body, errors)
+    ensure
+      body.close if body.respond_to?(:close)
+    end
+
+    # For historical reasons, we're pinning to RFC 2396.
+    # URI::Parser = URI::RFC2396_Parser
+    def self.parse_uri_rfc2396(uri)
+      @parser ||= URI::Parser.new
+      @parser.parse(uri)
+    end
+
+    # Return the Rack environment used for a request to +uri+.
+    def self.env_for(uri="", opts={})
+      uri = parse_uri_rfc2396(uri)
+      uri.path = "/#{uri.path}" unless uri.path[0] == ?/
+
+      env = DEFAULT_ENV.dup
+
+      env[REQUEST_METHOD]  = (opts[:method] ? opts[:method].to_s.upcase : GET).b
+      env[SERVER_NAME]     = (uri.host || "example.org").b
+      env[SERVER_PORT]     = (uri.port ? uri.port.to_s : "80").b
+      env[QUERY_STRING]    = (uri.query.to_s).b
+      env[PATH_INFO]       = ((!uri.path || uri.path.empty?) ? "/" : uri.path).b
+      env[RACK_URL_SCHEME] = (uri.scheme || "http").b
+      env[HTTPS]           = (env[RACK_URL_SCHEME] == "https" ? "on" : "off").b
+
+      env[SCRIPT_NAME] = opts[:script_name] || ""
+
+      if opts[:fatal]
+        env[RACK_ERRORS] = FatalWarner.new
+      else
+        env[RACK_ERRORS] = StringIO.new
+      end
+
+      if params = opts[:params]
+        if env[REQUEST_METHOD] == GET
+          params = Utils.parse_nested_query(params) if params.is_a?(String)
+          params.update(Utils.parse_nested_query(env[QUERY_STRING]))
+          env[QUERY_STRING] = Utils.build_nested_query(params)
+        elsif !opts.has_key?(:input)
+          opts["CONTENT_TYPE"] = "application/x-www-form-urlencoded"
+          if params.is_a?(Hash)
+            if data = Rack::Multipart.build_multipart(params)
+              opts[:input] = data
+              opts["CONTENT_LENGTH"] ||= data.length.to_s
+              opts["CONTENT_TYPE"] = "multipart/form-data; boundary=#{Rack::Multipart::MULTIPART_BOUNDARY}"
+            else
+              opts[:input] = Utils.build_nested_query(params)
+            end
+          else
+            opts[:input] = params
+          end
+        end
+      end
+
+      empty_str = String.new
+      opts[:input] ||= empty_str
+      if String === opts[:input]
+        rack_input = StringIO.new(opts[:input])
+      else
+        rack_input = opts[:input]
+      end
+
+      rack_input.set_encoding(Encoding::BINARY)
+      env[RACK_INPUT] = rack_input
+
+      env["CONTENT_LENGTH"] ||= env[RACK_INPUT].length.to_s
+
+      opts.each { |field, value|
+        env[field] = value  if String === field
+      }
+
+      env
+    end
+  end
+
+  # Rack::MockResponse provides useful helpers for testing your apps.
+  # Usually, you don't create the MockResponse on your own, but use
+  # MockRequest.
+
+  class MockResponse < Rack::Response
+    # Headers
+    attr_reader :original_headers
+
+    # Errors
+    attr_accessor :errors
+
+    def initialize(status, headers, body, errors=StringIO.new(""))
+      @original_headers = headers
+      @errors           = errors.string if errors.respond_to?(:string)
+
+      super(body, status, headers)
+    end
+
+    def =~(other)
+      body =~ other
+    end
+
+    def match(other)
+      body.match other
+    end
+
+    def body
+      # FIXME: apparently users of MockResponse expect the return value of
+      # MockResponse#body to be a string.  However, the real response object
+      # returns the body as a list.
+      #
+      # See spec_showstatus.rb:
+      #
+      #   should "not replace existing messages" do
+      #     ...
+      #     res.body.should == "foo!"
+      #   end
+      super.join
+    end
+
+    def empty?
+      [201, 204, 304].include? status
+    end
+  end
+end

data/vendor/ruby/gems/rack-2.0.5/lib/rack/multipart/generator.rb

@@ -0,0 +1,93 @@
+module Rack
+  module Multipart
+    class Generator
+      def initialize(params, first = true)
+        @params, @first = params, first
+
+        if @first && !@params.is_a?(Hash)
+          raise ArgumentError, "value must be a Hash"
+        end
+      end
+
+      def dump
+        return nil if @first && !multipart?
+        return flattened_params unless @first
+
+        flattened_params.map do |name, file|
+          if file.respond_to?(:original_filename)
+            ::File.open(file.path, 'rb') do |f|
+              f.set_encoding(Encoding::BINARY)
+              content_for_tempfile(f, file, name)
+            end
+          else
+            content_for_other(file, name)
+          end
+        end.join << "--#{MULTIPART_BOUNDARY}--\r"
+      end
+
+      private
+      def multipart?
+        multipart = false
+
+        query = lambda { |value|
+          case value
+          when Array
+            value.each(&query)
+          when Hash
+            value.values.each(&query)
+          when Rack::Multipart::UploadedFile
+            multipart = true
+          end
+        }
+        @params.values.each(&query)
+
+        multipart
+      end
+
+      def flattened_params
+        @flattened_params ||= begin
+          h = Hash.new
+          @params.each do |key, value|
+            k = @first ? key.to_s : "[#{key}]"
+
+            case value
+            when Array
+              value.map { |v|
+                Multipart.build_multipart(v, false).each { |subkey, subvalue|
+                  h["#{k}[]#{subkey}"] = subvalue
+                }
+              }
+            when Hash
+              Multipart.build_multipart(value, false).each { |subkey, subvalue|
+                h[k + subkey] = subvalue
+              }
+            else
+              h[k] = value
+            end
+          end
+          h
+        end
+      end
+
+      def content_for_tempfile(io, file, name)
+<<-EOF
+--#{MULTIPART_BOUNDARY}\r
+Content-Disposition: form-data; name="#{name}"; filename="#{Utils.escape(file.original_filename)}"\r
+Content-Type: #{file.content_type}\r
+Content-Length: #{::File.stat(file.path).size}\r
+\r
+#{io.read}\r
+EOF
+      end
+
+      def content_for_other(file, name)
+<<-EOF
+--#{MULTIPART_BOUNDARY}\r
+Content-Disposition: form-data; name="#{name}"\r
+\r
+#{file}\r
+EOF
+      end
+    end
+  end
+end

data/vendor/ruby/gems/rack-2.0.5/lib/rack/multipart/parser.rb

@@ -0,0 +1,369 @@
+require 'rack/utils'
+
+module Rack
+  module Multipart
+    class MultipartPartLimitError < Errno::EMFILE; end
+
+    class Parser
+      BUFSIZE = 1_048_576
+      TEXT_PLAIN = "text/plain"
+      TEMPFILE_FACTORY = lambda { |filename, content_type|
+        Tempfile.new(["RackMultipart", ::File.extname(filename.gsub("\0".freeze, '%00'.freeze))])
+      }
+
+      class BoundedIO # :nodoc:
+        def initialize(io, content_length)
+          @io             = io
+          @content_length = content_length
+          @cursor = 0
+        end
+
+        def read(size)
+          return if @cursor >= @content_length
+
+          left = @content_length - @cursor
+
+          str = if left < size
+                  @io.read left
+                else
+                  @io.read size
+                end
+
+          if str
+            @cursor += str.bytesize
+          else
+            # Raise an error for mismatching Content-Length and actual contents
+            raise EOFError, "bad content body"
+          end
+
+          str
+        end
+
+        def eof?; @content_length == @cursor; end
+
+        def rewind
+          @io.rewind
+        end
+      end
+
+      MultipartInfo = Struct.new :params, :tmp_files
+      EMPTY         = MultipartInfo.new(nil, [])
+
+      def self.parse_boundary(content_type)
+        return unless content_type
+        data = content_type.match(MULTIPART)
+        return unless data
+        data[1]
+      end
+
+      def self.parse(io, content_length, content_type, tmpfile, bufsize, qp)
+        return EMPTY if 0 == content_length
+
+        boundary = parse_boundary content_type
+        return EMPTY unless boundary
+
+        io = BoundedIO.new(io, content_length) if content_length
+
+        parser = new(boundary, tmpfile, bufsize, qp)
+        parser.on_read io.read(bufsize), io.eof?
+
+        loop do
+          break if parser.state == :DONE
+          parser.on_read io.read(bufsize), io.eof?
+        end
+
+        io.rewind
+        parser.result
+      end
+
+      class Collector
+        class MimePart < Struct.new(:body, :head, :filename, :content_type, :name)
+          def get_data
+            data = body
+            if filename == ""
+              # filename is blank which means no file has been selected
+              return
+            elsif filename
+              body.rewind if body.respond_to?(:rewind)
+
+              # Take the basename of the upload's original filename.
+              # This handles the full Windows paths given by Internet Explorer
+              # (and perhaps other broken user agents) without affecting
+              # those which give the lone filename.
+              fn = filename.split(/[\/\\]/).last
+
+              data = {:filename => fn, :type => content_type,
+                      :name => name, :tempfile => body, :head => head}
+            elsif !filename && content_type && body.is_a?(IO)
+              body.rewind
+
+              # Generic multipart cases, not coming from a form
+              data = {:type => content_type,
+                      :name => name, :tempfile => body, :head => head}
+            end
+
+            yield data
+          end
+        end
+
+        class BufferPart < MimePart
+          def file?; false; end
+          def close; end
+        end
+
+        class TempfilePart < MimePart
+          def file?; true; end
+          def close; body.close; end
+        end
+
+        include Enumerable
+
+        def initialize tempfile
+          @tempfile = tempfile
+          @mime_parts = []
+          @open_files = 0
+        end
+
+        def each
+          @mime_parts.each { |part| yield part }
+        end
+
+        def on_mime_head mime_index, head, filename, content_type, name
+          if filename
+            body = @tempfile.call(filename, content_type)
+            body.binmode if body.respond_to?(:binmode)
+            klass = TempfilePart
+            @open_files += 1
+          else
+            body = String.new
+            klass = BufferPart
+          end
+
+          @mime_parts[mime_index] = klass.new(body, head, filename, content_type, name)
+          check_open_files
+        end
+
+        def on_mime_body mime_index, content
+          @mime_parts[mime_index].body << content
+        end
+
+        def on_mime_finish mime_index
+        end
+
+        private
+
+        def check_open_files
+          if Utils.multipart_part_limit > 0
+            if @open_files >= Utils.multipart_part_limit
+              @mime_parts.each(&:close)
+              raise MultipartPartLimitError, 'Maximum file multiparts in content reached'
+            end
+          end
+        end
+      end
+
+      attr_reader :state
+
+      def initialize(boundary, tempfile, bufsize, query_parser)
+        @buf            = String.new
+
+        @query_parser   = query_parser
+        @params         = query_parser.make_params
+        @boundary       = "--#{boundary}"
+        @bufsize        = bufsize
+
+        @rx = /(?:#{EOL})?#{Regexp.quote(@boundary)}(#{EOL}|--)/n
+        @rx_max_size = EOL.size + @boundary.bytesize + [EOL.size, '--'.size].max
+        @full_boundary = @boundary
+        @end_boundary = @boundary + '--'
+        @state = :FAST_FORWARD
+        @mime_index = 0
+        @collector = Collector.new tempfile
+      end
+
+      def on_read content, eof
+        handle_empty_content!(content, eof)
+        @buf << content
+        run_parser
+      end
+
+      def result
+        @collector.each do |part|
+          part.get_data do |data|
+            tag_multipart_encoding(part.filename, part.content_type, part.name, data)
+            @query_parser.normalize_params(@params, part.name, data, @query_parser.param_depth_limit)
+          end
+        end
+
+        MultipartInfo.new @params.to_params_hash, @collector.find_all(&:file?).map(&:body)
+      end
+
+      private
+
+      def run_parser
+        loop do
+          case @state
+          when :FAST_FORWARD
+            break if handle_fast_forward == :want_read
+          when :CONSUME_TOKEN
+            break if handle_consume_token == :want_read
+          when :MIME_HEAD
+            break if handle_mime_head == :want_read
+          when :MIME_BODY
+            break if handle_mime_body == :want_read
+          when :DONE
+            break
+          end
+        end
+      end
+
+      def handle_fast_forward
+        if consume_boundary
+          @state = :MIME_HEAD
+        else
+          raise EOFError, "bad content body" if @buf.bytesize >= @bufsize
+          :want_read
+        end
+      end
+
+      def handle_consume_token
+        tok = consume_boundary
+        # break if we're at the end of a buffer, but not if it is the end of a field
+        if tok == :END_BOUNDARY || (@buf.empty? && tok != :BOUNDARY)
+          @state = :DONE
+        else
+          @state = :MIME_HEAD
+        end
+      end
+
+      def handle_mime_head
+        if @buf.index(EOL + EOL)
+          i = @buf.index(EOL+EOL)
+          head = @buf.slice!(0, i+2) # First \r\n
+          @buf.slice!(0, 2)          # Second \r\n
+
+          content_type = head[MULTIPART_CONTENT_TYPE, 1]
+          if name = head[MULTIPART_CONTENT_DISPOSITION, 1]
+            name = Rack::Auth::Digest::Params::dequote(name)
+          else
+            name = head[MULTIPART_CONTENT_ID, 1]
+          end
+
+          filename = get_filename(head)
+
+          if name.nil? || name.empty?
+            name = filename || "#{content_type || TEXT_PLAIN}[]"
+          end
+
+          @collector.on_mime_head @mime_index, head, filename, content_type, name
+          @state = :MIME_BODY
+        else
+          :want_read
+        end
+      end
+
+      def handle_mime_body
+        if i = @buf.index(rx)
+          # Save the rest.
+          @collector.on_mime_body @mime_index, @buf.slice!(0, i)
+          @buf.slice!(0, 2) # Remove \r\n after the content
+          @state = :CONSUME_TOKEN
+          @mime_index += 1
+        else
+          # Save the read body part.
+          if @rx_max_size < @buf.size
+            @collector.on_mime_body @mime_index, @buf.slice!(0, @buf.size - @rx_max_size)
+          end
+          :want_read
+        end
+      end
+
+      def full_boundary; @full_boundary; end
+
+      def rx; @rx; end
+
+      def consume_boundary
+        while @buf.gsub!(/\A([^\n]*(?:\n|\Z))/, '')
+          read_buffer = $1
+          case read_buffer.strip
+          when full_boundary then return :BOUNDARY
+          when @end_boundary then return :END_BOUNDARY
+          end
+          return if @buf.empty?
+        end
+      end
+
+      def get_filename(head)
+        filename = nil
+        case head
+        when RFC2183
+          params = Hash[*head.scan(DISPPARM).flat_map(&:compact)]
+
+          if filename = params['filename']
+            filename = $1 if filename =~ /^"(.*)"$/
+          elsif filename = params['filename*']
+            encoding, _, filename = filename.split("'", 3)
+          end
+        when BROKEN_QUOTED, BROKEN_UNQUOTED
+          filename = $1
+        end
+
+        return unless filename
+
+        if filename.scan(/%.?.?/).all? { |s| s =~ /%[0-9a-fA-F]{2}/ }
+          filename = Utils.unescape(filename)
+        end
+
+        filename.scrub!
+
+        if filename !~ /\\[^\\"]/
+          filename = filename.gsub(/\\(.)/, '\1')
+        end
+
+        if encoding
+          filename.force_encoding ::Encoding.find(encoding)
+        end
+
+        filename
+      end
+
+      CHARSET   = "charset"
+
+      def tag_multipart_encoding(filename, content_type, name, body)
+        name = name.to_s
+        encoding = Encoding::UTF_8
+
+        name.force_encoding(encoding)
+
+        return if filename
+
+        if content_type
+          list         = content_type.split(';')
+          type_subtype = list.first
+          type_subtype.strip!
+          if TEXT_PLAIN == type_subtype
+            rest         = list.drop 1
+            rest.each do |param|
+              k,v = param.split('=', 2)
+              k.strip!
+              v.strip!
+              v = v[1..-2] if v[0] == '"' && v[-1] == '"'
+              encoding = Encoding.find v if k == CHARSET
+            end
+          end
+        end
+
+        name.force_encoding(encoding)
+        body.force_encoding(encoding)
+      end
+
+
+      def handle_empty_content!(content, eof)
+        if content.nil? || content.empty?
+          raise EOFError if eof
+          return true
+        end
+      end
+    end
+  end
+end

data/vendor/ruby/gems/rack-2.0.5/lib/rack/multipart/uploaded_file.rb

@@ -0,0 +1,33 @@
+module Rack
+  module Multipart
+    class UploadedFile
+      # The filename, *not* including the path, of the "uploaded" file
+      attr_reader :original_filename
+
+      # The content type of the "uploaded" file
+      attr_accessor :content_type
+
+      def initialize(path, content_type = "text/plain", binary = false)
+        raise "#{path} file does not exist" unless ::File.exist?(path)
+        @content_type = content_type
+        @original_filename = ::File.basename(path)
+        @tempfile = Tempfile.new([@original_filename, ::File.extname(path)], encoding: Encoding::BINARY)
+        @tempfile.binmode if binary
+        FileUtils.copy_file(path, @tempfile.path)
+      end
+
+      def path
+        @tempfile.path
+      end
+      alias_method :local_path, :path
+
+      def respond_to?(*args)
+        super or @tempfile.respond_to?(*args)
+      end
+
+      def method_missing(method_name, *args, &block) #:nodoc:
+        @tempfile.__send__(method_name, *args, &block)
+      end
+    end
+  end
+end