torquebox-console 0.2.5 → 0.3.0

data/vendor/bundle/ruby/1.8/gems/rack-1.5.2/lib/rack/mock.rb

@@ -1,190 +0,0 @@
-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.run_once" => false,
-    }
-
-    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 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
-
-    # Return the Rack environment used for a request to +uri+.
-    def self.env_for(uri="", opts={})
-      uri = URI(uri)
-      uri.path = "/#{uri.path}" unless uri.path[0] == ?/
-
-      env = DEFAULT_ENV.dup
-
-      env["REQUEST_METHOD"] = opts[:method] ? opts[:method].to_s.upcase : "GET"
-      env["SERVER_NAME"] = uri.host || "example.org"
-      env["SERVER_PORT"] = uri.port ? uri.port.to_s : "80"
-      env["QUERY_STRING"] = uri.query.to_s
-      env["PATH_INFO"] = (!uri.path || uri.path.empty?) ? "/" : uri.path
-      env["rack.url_scheme"] = uri.scheme || "http"
-      env["HTTPS"] = env["rack.url_scheme"] == "https" ? "on" : "off"
-
-      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 = Utils::Multipart.build_multipart(params)
-              opts[:input] = data
-              opts["CONTENT_LENGTH"] ||= data.length.to_s
-              opts["CONTENT_TYPE"] = "multipart/form-data; boundary=#{Utils::Multipart::MULTIPART_BOUNDARY}"
-            else
-              opts[:input] = Utils.build_nested_query(params)
-            end
-          else
-            opts[:input] = params
-          end
-        end
-      end
-
-      empty_str = ""
-      empty_str.force_encoding("ASCII-8BIT") if empty_str.respond_to? :force_encoding
-      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) if rack_input.respond_to?(:set_encoding)
-      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)
-      @body_string      = nil
-
-      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, 205, 304].include? status
-    end
-  end
-end

data/vendor/bundle/ruby/1.8/gems/rack-1.5.2/lib/rack/multipart.rb

