challah 0.9.0 → 0.9.1.beta

data/vendor/bundle/gems/rack-1.4.3/lib/rack/mock.rb

@@ -0,0 +1,190 @@
+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/gems/rack-1.4.3/lib/rack/multipart/parser.rb

@@ -0,0 +1,176 @@
+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

data/vendor/bundle/gems/rack-1.4.3/lib/rack/multipart.rb

@@ -0,0 +1,34 @@
+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/gems/rack-1.4.3/lib/rack/reloader.rb

@@ -0,0 +1,109 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+#       Rack::Reloader is subject to the terms of an MIT-style license.
+#      See COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+require 'pathname'
+
+module Rack
+
+  # High performant source reloader
+  #
+  # This class acts as Rack middleware.
+  #
+  # What makes it especially suited for use in a production environment is that
+  # any file will only be checked once and there will only be made one system
+  # call stat(2).
+  #
+  # Please note that this will not reload files in the background, it does so
+  # only when actively called.
+  #
+  # It is performing a check/reload cycle at the start of every request, but
+  # also respects a cool down time, during which nothing will be done.
+  class Reloader
+    def initialize(app, cooldown = 10, backend = Stat)
+      @app = app
+      @cooldown = cooldown
+      @last = (Time.now - cooldown)
+      @cache = {}
+      @mtimes = {}
+
+      extend backend
+    end
+
+    def call(env)
+      if @cooldown and Time.now > @last + @cooldown
+        if Thread.list.size > 1
+          Thread.exclusive{ reload! }
+        else
+          reload!
+        end
+
+        @last = Time.now
+      end
+
+      @app.call(env)
+    end
+
+    def reload!(stderr = $stderr)
+      rotation do |file, mtime|
+        previous_mtime = @mtimes[file] ||= mtime
+        safe_load(file, mtime, stderr) if mtime > previous_mtime
+      end
+    end
+
+    # A safe Kernel::load, issuing the hooks depending on the results
+    def safe_load(file, mtime, stderr = $stderr)
+      load(file)
+      stderr.puts "#{self.class}: reloaded `#{file}'"
+      file
+    rescue LoadError, SyntaxError => ex
+      stderr.puts ex
+    ensure
+      @mtimes[file] = mtime
+    end
+
+    module Stat
+      def rotation
+        files = [$0, *$LOADED_FEATURES].uniq
+        paths = ['./', *$LOAD_PATH].uniq
+
+        files.map{|file|
+          next if file =~ /\.(so|bundle)$/ # cannot reload compiled files
+
+          found, stat = figure_path(file, paths)
+          next unless found && stat && mtime = stat.mtime
+
+          @cache[file] = found
+
+          yield(found, mtime)
+        }.compact
+      end
+
+      # Takes a relative or absolute +file+ name, a couple possible +paths+ that
+      # the +file+ might reside in. Returns the full path and File::Stat for the
+      # path.
+      def figure_path(file, paths)
+        found = @cache[file]
+        found = file if !found and Pathname.new(file).absolute?
+        found, stat = safe_stat(found)
+        return found, stat if found
+
+        paths.find do |possible_path|
+          path = ::File.join(possible_path, file)
+          found, stat = safe_stat(path)
+          return ::File.expand_path(found), stat if found
+        end
+
+        return false, false
+      end
+
+      def safe_stat(file)
+        return unless file
+        stat = ::File.stat(file)
+        return file, stat if stat.file?
+      rescue Errno::ENOENT, Errno::ENOTDIR, Errno::ESRCH
+        @cache.delete(file) and false
+      end
+    end
+  end
+end