@@ -1,34 +0,0 @@
-module Rack
-  # A multipart form data parser, adapted from IOWA.
-  #
-  # Usually, Rack::Request#POST takes care of calling this.
-  module Multipart
-    autoload :UploadedFile, 'rack/multipart/uploaded_file'
-    autoload :Parser, 'rack/multipart/parser'
-    autoload :Generator, 'rack/multipart/generator'
-
-    EOL = "\r\n"
-    MULTIPART_BOUNDARY = "AaB03x"
-    MULTIPART = %r|\Amultipart/.*boundary=\"?([^\";,]+)\"?|n
-    TOKEN = /[^\s()<>,;:\\"\/\[\]?=]+/
-    CONDISP = /Content-Disposition:\s*#{TOKEN}\s*/i
-    DISPPARM = /;\s*(#{TOKEN})=("(?:\\"|[^"])*"|#{TOKEN})/
-    RFC2183 = /^#{CONDISP}(#{DISPPARM})+$/i
-    BROKEN_QUOTED = /^#{CONDISP}.*;\sfilename="(.*?)"(?:\s*$|\s*;\s*#{TOKEN}=)/i
-    BROKEN_UNQUOTED = /^#{CONDISP}.*;\sfilename=(#{TOKEN})/i
-    MULTIPART_CONTENT_TYPE = /Content-Type: (.*)#{EOL}/ni
-    MULTIPART_CONTENT_DISPOSITION = /Content-Disposition:.*\s+name="?([^\";]*)"?/ni
-    MULTIPART_CONTENT_ID = /Content-ID:\s*([^#{EOL}]*)/ni
-
-    class << self
-      def parse_multipart(env)
-        Parser.new(env).parse
-      end
-
-      def build_multipart(params, first = true)
-        Generator.new(params, first).dump
-      end
-    end
-
-  end
-end

data/vendor/bundle/ruby/1.8/gems/rack-1.5.2/lib/rack/multipart/generator.rb

@@ -1,93 +0,0 @@
-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 if !@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) if f.respond_to?(:set_encoding)
-              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/bundle/ruby/1.8/gems/rack-1.5.2/lib/rack/multipart/parser.rb

@@ -1,176 +0,0 @@
-require 'rack/utils'
-
-module Rack
-  module Multipart
-    class Parser
-      BUFSIZE = 16384
-
-      def initialize(env)
-        @env = env
-      end
-
-      def parse
-        return nil unless setup_parse
-
-        fast_forward_to_first_boundary
-
-        loop do
-          head, filename, content_type, name, body =
-            get_current_head_and_filename_and_content_type_and_name_and_body
-
-          # Save the rest.
-          if i = @buf.index(rx)
-            body << @buf.slice!(0, i)
-            @buf.slice!(0, @boundary_size+2)
-
-            @content_length = -1  if $1 == "--"
-          end
-
-          filename, data = get_data(filename, body, content_type, name, head)
-
-          Utils.normalize_params(@params, name, data) unless data.nil?
-
-          # break if we're at the end of a buffer, but not if it is the end of a field
-          break if (@buf.empty? && $1 != EOL) || @content_length == -1
-        end
-
-        @io.rewind
-
-        @params.to_params_hash
-      end
-
-      private
-      def setup_parse
-        return false unless @env['CONTENT_TYPE'] =~ MULTIPART
-
-        @boundary = "--#{$1}"
-
-        @buf = ""
-        @params = Utils::KeySpaceConstrainedParams.new
-
-        @io = @env['rack.input']
-        @io.rewind
-
-        @boundary_size = Utils.bytesize(@boundary) + EOL.size
-
-        if @content_length = @env['CONTENT_LENGTH']
-          @content_length = @content_length.to_i
-          @content_length -= @boundary_size
-        end
-        true
-      end
-
-      def full_boundary
-        @boundary + EOL
-      end
-
-      def rx
-        @rx ||= /(?:#{EOL})?#{Regexp.quote(@boundary)}(#{EOL}|--)/n
-      end
-
-      def fast_forward_to_first_boundary
-        loop do
-          content = @io.read(BUFSIZE)
-          raise EOFError, "bad content body" unless content
-          @buf << content
-
-          while @buf.gsub!(/\A([^\n]*\n)/, '')
-            read_buffer = $1
-            return if read_buffer == full_boundary
-          end
-
-          raise EOFError, "bad content body" if Utils.bytesize(@buf) >= BUFSIZE
-        end
-      end
-
-      def get_current_head_and_filename_and_content_type_and_name_and_body
-        head = nil
-        body = ''
-        filename = content_type = name = nil
-        content = nil
-
-        until head && @buf =~ rx
-          if !head && 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]
-            name = head[MULTIPART_CONTENT_DISPOSITION, 1] || head[MULTIPART_CONTENT_ID, 1]
-
-            filename = get_filename(head)
-
-            if filename
-              body = Tempfile.new("RackMultipart")
-              body.binmode  if body.respond_to?(:binmode)
-            end
-
-            next
-          end
-
-          # Save the read body part.
-          if head && (@boundary_size+4 < @buf.size)
-            body << @buf.slice!(0, @buf.size - (@boundary_size+4))
-          end
-
-          content = @io.read(@content_length && BUFSIZE >= @content_length ? @content_length : BUFSIZE)
-          raise EOFError, "bad content body"  if content.nil? || content.empty?
-
-          @buf << content
-          @content_length -= content.size if @content_length
-        end
-
-        [head, filename, content_type, name, body]
-      end
-
-      def get_filename(head)
-        filename = nil
-        if head =~ RFC2183
-          filename = Hash[head.scan(DISPPARM)]['filename']
-          filename = $1 if filename and filename =~ /^"(.*)"$/
-        elsif head =~ BROKEN_QUOTED
-          filename = $1
-        elsif head =~ BROKEN_UNQUOTED
-          filename = $1
-        end
-
-        if filename && filename.scan(/%.?.?/).all? { |s| s =~ /%[0-9a-fA-F]{2}/ }
-          filename = Utils.unescape(filename)
-        end
-        if filename && filename !~ /\\[^\\"]/
-          filename = filename.gsub(/\\(.)/, '\1')
-        end
-        filename
-      end
-
-      def get_data(filename, body, content_type, name, head)
-        data = nil
-        if filename == ""
-          # filename is blank which means no file has been selected
-          return data
-        elsif filename
-          body.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.
-          filename = filename.split(/[\/\\]/).last
-
-          data = {:filename => filename, :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}
-        else
-          data = body
-        end
-
-        [filename, data]
-      end
-    end
-  end
-end