diff options
| author | Simon Brandhof <simon.brandhof@gmail.com> | 2013-09-12 16:18:49 +0200 |
|---|---|---|
| committer | Simon Brandhof <simon.brandhof@gmail.com> | 2013-09-12 16:19:02 +0200 |
| commit | 22faaf0eb1106b8ab9f5e002b05ebcaa0ef00601 (patch) | |
| tree | cd1311af5f9e5f24693df7f638c05d26e474b055 | |
| parent | 8513eb10cbf7fb5c0ac7da63a9907f06299a2f2f (diff) | |
| download | sonarqube-22faaf0eb1106b8ab9f5e002b05ebcaa0ef00601.tar.gz sonarqube-22faaf0eb1106b8ab9f5e002b05ebcaa0ef00601.zip | |
SONAR-4045 Upgrade to JRuby 1.7.4
115 files changed, 47 insertions, 6102 deletions
@@ -942,7 +942,7 @@ <dependency> <groupId>org.jruby</groupId> <artifactId>jruby-complete</artifactId> - <version>1.6.8</version> + <version>1.7.4</version> </dependency> <dependency> <groupId>geronimo-spec</groupId> diff --git a/sonar-application/pom.xml b/sonar-application/pom.xml index 52d2b28ad3f..d59fcc22175 100644 --- a/sonar-application/pom.xml +++ b/sonar-application/pom.xml @@ -227,8 +227,8 @@ <configuration> <rules> <requireFilesSize> - <maxsize>63000000</maxsize> - <minsize>54000000</minsize> + <minsize>64000000</minsize> + <maxsize>68000000</maxsize> <files> <file>${project.build.directory}/sonar-${project.version}.zip</file> </files> diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/KNOWN-ISSUES b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/KNOWN-ISSUES deleted file mode 100755 index a1af5dc1eef..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/KNOWN-ISSUES +++ /dev/null @@ -1,21 +0,0 @@ -= Known issues with Rack and Web servers - -* Lighttpd sets wrong SCRIPT_NAME and PATH_INFO if you mount your - FastCGI app at "/". This can be fixed by using this middleware: - - class LighttpdScriptNameFix - def initialize(app) - @app = app - end - - def call(env) - env["PATH_INFO"] = env["SCRIPT_NAME"].to_s + env["PATH_INFO"].to_s - env["SCRIPT_NAME"] = "" - @app.call(env) - end - end - - Of course, use this only when your app runs at "/". - - Since lighttpd 1.4.23, you also can use the "fix-root-scriptname" flag - in fastcgi.server. diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/RDOX b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/RDOX deleted file mode 100755 index e69de29bb2d..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/RDOX +++ /dev/null diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/README b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/README deleted file mode 100755 index a73a83aadbf..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/README +++ /dev/null @@ -1,407 +0,0 @@ -= Rack, a modular Ruby webserver interface - -Rack provides a minimal, modular and adaptable interface for developing -web applications in Ruby. By wrapping HTTP requests and responses in -the simplest way possible, it unifies and distills the API for web -servers, web frameworks, and software in between (the so-called -middleware) into a single method call. - -The exact details of this are described in the Rack specification, -which all Rack applications should conform to. - -== Specification changes in this release - -With Rack 1.1, the Rack specification (found in SPEC) changed in the -following backward-incompatible ways. - -* Rack::VERSION has been pushed to [1,1]. -* rack.logger is now specified. -* The SPEC now allows subclasses of the required types. -* rack.input has to be opened in binary mode. - -== Supported web servers - -The included *handlers* connect all kinds of web servers to Rack: -* Mongrel -* EventedMongrel -* SwiftipliedMongrel -* WEBrick -* FCGI -* CGI -* SCGI -* LiteSpeed -* Thin - -These web servers include Rack handlers in their distributions: -* Ebb -* Fuzed -* Glassfish v3 -* Phusion Passenger (which is mod_rack for Apache and for nginx) -* Rainbows! -* Unicorn -* Zbatery - -Any valid Rack app will run the same on all these handlers, without -changing anything. - -== Supported web frameworks - -The included *adapters* connect Rack with existing Ruby web frameworks: -* Camping - -These frameworks include Rack adapters in their distributions: -* Camping -* Coset -* Halcyon -* Mack -* Maveric -* Merb -* Racktools::SimpleApplication -* Ramaze -* Ruby on Rails -* Rum -* Sinatra -* Sin -* Vintage -* Waves -* Wee -* ... and many others. - -Current links to these projects can be found at -http://wiki.ramaze.net/Home#other-frameworks - -== Available middleware - -Between the server and the framework, Rack can be customized to your -applications needs using middleware, for example: -* Rack::URLMap, to route to multiple applications inside the same process. -* Rack::CommonLogger, for creating Apache-style logfiles. -* Rack::ShowException, for catching unhandled exceptions and - presenting them in a nice and helpful way with clickable backtrace. -* Rack::File, for serving static files. -* ...many others! - -All these components use the same interface, which is described in -detail in the Rack specification. These optional components can be -used in any way you wish. - -== Convenience - -If you want to develop outside of existing frameworks, implement your -own ones, or develop middleware, Rack provides many helpers to create -Rack applications quickly and without doing the same web stuff all -over: -* Rack::Request, which also provides query string parsing and - multipart handling. -* Rack::Response, for convenient generation of HTTP replies and - cookie handling. -* Rack::MockRequest and Rack::MockResponse for efficient and quick - testing of Rack application without real HTTP round-trips. - -== rack-contrib - -The plethora of useful middleware created the need for a project that -collects fresh Rack middleware. rack-contrib includes a variety of -add-on components for Rack and it is easy to contribute new modules. - -* http://github.com/rack/rack-contrib - -== rackup - -rackup is a useful tool for running Rack applications, which uses the -Rack::Builder DSL to configure middleware and build up applications -easily. - -rackup automatically figures out the environment it is run in, and -runs your application as FastCGI, CGI, or standalone with Mongrel or -WEBrick---all from the same configuration. - -== Quick start - -Try the lobster! - -Either with the embedded WEBrick starter: - - ruby -Ilib lib/rack/lobster.rb - -Or with rackup: - - bin/rackup -Ilib example/lobster.ru - -By default, the lobster is found at http://localhost:9292. - -== Installing with RubyGems - -A Gem of Rack is available at gemcutter.org. You can install it with: - - gem install rack - -I also provide a local mirror of the gems (and development snapshots) -at my site: - - gem install rack --source http://chneukirchen.org/releases/gems/ - -== Running the tests - -Testing Rack requires the test/spec testing framework: - - gem install test-spec - -There are two rake-based test tasks: - - rake test tests all the fast tests (no Handlers or Adapters) - rake fulltest runs all the tests - -The fast testsuite has no dependencies outside of the core Ruby -installation and test-spec. - -To run the test suite completely, you need: - - * camping - * fcgi - * memcache-client - * mongrel - * thin - -The full set of tests test FCGI access with lighttpd (on port -9203) so you will need lighttpd installed as well as the FCGI -libraries and the fcgi gem: - -Download and install lighttpd: - - http://www.lighttpd.net/download - -Installing the FCGI libraries: - - curl -O http://www.fastcgi.com/dist/fcgi-2.4.0.tar.gz - tar xzvf fcgi-2.4.0.tar.gz - cd fcgi-2.4.0 - ./configure --prefix=/usr/local - make - sudo make install - cd .. - -Installing the Ruby fcgi gem: - - gem install fcgi - -Furthermore, to test Memcache sessions, you need memcached (will be -run on port 11211) and memcache-client installed. - -== History - -* March 3rd, 2007: First public release 0.1. - -* May 16th, 2007: Second public release 0.2. - * HTTP Basic authentication. - * Cookie Sessions. - * Static file handler. - * Improved Rack::Request. - * Improved Rack::Response. - * Added Rack::ShowStatus, for better default error messages. - * Bug fixes in the Camping adapter. - * Removed Rails adapter, was too alpha. - -* February 26th, 2008: Third public release 0.3. - * LiteSpeed handler, by Adrian Madrid. - * SCGI handler, by Jeremy Evans. - * Pool sessions, by blink. - * OpenID authentication, by blink. - * :Port and :File options for opening FastCGI sockets, by blink. - * Last-Modified HTTP header for Rack::File, by blink. - * Rack::Builder#use now accepts blocks, by Corey Jewett. - (See example/protectedlobster.ru) - * HTTP status 201 can contain a Content-Type and a body now. - * Many bugfixes, especially related to Cookie handling. - -* August 21st, 2008: Fourth public release 0.4. - * New middleware, Rack::Deflater, by Christoffer Sawicki. - * OpenID authentication now needs ruby-openid 2. - * New Memcache sessions, by blink. - * Explicit EventedMongrel handler, by Joshua Peek <josh@joshpeek.com> - * Rack::Reloader is not loaded in rackup development mode. - * rackup can daemonize with -D. - * Many bugfixes, especially for pool sessions, URLMap, thread safety - and tempfile handling. - * Improved tests. - * Rack moved to Git. - -* January 6th, 2009: Fifth public release 0.9. - * Rack is now managed by the Rack Core Team. - * Rack::Lint is stricter and follows the HTTP RFCs more closely. - * Added ConditionalGet middleware. - * Added ContentLength middleware. - * Added Deflater middleware. - * Added Head middleware. - * Added MethodOverride middleware. - * Rack::Mime now provides popular MIME-types and their extension. - * Mongrel Header now streams. - * Added Thin handler. - * Official support for swiftiplied Mongrel. - * Secure cookies. - * Made HeaderHash case-preserving. - * Many bugfixes and small improvements. - -* January 9th, 2009: Sixth public release 0.9.1. - * Fix directory traversal exploits in Rack::File and Rack::Directory. - -* April 25th, 2009: Seventh public release 1.0.0. - * SPEC change: Rack::VERSION has been pushed to [1,0]. - * SPEC change: header values must be Strings now, split on "\n". - * SPEC change: Content-Length can be missing, in this case chunked transfer - encoding is used. - * SPEC change: rack.input must be rewindable and support reading into - a buffer, wrap with Rack::RewindableInput if it isn't. - * SPEC change: rack.session is now specified. - * SPEC change: Bodies can now additionally respond to #to_path with - a filename to be served. - * NOTE: String bodies break in 1.9, use an Array consisting of a - single String instead. - * New middleware Rack::Lock. - * New middleware Rack::ContentType. - * Rack::Reloader has been rewritten. - * Major update to Rack::Auth::OpenID. - * Support for nested parameter parsing in Rack::Response. - * Support for redirects in Rack::Response. - * HttpOnly cookie support in Rack::Response. - * The Rakefile has been rewritten. - * Many bugfixes and small improvements. - -* October 18th, 2009: Eighth public release 1.0.1. - * Bump remainder of rack.versions. - * Support the pure Ruby FCGI implementation. - * Fix for form names containing "=": split first then unescape components - * Fixes the handling of the filename parameter with semicolons in names. - * Add anchor to nested params parsing regexp to prevent stack overflows - * Use more compatible gzip write api instead of "<<". - * Make sure that Reloader doesn't break when executed via ruby -e - * Make sure WEBrick respects the :Host option - * Many Ruby 1.9 fixes. - -* January 3rd, 2009: Ninth public release 1.1.0. - * Moved Auth::OpenID to rack-contrib. - * SPEC change that relaxes Lint slightly to allow subclasses of the - required types - * SPEC change to document rack.input binary mode in greator detail - * SPEC define optional rack.logger specification - * File servers support X-Cascade header - * Imported Config middleware - * Imported ETag middleware - * Imported Runtime middleware - * Imported Sendfile middleware - * New Logger and NullLogger middlewares - * Added mime type for .ogv and .manifest. - * Don't squeeze PATH_INFO slashes - * Use Content-Type to determine POST params parsing - * Update Rack::Utils::HTTP_STATUS_CODES hash - * Add status code lookup utility - * Response should call #to_i on the status - * Add Request#user_agent - * Request#host knows about forwared host - * Return an empty string for Request#host if HTTP_HOST and - SERVER_NAME are both missing - * Allow MockRequest to accept hash params - * Optimizations to HeaderHash - * Refactored rackup into Rack::Server - * Added Utils.build_nested_query to complement Utils.parse_nested_query - * Added Utils::Multipart.build_multipart to complement - Utils::Multipart.parse_multipart - * Extracted set and delete cookie helpers into Utils so they can be - used outside Response - * Extract parse_query and parse_multipart in Request so subclasses - can change their behavior - * Enforce binary encoding in RewindableInput - * Set correct external_encoding for handlers that don't use RewindableInput - -* March 13th, 2011: Twelfth public release 1.2.2/1.1.2. - * Security fix in Rack::Auth::Digest::MD5: when authenticator - returned nil, permission was granted on empty password. - -* December 28th, 2011: Twenty first public release: 1.1.3. - * Security fix. http://www.ocert.org/advisories/ocert-2011-003.html - Further information here: http://jruby.org/2011/12/27/jruby-1-6-5-1 - -== Contact - -Please post bugs, suggestions and patches to -the bug tracker at <http://rack.lighthouseapp.com/>. - -Mailing list archives are available at -<http://groups.google.com/group/rack-devel>. - -Git repository (send Git patches to the mailing list): -* http://github.com/rack/rack -* http://git.vuxu.org/cgi-bin/gitweb.cgi?p=rack.git - -You are also welcome to join the #rack channel on irc.freenode.net. - -== Thanks - -The Rack Core Team, consisting of - -* Christian Neukirchen (chneukirchen) -* James Tucker (raggi) -* Josh Peek (josh) -* Michael Fellinger (manveru) -* Ryan Tomayko (rtomayko) -* Scytrin dai Kinthra (scytrin) - -would like to thank: - -* Adrian Madrid, for the LiteSpeed handler. -* Christoffer Sawicki, for the first Rails adapter and Rack::Deflater. -* Tim Fletcher, for the HTTP authentication code. -* Luc Heinrich for the Cookie sessions, the static file handler and bugfixes. -* Armin Ronacher, for the logo and racktools. -* Aredridel, Ben Alpert, Dan Kubb, Daniel Roethlisberger, Matt Todd, - Tom Robinson, Phil Hagelberg, S. Brent Faulkner, Bosko Milekic, - Daniel RodrÃguez Troitiño, Genki Takiuchi, Geoffrey Grosenbach, - Julien Sanchez, Kamal Fariz Mahyuddin, Masayoshi Takahashi, Patrick - Aljordm, Mig, and Kazuhiro Nishiyama for bug fixing and other - improvements. -* Eric Wong, Hongli Lai, Jeremy Kemper for their continuous support - and API improvements. -* Yehuda Katz and Carl Lerche for refactoring rackup. -* Brian Candler, for Rack::ContentType. -* Graham Batty, for improved handler loading. -* Stephen Bannasch, for bug reports and documentation. -* Gary Wright, for proposing a better Rack::Response interface. -* Jonathan Buch, for improvements regarding Rack::Response. -* Armin Röhrl, for tracking down bugs in the Cookie generator. -* Alexander Kellett for testing the Gem and reviewing the announcement. -* Marcus Rückert, for help with configuring and debugging lighttpd. -* The WSGI team for the well-done and documented work they've done and - Rack builds up on. -* All bug reporters and patch contributers not mentioned above. - -== Copyright - -Copyright (C) 2007, 2008, 2009, 2010 Christian Neukirchen <http://purl.org/net/chneukirchen> - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to -deal in the Software without restriction, including without limitation the -rights to use, copy, modify, merge, publish, distribute, sublicense, and/or -sell copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL -THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER -IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN -CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - -== Links - -Rack:: <http://rack.rubyforge.org/> -Rack's Rubyforge project:: <http://rubyforge.org/projects/rack> -Official Rack repositories:: <http://github.com/rack> -Rack Lighthouse Bug Tracking:: <http://rack.lighthouseapp.com/> -rack-devel mailing list:: <http://groups.google.com/group/rack-devel> - -Christian Neukirchen:: <http://chneukirchen.org/> - diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/SPEC b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/SPEC deleted file mode 100755 index d2260cbe70f..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/SPEC +++ /dev/null @@ -1,171 +0,0 @@ -This specification aims to formalize the Rack protocol. You -can (and should) use Rack::Lint to enforce it. -When you develop middleware, be sure to add a Lint before and -after to catch all mistakes. -= Rack applications -A Rack application is an Ruby object (not a class) that -responds to +call+. -It takes exactly one argument, the *environment* -and returns an Array of exactly three values: -The *status*, -the *headers*, -and the *body*. -== The Environment -The environment must be an true instance of Hash (no -subclassing allowed) that includes CGI-like headers. -The application is free to modify the environment. -The environment is required to include these variables -(adopted from PEP333), except when they'd be empty, but see -below. -<tt>REQUEST_METHOD</tt>:: The HTTP request method, such as - "GET" or "POST". This cannot ever - be an empty string, and so is - always required. -<tt>SCRIPT_NAME</tt>:: The initial portion of the request - URL's "path" that corresponds to the - application object, so that the - application knows its virtual - "location". This may be an empty - string, if the application corresponds - to the "root" of the server. -<tt>PATH_INFO</tt>:: The remainder of the request URL's - "path", designating the virtual - "location" of the request's target - within the application. This may be an - empty string, if the request URL targets - the application root and does not have a - trailing slash. This value may be - percent-encoded when I originating from - a URL. -<tt>QUERY_STRING</tt>:: The portion of the request URL that - follows the <tt>?</tt>, if any. May be - empty, but is always required! -<tt>SERVER_NAME</tt>, <tt>SERVER_PORT</tt>:: When combined with <tt>SCRIPT_NAME</tt> and <tt>PATH_INFO</tt>, these variables can be used to complete the URL. Note, however, that <tt>HTTP_HOST</tt>, if present, should be used in preference to <tt>SERVER_NAME</tt> for reconstructing the request URL. <tt>SERVER_NAME</tt> and <tt>SERVER_PORT</tt> can never be empty strings, and so are always required. -<tt>HTTP_</tt> Variables:: Variables corresponding to the - client-supplied HTTP request - headers (i.e., variables whose - names begin with <tt>HTTP_</tt>). The - presence or absence of these - variables should correspond with - the presence or absence of the - appropriate HTTP header in the - request. -In addition to this, the Rack environment must include these -Rack-specific variables: -<tt>rack.version</tt>:: The Array [1,1], representing this version of Rack. -<tt>rack.url_scheme</tt>:: +http+ or +https+, depending on the request URL. -<tt>rack.input</tt>:: See below, the input stream. -<tt>rack.errors</tt>:: See below, the error stream. -<tt>rack.multithread</tt>:: true if the application object may be simultaneously invoked by another thread in the same process, false otherwise. -<tt>rack.multiprocess</tt>:: true if an equivalent application object may be simultaneously invoked by another process, false otherwise. -<tt>rack.run_once</tt>:: true if the server expects (but does not guarantee!) that the application will only be invoked this one time during the life of its containing process. Normally, this will only be true for a server based on CGI (or something similar). -Additional environment specifications have approved to -standardized middleware APIs. None of these are required to -be implemented by the server. -<tt>rack.session</tt>:: A hash like interface for storing request session data. - The store must implement: - store(key, value) (aliased as []=); - fetch(key, default = nil) (aliased as []); - delete(key); - clear; -<tt>rack.logger</tt>:: A common object interface for logging messages. - The object must implement: - info(message, &block) - debug(message, &block) - warn(message, &block) - error(message, &block) - fatal(message, &block) -The server or the application can store their own data in the -environment, too. The keys must contain at least one dot, -and should be prefixed uniquely. The prefix <tt>rack.</tt> -is reserved for use with the Rack core distribution and other -accepted specifications and must not be used otherwise. -The environment must not contain the keys -<tt>HTTP_CONTENT_TYPE</tt> or <tt>HTTP_CONTENT_LENGTH</tt> -(use the versions without <tt>HTTP_</tt>). -The CGI keys (named without a period) must have String values. -There are the following restrictions: -* <tt>rack.version</tt> must be an array of Integers. -* <tt>rack.url_scheme</tt> must either be +http+ or +https+. -* There must be a valid input stream in <tt>rack.input</tt>. -* There must be a valid error stream in <tt>rack.errors</tt>. -* The <tt>REQUEST_METHOD</tt> must be a valid token. -* The <tt>SCRIPT_NAME</tt>, if non-empty, must start with <tt>/</tt> -* The <tt>PATH_INFO</tt>, if non-empty, must start with <tt>/</tt> -* The <tt>CONTENT_LENGTH</tt>, if given, must consist of digits only. -* One of <tt>SCRIPT_NAME</tt> or <tt>PATH_INFO</tt> must be - set. <tt>PATH_INFO</tt> should be <tt>/</tt> if - <tt>SCRIPT_NAME</tt> is empty. - <tt>SCRIPT_NAME</tt> never should be <tt>/</tt>, but instead be empty. -=== The Input Stream -The input stream is an IO-like object which contains the raw HTTP -POST data. -When applicable, its external encoding must be "ASCII-8BIT" and it -must be opened in binary mode, for Ruby 1.9 compatibility. -The input stream must respond to +gets+, +each+, +read+ and +rewind+. -* +gets+ must be called without arguments and return a string, - or +nil+ on EOF. -* +read+ behaves like IO#read. Its signature is <tt>read([length, [buffer]])</tt>. - If given, +length+ must be an non-negative Integer (>= 0) or +nil+, and +buffer+ must - be a String and may not be nil. If +length+ is given and not nil, then this method - reads at most +length+ bytes from the input stream. If +length+ is not given or nil, - then this method reads all data until EOF. - When EOF is reached, this method returns nil if +length+ is given and not nil, or "" - if +length+ is not given or is nil. - If +buffer+ is given, then the read data will be placed into +buffer+ instead of a - newly created String object. -* +each+ must be called without arguments and only yield Strings. -* +rewind+ must be called without arguments. It rewinds the input - stream back to the beginning. It must not raise Errno::ESPIPE: - that is, it may not be a pipe or a socket. Therefore, handler - developers must buffer the input data into some rewindable object - if the underlying input stream is not rewindable. -* +close+ must never be called on the input stream. -=== The Error Stream -The error stream must respond to +puts+, +write+ and +flush+. -* +puts+ must be called with a single argument that responds to +to_s+. -* +write+ must be called with a single argument that is a String. -* +flush+ must be called without arguments and must be called - in order to make the error appear for sure. -* +close+ must never be called on the error stream. -== The Response -=== The Status -This is an HTTP status. When parsed as integer (+to_i+), it must be -greater than or equal to 100. -=== The Headers -The header must respond to +each+, and yield values of key and value. -The header keys must be Strings. -The header must not contain a +Status+ key, -contain keys with <tt>:</tt> or newlines in their name, -contain keys names that end in <tt>-</tt> or <tt>_</tt>, -but only contain keys that consist of -letters, digits, <tt>_</tt> or <tt>-</tt> and start with a letter. -The values of the header must be Strings, -consisting of lines (for multiple header values, e.g. multiple -<tt>Set-Cookie</tt> values) seperated by "\n". -The lines must not contain characters below 037. -=== The Content-Type -There must be a <tt>Content-Type</tt>, except when the -+Status+ is 1xx, 204 or 304, in which case there must be none -given. -=== The Content-Length -There must not be a <tt>Content-Length</tt> header when the -+Status+ is 1xx, 204 or 304. -=== The Body -The Body must respond to +each+ -and must only yield String values. -The Body itself should not be an instance of String, as this will -break in Ruby 1.9. -If the Body responds to +close+, it will be called after iteration. -If the Body responds to +to_path+, it must return a String -identifying the location of a file whose contents are identical -to that produced by calling +each+; this may be used by the -server as an alternative, possibly more efficient way to -transport the response. -The Body commonly is an Array of Strings, the application -instance itself, or a File-like object. -== Thanks -Some parts of this specification are adopted from PEP333: Python -Web Server Gateway Interface -v1.0 (http://www.python.org/dev/peps/pep-0333/). I'd like to thank -everyone involved in that effort. diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/bin/rackup b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/bin/rackup deleted file mode 100755 index ad94af4be3b..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/bin/rackup +++ /dev/null @@ -1,4 +0,0 @@ -#!/usr/bin/env ruby - -require "rack" -Rack::Server.start diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/contrib/rack_logo.svg b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/contrib/rack_logo.svg deleted file mode 100755 index 905dcd32b45..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/contrib/rack_logo.svg +++ /dev/null @@ -1,111 +0,0 @@ -<?xml version="1.0" encoding="UTF-8" standalone="no"?> -<!-- Created with Inkscape (http://www.inkscape.org/) - by Armin Ronacher (mitsuhiko), MIT-licensed. ---> -<svg - xmlns:dc="http://purl.org/dc/elements/1.1/" - xmlns:cc="http://web.resource.org/cc/" - xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" - xmlns:svg="http://www.w3.org/2000/svg" - xmlns="http://www.w3.org/2000/svg" - xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" - xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" - width="200" - height="100" - id="svg2" - sodipodi:version="0.32" - inkscape:version="0.44" - version="1.0" - inkscape:export-filename="/home/blackbird/Desktop/rack_logo_final.png" - inkscape:export-xdpi="360" - inkscape:export-ydpi="360" - sodipodi:docbase="/home/blackbird/Desktop" - sodipodi:docname="rack_logo.svg"> - <defs - id="defs4" /> - <sodipodi:namedview - id="base" - pagecolor="#ffffff" - bordercolor="#666666" - borderopacity="1.0" - gridtolerance="10000" - guidetolerance="10" - objecttolerance="10" - inkscape:pageopacity="0.0" - inkscape:pageshadow="2" - inkscape:zoom="3.959798" - inkscape:cx="148.56163" - inkscape:cy="67.007749" - inkscape:document-units="px" - inkscape:current-layer="layer1" - width="200px" - height="100px" - inkscape:window-width="1400" - inkscape:window-height="975" - inkscape:window-x="0" - inkscape:window-y="24" /> - <metadata - id="metadata7"> - <rdf:RDF> - <cc:Work - rdf:about=""> - <dc:format>image/svg+xml</dc:format> - <dc:type - rdf:resource="http://purl.org/dc/dcmitype/StillImage" /> - </cc:Work> - </rdf:RDF> - </metadata> - <g - inkscape:label="Layer 1" - inkscape:groupmode="layer" - id="layer1"> - <path - style="font-size:33.17043304px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:black;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Frutiger" - d="M 102.28876,57.97848 L 102.28876,64.972684 C 101.77662,64.784857 101.19214,64.690938 100.5353,64.690927 C 99.767107,64.690938 99.026757,64.873251 98.314248,65.237867 C 97.612848,65.591455 97.056197,66.050001 96.644288,66.613505 C 96.343688,67.022337 96.121018,67.541654 95.976308,68.171455 C 95.876091,68.558187 95.826008,69.094078 95.826016,69.779128 L 95.826016,75.861765 L 87.125504,75.861765 L 87.125504,58.144219 L 95.274924,58.144219 L 95.274924,62.105392 C 95.987422,60.569555 96.783437,59.481201 97.662958,58.840325 C 98.542463,58.188434 99.622368,57.86248 100.90268,57.862463 C 101.30345,57.86248 101.76548,57.901153 102.28876,57.97848 M 115.63175,75.861765 L 115.63175,73.342526 C 114.26238,75.364548 112.21945,76.375557 109.50299,76.375558 C 107.49902,76.375557 105.94039,75.86729 104.82709,74.850755 C 103.71379,73.834221 103.15714,72.552504 103.15714,71.0056 C 103.15714,69.867528 103.41875,68.867568 103.94202,68.005716 C 104.4764,67.13283 105.22231,66.431201 106.17978,65.900825 C 106.79207,65.558307 107.65489,65.276551 108.7682,65.055554 C 109.89264,64.82353 111.22861,64.707512 112.7761,64.707501 C 113.47749,64.707512 114.37371,64.735135 115.46475,64.790371 C 115.44246,63.994833 115.12518,63.353974 114.51288,62.867793 C 113.90056,62.381638 112.86517,62.138553 111.40674,62.13854 C 110.47156,62.138553 109.50298,62.254571 108.50101,62.486592 C 107.76623,62.663395 106.66962,63.05012 105.21119,63.646768 L 105.21119,58.740881 C 106.54715,58.365223 107.78292,58.10004 108.91851,57.945332 C 110.05407,57.79066 111.31211,57.713315 112.69263,57.713297 C 114.85243,57.713315 116.71722,57.912202 118.28699,58.309959 C 119.05515,58.497815 119.76766,58.79062 120.42454,59.188378 C 121.08138,59.586169 121.59907,60.02814 121.97762,60.514293 C 122.36724,60.989428 122.68454,61.591614 122.9295,62.320853 C 123.18553,63.05012 123.31357,64.055605 123.31358,65.33731 L 123.31358,75.861765 L 115.63175,75.861765 M 115.69855,67.972568 C 114.30691,67.961526 113.33832,68.011249 112.79282,68.121734 C 112.24727,68.232234 111.81866,68.469793 111.50693,68.834413 C 111.19522,69.199047 111.03934,69.613395 111.03935,70.077459 C 111.03934,70.574683 111.22861,71.005604 111.60714,71.370227 C 111.98566,71.723808 112.44768,71.900596 112.99322,71.900593 C 113.67231,71.900596 114.29577,71.607791 114.86358,71.022173 C 115.43134,70.436566 115.71525,69.596821 115.71525,68.502934 C 115.71525,68.381399 115.70968,68.20461 115.69855,67.972568 M 142.55155,58.376254 L 142.55155,63.646768 C 141.04855,63.03907 139.76826,62.735215 138.71063,62.735202 C 137.41918,62.735215 136.38381,63.110891 135.6045,63.86223 C 134.82518,64.613593 134.43552,65.59698 134.43553,66.812392 C 134.43552,68.171463 134.82518,69.248768 135.6045,70.044311 C 136.39494,70.828816 137.46928,71.221066 138.82753,71.221061 C 139.92968,71.221066 141.22114,70.867489 142.70184,70.160328 L 142.70184,75.46399 C 140.50862,76.071702 138.34322,76.375557 136.20569,76.375558 C 134.44665,76.375557 132.80452,76.115898 131.27929,75.596582 C 130.13258,75.209858 129.13618,74.646344 128.29007,73.90604 C 127.45508,73.15469 126.80936,72.325994 126.35291,71.419948 C 125.69606,70.116137 125.36763,68.646582 125.36763,67.011279 C 125.36763,63.89539 126.52547,61.459022 128.84117,59.70217 C 130.66698,58.309976 133.14964,57.613871 136.2892,57.613853 C 138.47127,57.613871 140.55871,57.868005 142.55155,58.376254 M 154.2413,65.221293 L 159.21776,58.144219 L 168.95366,58.144219 L 162.94178,66.000268 L 169.20414,75.861765 L 159.13426,75.861765 L 154.2413,67.259888 L 154.2413,75.861765 L 145.52407,75.861765 L 145.52407,50.255022 L 154.2413,50.255022 L 154.2413,65.221293" - id="text2980" /> - <path - style="font-size:9.72235012px;font-style:normal;font-variant:normal;font-weight:300;font-stretch:normal;text-align:start;line-height:125%;writing-mode:lr-tb;text-anchor:start;fill:black;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;font-family:Frutiger45-Light" - d="M 87.460353,88.057465 L 88.081744,88.057465 L 88.081744,85.211201 L 88.101471,85.211201 C 88.259282,85.530647 88.463124,85.770232 88.712998,85.929955 C 88.962867,86.083288 89.281782,86.159955 89.669743,86.159955 C 90.33387,86.159955 90.843476,85.923565 91.198561,85.450785 C 91.560211,84.971618 91.741039,84.355087 91.741044,83.601194 C 91.741039,82.815359 91.579938,82.202023 91.25774,81.761184 C 91.086772,81.531188 90.869779,81.355493 90.60676,81.234098 C 90.343734,81.106325 90.031395,81.042436 89.669743,81.042431 C 89.43302,81.042436 89.222602,81.077575 89.038488,81.147848 C 88.85437,81.211743 88.699845,81.294798 88.574911,81.397016 C 88.456549,81.499244 88.361203,81.601466 88.288874,81.703684 C 88.216541,81.799522 88.147498,81.901745 88.081744,82.010353 L 88.062018,82.048686 L 88.042291,82.048686 L 88.081744,81.157431 L 87.460353,81.157431 L 87.460353,88.057465 M 91.060474,83.601194 C 91.06047,83.863141 91.037455,84.112309 90.991431,84.348697 C 90.945397,84.585088 90.863203,84.802312 90.744847,85.000367 C 90.633058,85.192035 90.478533,85.348563 90.281269,85.469952 C 90.090575,85.584954 89.853854,85.642454 89.571109,85.642453 C 89.308084,85.642454 89.081227,85.581759 88.890538,85.460369 C 88.699845,85.33898 88.545319,85.179258 88.426961,84.9812 C 88.308599,84.776755 88.219829,84.556338 88.160651,84.319947 C 88.108045,84.077169 88.081743,83.837586 88.081744,83.601194 C 88.081743,83.364806 88.108045,83.128416 88.160651,82.892023 C 88.219829,82.649248 88.305311,82.42883 88.417097,82.23077 C 88.535456,82.026329 88.689981,81.863412 88.880675,81.742018 C 89.077939,81.620632 89.308084,81.559938 89.571109,81.559933 C 89.853854,81.559938 90.090575,81.620632 90.281269,81.742018 C 90.478533,81.857022 90.633058,82.01355 90.744847,82.211603 C 90.863203,82.403275 90.945397,82.617303 90.991431,82.853689 C 91.037455,83.090082 91.06047,83.33925 91.060474,83.601194 M 92.509615,83.601194 C 92.509614,83.939808 92.555643,84.265642 92.647702,84.578698 C 92.746334,84.885367 92.890996,85.156896 93.081688,85.393285 C 93.272378,85.629676 93.515674,85.818149 93.811576,85.958705 C 94.11405,86.092872 94.462554,86.159955 94.85709,86.159955 C 95.251621,86.159955 95.596838,86.092872 95.892741,85.958705 C 96.195213,85.818149 96.441797,85.629676 96.632492,85.393285 C 96.823179,85.150508 96.964554,84.875783 97.056616,84.569114 C 97.155245,84.262449 97.204561,83.939808 97.204567,83.601194 C 97.204561,83.262583 97.155245,82.939944 97.056616,82.633272 C 96.964554,82.320218 96.823179,82.045495 96.632492,81.809101 C 96.441797,81.572716 96.195213,81.387438 95.892741,81.253266 C 95.596838,81.112714 95.251621,81.042436 94.85709,81.042431 C 94.462554,81.042436 94.117338,81.112714 93.821439,81.253266 C 93.525538,81.387438 93.278954,81.575911 93.081688,81.818685 C 92.890996,82.055079 92.746334,82.326608 92.647702,82.633272 C 92.555643,82.939944 92.509614,83.262583 92.509615,83.601194 M 93.190185,83.601194 C 93.190184,83.013416 93.334846,82.527858 93.624172,82.144519 C 93.920071,81.7548 94.331043,81.559938 94.85709,81.559933 C 95.383132,81.559938 95.790816,81.7548 96.080145,82.144519 C 96.376041,82.527858 96.523991,83.013416 96.523995,83.601194 C 96.523991,84.188976 96.376041,84.677727 96.080145,85.06745 C 95.790816,85.450786 95.383132,85.642454 94.85709,85.642453 C 94.331043,85.642454 93.920071,85.450786 93.624172,85.06745 C 93.334846,84.677727 93.190184,84.188976 93.190185,83.601194 M 105.09447,81.157431 L 104.47308,81.157431 L 103.08235,85.383702 L 103.06262,85.383702 L 101.73107,81.157431 L 100.98146,81.157431 L 99.580861,85.383702 L 99.561135,85.383702 L 98.239447,81.157431 L 97.558876,81.157431 L 99.176464,86.044955 L 99.926079,86.044955 L 101.29708,81.818685 L 101.31681,81.818685 L 102.68781,86.044955 L 103.43743,86.044955 L 105.09447,81.157431 M 109.15539,85.278285 C 109.00415,85.374119 108.78387,85.460369 108.49455,85.537035 C 108.2118,85.607314 107.96192,85.642454 107.74493,85.642453 C 107.22547,85.642454 106.81778,85.466758 106.52188,85.115367 C 106.23255,84.763978 106.0879,84.316754 106.0879,83.773694 L 109.5302,83.773694 L 109.5302,83.467026 C 109.5302,83.128416 109.49075,82.815359 109.41184,82.527854 C 109.33293,82.233968 109.21128,81.975217 109.04689,81.751601 C 108.88908,81.527994 108.68195,81.355493 108.42551,81.234098 C 108.16905,81.106325 107.86987,81.042436 107.52794,81.042431 C 107.21889,81.042436 106.93285,81.106325 106.66983,81.234098 C 106.4068,81.355493 106.17995,81.531188 105.98927,81.761184 C 105.80514,81.99119 105.66049,82.262718 105.55527,82.575772 C 105.45664,82.888832 105.40733,83.230639 105.40733,83.601194 C 105.40733,83.978141 105.45007,84.323142 105.53555,84.636199 C 105.62103,84.942868 105.75254,85.211201 105.93008,85.441202 C 106.11419,85.671204 106.35091,85.850093 106.64024,85.977872 C 106.93614,86.09926 107.28793,86.159955 107.69562,86.159955 C 107.93891,86.159955 108.18879,86.1344 108.44523,86.083288 C 108.70825,86.038566 108.94498,85.974677 109.15539,85.89162 L 109.15539,85.278285 M 106.0879,83.256192 C 106.0879,83.051749 106.12078,82.850499 106.18652,82.652439 C 106.25886,82.447997 106.35749,82.262718 106.48242,82.096603 C 106.61393,81.930495 106.77175,81.799522 106.95587,81.703684 C 107.13998,81.607855 107.34383,81.559938 107.56739,81.559933 C 107.79096,81.559938 107.98494,81.607855 108.14933,81.703684 C 108.31372,81.793134 108.44523,81.917717 108.54386,82.077436 C 108.64908,82.237163 108.72469,82.419247 108.77073,82.623689 C 108.82333,82.821749 108.84962,83.032582 108.84963,83.256192 L 106.0879,83.256192 M 110.61748,86.044955 L 111.23887,86.044955 L 111.23887,83.629944 C 111.23887,83.387167 111.2586,83.153972 111.29805,82.930357 C 111.33751,82.700359 111.40654,82.492719 111.50518,82.307437 C 111.60381,82.115773 111.73204,81.96244 111.88985,81.847435 C 112.05424,81.732439 112.25479,81.674939 112.49151,81.674934 C 112.66905,81.674939 112.82029,81.694105 112.94523,81.732434 L 112.94523,81.099931 C 112.88604,81.08077 112.81372,81.067992 112.72824,81.061598 C 112.64933,81.048825 112.57699,81.042436 112.51124,81.042431 C 112.21533,81.042436 111.9556,81.141464 111.73204,81.339516 C 111.51504,81.537577 111.34408,81.789939 111.21914,82.096603 L 111.19941,82.096603 L 111.19941,81.157431 L 110.57803,81.157431 C 110.59775,81.323548 110.60761,81.473688 110.60761,81.607851 C 110.61419,81.735634 110.61748,81.949662 110.61748,82.249937 L 110.61748,86.044955 M 113.39078,85.929955 C 113.78531,86.083288 114.25546,86.159955 114.80123,86.159955 C 115.00507,86.159955 115.20892,86.1344 115.41276,86.083288 C 115.61661,86.032177 115.804,85.952315 115.97497,85.843704 C 116.15251,85.735092 116.29389,85.591342 116.3991,85.412452 C 116.5043,85.233563 116.55691,85.019535 116.55691,84.770365 C 116.55691,84.553144 116.51417,84.361476 116.42868,84.195362 C 116.3432,84.029253 116.22813,83.888696 116.08347,83.773694 C 115.94537,83.652307 115.79743,83.553278 115.63961,83.476609 C 115.48838,83.393556 115.2944,83.300917 115.05769,83.198691 C 114.72232,83.051749 114.47575,82.920776 114.31793,82.805773 C 114.16012,82.690776 114.08121,82.547025 114.08121,82.374521 C 114.08121,82.080635 114.17326,81.872995 114.35738,81.751601 C 114.54807,81.623827 114.81767,81.559938 115.16618,81.559933 C 115.33714,81.559938 115.52454,81.582299 115.72839,81.627018 C 115.9388,81.665355 116.12292,81.719661 116.28074,81.789935 L 116.33991,81.262849 C 116.13607,81.186186 115.91579,81.131881 115.67907,81.099931 C 115.44893,81.061603 115.25495,81.042436 115.09713,81.042431 C 114.88014,81.042436 114.67301,81.067992 114.47575,81.119098 C 114.28505,81.163826 114.1108,81.240493 113.95298,81.349099 C 113.80175,81.457716 113.6801,81.598272 113.58805,81.770768 C 113.50256,81.936884 113.45981,82.138135 113.45981,82.374521 C 113.45981,82.547025 113.49598,82.703554 113.56832,82.844106 C 113.64065,82.978277 113.73599,83.096472 113.85435,83.198691 C 113.97272,83.300917 114.09765,83.387167 114.22916,83.457442 C 114.36725,83.527723 114.54478,83.61078 114.76178,83.706611 C 115.13658,83.879113 115.41605,84.038836 115.60016,84.185779 C 115.78428,84.326337 115.87634,84.521199 115.87634,84.770365 C 115.87634,85.038701 115.76784,85.25273 115.55085,85.412452 C 115.33385,85.565786 115.07083,85.642454 114.76178,85.642453 C 114.30807,85.642454 113.87079,85.540231 113.44995,85.335785 L 113.39078,85.929955 M 127.11361,81.157431 L 126.49222,81.157431 L 125.10149,85.383702 L 125.08177,85.383702 L 123.75021,81.157431 L 123.0006,81.157431 L 121.60001,85.383702 L 121.58027,85.383702 L 120.25859,81.157431 L 119.57802,81.157431 L 121.19561,86.044955 L 121.94522,86.044955 L 123.31623,81.818685 L 123.33595,81.818685 L 124.70696,86.044955 L 125.45657,86.044955 L 127.11361,81.157431 M 131.17454,85.278285 C 131.0233,85.374119 130.80301,85.460369 130.51369,85.537035 C 130.23094,85.607314 129.98107,85.642454 129.76408,85.642453 C 129.2446,85.642454 128.83693,85.466758 128.54103,85.115367 C 128.2517,84.763978 128.10703,84.316754 128.10704,83.773694 L 131.54935,83.773694 L 131.54935,83.467026 C 131.54934,83.128416 131.50988,82.815359 131.43099,82.527854 C 131.35207,82.233968 131.23043,81.975217 131.06604,81.751601 C 130.90822,81.527994 130.70109,81.355493 130.44465,81.234098 C 130.1882,81.106325 129.88901,81.042436 129.54709,81.042431 C 129.23803,81.042436 128.95199,81.106325 128.68897,81.234098 C 128.42595,81.355493 128.1991,81.531188 128.0084,81.761184 C 127.82429,81.99119 127.67962,82.262718 127.57442,82.575772 C 127.47578,82.888832 127.42646,83.230639 127.42646,83.601194 C 127.42646,83.978141 127.4692,84.323142 127.55469,84.636199 C 127.64017,84.942868 127.77168,85.211201 127.94923,85.441202 C 128.13334,85.671204 128.37006,85.850093 128.65939,85.977872 C 128.95529,86.09926 129.30708,86.159955 129.71476,86.159955 C 129.95805,86.159955 130.20792,86.1344 130.46438,86.083288 C 130.7274,86.038566 130.96411,85.974677 131.17454,85.89162 L 131.17454,85.278285 M 128.10704,83.256192 C 128.10703,83.051749 128.13991,82.850499 128.20567,82.652439 C 128.278,82.447997 128.37664,82.262718 128.50157,82.096603 C 128.63308,81.930495 128.7909,81.799522 128.97501,81.703684 C 129.15912,81.607855 129.36297,81.559938 129.58654,81.559933 C 129.81011,81.559938 130.00408,81.607855 130.16848,81.703684 C 130.33286,81.793134 130.46437,81.917717 130.56301,82.077436 C 130.66821,82.237163 130.74383,82.419247 130.78986,82.623689 C 130.84246,82.821749 130.86877,83.032582 130.86877,83.256192 L 128.10704,83.256192 M 132.57745,86.044955 L 133.19884,86.044955 L 133.19884,85.268702 L 133.21856,85.268702 C 133.54077,85.862871 134.06352,86.159955 134.78684,86.159955 C 135.45096,86.159955 135.96057,85.923565 136.31565,85.450785 C 136.6773,84.971618 136.85813,84.355087 136.85814,83.601194 C 136.85813,82.815359 136.69703,82.202023 136.37483,81.761184 C 136.20386,81.531188 135.98687,81.355493 135.72385,81.234098 C 135.46082,81.106325 135.14849,81.042436 134.78684,81.042431 C 134.55669,81.042436 134.34627,81.077575 134.15558,81.147848 C 133.97146,81.218131 133.81365,81.304381 133.68214,81.4066 C 133.55063,81.508827 133.44542,81.611049 133.36651,81.713268 C 133.29418,81.815494 133.24487,81.904939 133.21856,81.981603 L 133.19884,81.981603 L 133.19884,78.85742 L 132.57745,78.85742 L 132.57745,86.044955 M 136.17757,83.601194 C 136.17756,83.863141 136.15455,84.112309 136.10852,84.348697 C 136.06249,84.585088 135.9803,84.802312 135.86194,85.000367 C 135.75015,85.192035 135.59563,85.348563 135.39836,85.469952 C 135.20766,85.584954 134.97095,85.642454 134.6882,85.642453 C 134.42518,85.642454 134.19832,85.581759 134.00763,85.460369 C 133.81693,85.33898 133.66241,85.179258 133.54405,84.9812 C 133.42569,84.776755 133.33692,84.556338 133.27775,84.319947 C 133.22513,84.077169 133.19884,83.837586 133.19884,83.601194 C 133.19884,83.358417 133.22513,83.118832 133.27775,82.882439 C 133.33035,82.646053 133.41254,82.42883 133.52433,82.23077 C 133.64268,82.026329 133.79721,81.863412 133.98791,81.742018 C 134.18517,81.620632 134.4186,81.559938 134.6882,81.559933 C 134.97095,81.559938 135.20766,81.620632 135.39836,81.742018 C 135.59563,81.857022 135.75015,82.01355 135.86194,82.211603 C 135.9803,82.403275 136.06249,82.617303 136.10852,82.853689 C 136.15455,83.090082 136.17756,83.33925 136.17757,83.601194 M 143.57908,86.044955 L 144.1906,86.044955 C 144.17087,85.891621 144.15772,85.744676 144.15115,85.60412 C 144.14457,85.463564 144.14129,85.268702 144.14129,85.019534 L 144.14129,82.863273 C 144.14129,82.224385 144.0032,81.761189 143.72703,81.473683 C 143.45085,81.186186 143.00043,81.042436 142.37575,81.042431 C 142.15876,81.042436 141.9056,81.077575 141.61627,81.147848 C 141.32695,81.211743 141.08694,81.288409 140.89625,81.377849 L 140.89625,81.962436 C 141.33023,81.694105 141.8234,81.559938 142.37575,81.559933 C 142.78344,81.559938 143.07605,81.662161 143.25359,81.866601 C 143.43113,82.071051 143.51989,82.387303 143.51989,82.815356 L 143.51989,83.064524 L 143.40154,83.064524 C 142.9807,83.064527 142.6026,83.080499 142.26726,83.112441 C 141.93848,83.144389 141.62285,83.214667 141.32037,83.323276 C 141.0179,83.43189 140.77131,83.60439 140.58062,83.840777 C 140.39651,84.077169 140.30445,84.390227 140.30445,84.779949 C 140.30445,84.914117 140.32417,85.057868 140.36363,85.211201 C 140.40965,85.364536 140.49185,85.514675 140.61021,85.66162 C 140.72857,85.802177 140.89954,85.920372 141.1231,86.016205 C 141.34667,86.112038 141.62613,86.159955 141.96149,86.159955 C 142.29027,86.159955 142.60589,86.080094 142.90837,85.920371 C 143.21085,85.760649 143.42784,85.540231 143.55935,85.259118 L 143.57908,85.259118 L 143.57908,86.044955 M 143.51989,83.879111 C 143.51989,84.077169 143.50675,84.265642 143.48044,84.444531 C 143.46072,84.623422 143.40153,84.805506 143.3029,84.990783 C 143.21085,85.176063 143.0596,85.332591 142.84919,85.460369 C 142.64534,85.581759 142.37246,85.642454 142.03053,85.642453 C 141.72148,85.642454 141.46832,85.572176 141.27106,85.431619 C 141.08036,85.284674 140.98502,85.061063 140.98502,84.760782 C 140.98502,84.505227 141.05077,84.297587 141.18229,84.137862 C 141.32037,83.978141 141.5012,83.859946 141.72477,83.783277 C 141.95491,83.700224 142.2015,83.645918 142.46452,83.62036 C 142.72754,83.594807 143.02015,83.582028 143.34236,83.582027 L 143.51989,83.582027 L 143.51989,83.879111 M 145.46529,88.057465 L 146.08668,88.057465 L 146.08668,85.211201 L 146.10641,85.211201 C 146.26422,85.530647 146.46806,85.770232 146.71794,85.929955 C 146.9678,86.083288 147.28672,86.159955 147.67468,86.159955 C 148.33881,86.159955 148.84841,85.923565 149.2035,85.450785 C 149.56515,84.971618 149.74597,84.355087 149.74598,83.601194 C 149.74597,82.815359 149.58487,82.202023 149.26268,81.761184 C 149.09171,81.531188 148.87472,81.355493 148.6117,81.234098 C 148.34867,81.106325 148.03634,81.042436 147.67468,81.042431 C 147.43795,81.042436 147.22753,81.077575 147.04342,81.147848 C 146.85931,81.211743 146.70478,81.294798 146.57985,81.397016 C 146.46148,81.499244 146.36614,81.601466 146.29381,81.703684 C 146.22148,81.799522 146.15244,81.901745 146.08668,82.010353 L 146.06695,82.048686 L 146.04723,82.048686 L 146.08668,81.157431 L 145.46529,81.157431 L 145.46529,88.057465 M 149.06541,83.601194 C 149.06541,83.863141 149.04239,84.112309 148.99637,84.348697 C 148.95033,84.585088 148.86814,84.802312 148.74978,85.000367 C 148.638,85.192035 148.48347,85.348563 148.28621,85.469952 C 148.09551,85.584954 147.85879,85.642454 147.57605,85.642453 C 147.31302,85.642454 147.08616,85.581759 146.89548,85.460369 C 146.70478,85.33898 146.55025,85.179258 146.4319,84.9812 C 146.31354,84.776755 146.22477,84.556338 146.16558,84.319947 C 146.11298,84.077169 146.08668,83.837586 146.08668,83.601194 C 146.08668,83.364806 146.11298,83.128416 146.16558,82.892023 C 146.22477,82.649248 146.31025,82.42883 146.42203,82.23077 C 146.54039,82.026329 146.69492,81.863412 146.88562,81.742018 C 147.08288,81.620632 147.31302,81.559938 147.57605,81.559933 C 147.85879,81.559938 148.09551,81.620632 148.28621,81.742018 C 148.48347,81.857022 148.638,82.01355 148.74978,82.211603 C 148.86814,82.403275 148.95033,82.617303 148.99637,82.853689 C 149.04239,83.090082 149.06541,83.33925 149.06541,83.601194 M 150.84004,88.057465 L 151.46144,88.057465 L 151.46144,85.211201 L 151.48116,85.211201 C 151.63897,85.530647 151.84281,85.770232 152.09269,85.929955 C 152.34255,86.083288 152.66147,86.159955 153.04943,86.159955 C 153.71356,86.159955 154.22316,85.923565 154.57825,85.450785 C 154.9399,84.971618 155.12072,84.355087 155.12073,83.601194 C 155.12072,82.815359 154.95962,82.202023 154.63743,81.761184 C 154.46646,81.531188 154.24947,81.355493 153.98645,81.234098 C 153.72342,81.106325 153.41109,81.042436 153.04943,81.042431 C 152.8127,81.042436 152.60228,81.077575 152.41817,81.147848 C 152.23406,81.211743 152.07953,81.294798 151.9546,81.397016 C 151.83623,81.499244 151.74089,81.601466 151.66856,81.703684 C 151.59623,81.799522 151.52719,81.901745 151.46144,82.010353 L 151.4417,82.048686 L 151.42198,82.048686 L 151.46144,81.157431 L 150.84004,81.157431 L 150.84004,88.057465 M 154.44016,83.601194 C 154.44016,83.863141 154.41715,84.112309 154.37112,84.348697 C 154.32508,84.585088 154.24289,84.802312 154.12453,85.000367 C 154.01275,85.192035 153.85822,85.348563 153.66096,85.469952 C 153.47026,85.584954 153.23354,85.642454 152.9508,85.642453 C 152.68777,85.642454 152.46091,85.581759 152.27023,85.460369 C 152.07953,85.33898 151.925,85.179258 151.80665,84.9812 C 151.68829,84.776755 151.59952,84.556338 151.54033,84.319947 C 151.48773,84.077169 151.46143,83.837586 151.46144,83.601194 C 151.46143,83.364806 151.48773,83.128416 151.54033,82.892023 C 151.59952,82.649248 151.685,82.42883 151.79679,82.23077 C 151.91514,82.026329 152.06967,81.863412 152.26037,81.742018 C 152.45763,81.620632 152.68777,81.559938 152.9508,81.559933 C 153.23354,81.559938 153.47026,81.620632 153.66096,81.742018 C 153.85822,81.857022 154.01275,82.01355 154.12453,82.211603 C 154.24289,82.403275 154.32508,82.617303 154.37112,82.853689 C 154.41715,83.090082 154.44016,83.33925 154.44016,83.601194 M 156.27397,86.044955 L 156.89536,86.044955 L 156.89536,78.85742 L 156.27397,78.85742 L 156.27397,86.044955 M 158.43157,86.044955 L 159.05296,86.044955 L 159.05296,81.157431 L 158.43157,81.157431 L 158.43157,86.044955 M 159.05296,79.049088 L 158.43157,79.049088 L 158.43157,79.854092 L 159.05296,79.854092 L 159.05296,79.049088 M 163.91314,81.234098 C 163.7619,81.182993 163.58435,81.13827 163.38052,81.099931 C 163.18325,81.061603 162.95638,81.042436 162.69995,81.042431 C 162.33171,81.042436 161.99307,81.106325 161.68401,81.234098 C 161.38154,81.355493 161.11852,81.531188 160.89496,81.761184 C 160.67795,81.9848 160.51028,82.25633 160.39192,82.575772 C 160.27356,82.888832 160.21438,83.230639 160.21438,83.601194 C 160.21438,83.946197 160.2637,84.275226 160.36233,84.588282 C 160.46754,84.89495 160.61878,85.166479 160.81605,85.402869 C 161.01989,85.639259 161.27305,85.824537 161.57552,85.958705 C 161.88457,86.092872 162.23307,86.159955 162.62104,86.159955 C 162.87749,86.159955 163.10762,86.147178 163.31147,86.121622 C 163.51531,86.102455 163.71586,86.057733 163.91314,85.987455 L 163.85395,85.422035 C 163.44627,85.568981 163.06817,85.642454 162.71967,85.642453 C 162.44349,85.642454 162.19033,85.591342 161.96019,85.489119 C 161.73663,85.380508 161.54593,85.233563 161.38812,85.048284 C 161.23031,84.856617 161.10866,84.639394 161.02318,84.396614 C 160.9377,84.147448 160.89496,83.882308 160.89496,83.601194 C 160.89496,82.994249 161.06263,82.502303 161.39799,82.125353 C 161.73333,81.748411 162.19691,81.559938 162.78872,81.559933 C 162.94652,81.559938 163.12077,81.582299 163.31147,81.627018 C 163.50215,81.671744 163.68628,81.732439 163.86381,81.809101 L 163.91314,81.234098 M 167.77509,86.044955 L 168.38662,86.044955 C 168.36688,85.891621 168.35374,85.744676 168.34716,85.60412 C 168.34059,85.463564 168.3373,85.268702 168.3373,85.019534 L 168.3373,82.863273 C 168.3373,82.224385 168.19921,81.761189 167.92304,81.473683 C 167.64686,81.186186 167.19644,81.042436 166.57176,81.042431 C 166.35477,81.042436 166.10161,81.077575 165.81229,81.147848 C 165.52296,81.211743 165.28295,81.288409 165.09226,81.377849 L 165.09226,81.962436 C 165.52625,81.694105 166.01942,81.559938 166.57176,81.559933 C 166.97945,81.559938 167.27205,81.662161 167.4496,81.866601 C 167.62714,82.071051 167.71591,82.387303 167.71591,82.815356 L 167.71591,83.064524 L 167.59756,83.064524 C 167.17671,83.064527 166.79862,83.080499 166.46327,83.112441 C 166.13448,83.144389 165.81886,83.214667 165.51639,83.323276 C 165.21391,83.43189 164.96733,83.60439 164.77663,83.840777 C 164.59252,84.077169 164.50047,84.390227 164.50047,84.779949 C 164.50047,84.914117 164.52019,85.057868 164.55964,85.211201 C 164.60567,85.364536 164.68786,85.514675 164.80623,85.66162 C 164.92459,85.802177 165.09555,85.920372 165.31912,86.016205 C 165.54268,86.112038 165.82215,86.159955 166.1575,86.159955 C 166.48628,86.159955 166.8019,86.080094 167.10439,85.920371 C 167.40686,85.760649 167.62385,85.540231 167.75536,85.259118 L 167.77509,85.259118 L 167.77509,86.044955 M 167.71591,83.879111 C 167.71591,84.077169 167.70276,84.265642 167.67645,84.444531 C 167.65673,84.623422 167.59755,84.805506 167.49892,84.990783 C 167.40686,85.176063 167.25562,85.332591 167.0452,85.460369 C 166.84136,85.581759 166.56848,85.642454 166.22655,85.642453 C 165.91749,85.642454 165.66433,85.572176 165.46707,85.431619 C 165.27638,85.284674 165.18103,85.061063 165.18103,84.760782 C 165.18103,84.505227 165.24678,84.297587 165.3783,84.137862 C 165.51639,83.978141 165.69721,83.859946 165.92079,83.783277 C 166.15093,83.700224 166.39751,83.645918 166.66053,83.62036 C 166.92355,83.594807 167.21617,83.582028 167.53837,83.582027 L 167.71591,83.582027 L 167.71591,83.879111 M 171.89041,81.157431 L 170.74627,81.157431 L 170.74627,79.767842 L 170.12487,79.978676 L 170.12487,81.157431 L 169.13855,81.157431 L 169.13855,81.674934 L 170.12487,81.674934 L 170.12487,84.530781 C 170.12487,84.805506 170.13474,85.032313 170.15447,85.211201 C 170.17419,85.390091 170.22022,85.553009 170.29255,85.699953 C 170.36489,85.84051 170.47996,85.952315 170.63778,86.035372 C 170.79558,86.118427 171.006,86.159955 171.26903,86.159955 C 171.40711,86.159955 171.5452,86.143983 171.68328,86.112038 C 171.82795,86.086483 171.94301,86.057733 172.02851,86.025788 L 171.98905,85.527452 C 171.89041,85.565786 171.79507,85.594537 171.70301,85.613703 C 171.61753,85.63287 171.52218,85.642454 171.41697,85.642453 C 171.18025,85.642454 171.00929,85.568981 170.90408,85.422035 C 170.79887,85.275091 170.74627,85.080229 170.74627,84.837449 L 170.74627,81.674934 L 171.89041,81.674934 L 171.89041,81.157431 M 172.93762,86.044955 L 173.55901,86.044955 L 173.55901,81.157431 L 172.93762,81.157431 L 172.93762,86.044955 M 173.55901,79.049088 L 172.93762,79.049088 L 172.93762,79.854092 L 173.55901,79.854092 L 173.55901,79.049088 M 174.71057,83.601194 C 174.71057,83.939808 174.75659,84.265642 174.84866,84.578698 C 174.94729,84.885367 175.09195,85.156896 175.28264,85.393285 C 175.47333,85.629676 175.71663,85.818149 176.01253,85.958705 C 176.315,86.092872 176.66351,86.159955 177.05804,86.159955 C 177.45257,86.159955 177.7978,86.092872 178.0937,85.958705 C 178.39617,85.818149 178.64275,85.629676 178.83345,85.393285 C 179.02414,85.150508 179.16551,84.875783 179.25757,84.569114 C 179.35619,84.262449 179.40552,83.939808 179.40552,83.601194 C 179.40552,83.262583 179.35619,82.939944 179.25757,82.633272 C 179.16551,82.320218 179.02414,82.045495 178.83345,81.809101 C 178.64275,81.572716 178.39617,81.387438 178.0937,81.253266 C 177.7978,81.112714 177.45257,81.042436 177.05804,81.042431 C 176.66351,81.042436 176.31829,81.112714 176.0224,81.253266 C 175.72649,81.387438 175.47991,81.575911 175.28264,81.818685 C 175.09195,82.055079 174.94729,82.326608 174.84866,82.633272 C 174.75659,82.939944 174.71057,83.262583 174.71057,83.601194 M 175.39114,83.601194 C 175.39113,83.013416 175.5358,82.527858 175.82513,82.144519 C 176.12103,81.7548 176.53199,81.559938 177.05804,81.559933 C 177.58408,81.559938 177.99177,81.7548 178.2811,82.144519 C 178.57699,82.527858 178.72495,83.013416 178.72495,83.601194 C 178.72495,84.188976 178.57699,84.677727 178.2811,85.06745 C 177.99177,85.450786 177.58408,85.642454 177.05804,85.642453 C 176.53199,85.642454 176.12103,85.450786 175.82513,85.06745 C 175.5358,84.677727 175.39113,84.188976 175.39114,83.601194 M 180.46998,86.044955 L 181.09138,86.044955 L 181.09138,83.342442 C 181.09138,83.125222 181.11768,82.914387 181.17029,82.709939 C 181.22289,82.499108 181.30508,82.307441 181.41687,82.134936 C 181.53523,81.95605 181.68975,81.815494 181.88045,81.713268 C 182.07772,81.611049 182.31114,81.559938 182.58075,81.559933 C 182.995,81.559938 183.29748,81.690911 183.48817,81.952852 C 183.67886,82.214802 183.77421,82.588553 183.77421,83.074107 L 183.77421,86.044955 L 184.3956,86.044955 L 184.3956,82.920774 C 184.3956,82.345775 184.25751,81.888967 183.98134,81.55035 C 183.70516,81.211743 183.27118,81.042436 182.67938,81.042431 C 182.43608,81.042436 182.21909,81.071186 182.0284,81.128681 C 181.84428,81.186186 181.68975,81.262854 181.56482,81.358683 C 181.44646,81.454521 181.34782,81.556744 181.26893,81.665351 C 181.19001,81.773967 181.11768,81.895356 181.05192,82.029519 L 181.0322,82.029519 L 181.0322,81.157431 L 180.43054,81.157431 C 180.45684,81.419382 180.46998,81.802717 180.46998,82.307437 L 180.46998,86.044955 M 185.42016,85.929955 C 185.81469,86.083288 186.28484,86.159955 186.83061,86.159955 C 187.03445,86.159955 187.2383,86.1344 187.44214,86.083288 C 187.64598,86.032177 187.83338,85.952315 188.00435,85.843704 C 188.18188,85.735092 188.32326,85.591342 188.42848,85.412452 C 188.53368,85.233563 188.58628,85.019535 188.58628,84.770365 C 188.58628,84.553144 188.54354,84.361476 188.45806,84.195362 C 188.37258,84.029253 188.2575,83.888696 188.11285,83.773694 C 187.97475,83.652307 187.82681,83.553278 187.66899,83.476609 C 187.51776,83.393556 187.32378,83.300917 187.08706,83.198691 C 186.7517,83.051749 186.50513,82.920776 186.34731,82.805773 C 186.18949,82.690776 186.11059,82.547025 186.11059,82.374521 C 186.11059,82.080635 186.20264,81.872995 186.38676,81.751601 C 186.57745,81.623827 186.84705,81.559938 187.19555,81.559933 C 187.36652,81.559938 187.55392,81.582299 187.75777,81.627018 C 187.96818,81.665355 188.1523,81.719661 188.31012,81.789935 L 188.36929,81.262849 C 188.16545,81.186186 187.94517,81.131881 187.70845,81.099931 C 187.47831,81.061603 187.28432,81.042436 187.12652,81.042431 C 186.90952,81.042436 186.70238,81.067992 186.50513,81.119098 C 186.31443,81.163826 186.14018,81.240493 185.98236,81.349099 C 185.83113,81.457716 185.70948,81.598272 185.61743,81.770768 C 185.53194,81.936884 185.48919,82.138135 185.4892,82.374521 C 185.48919,82.547025 185.52536,82.703554 185.59769,82.844106 C 185.67003,82.978277 185.76537,83.096472 185.88373,83.198691 C 186.00209,83.300917 186.12703,83.387167 186.25854,83.457442 C 186.39662,83.527723 186.57416,83.61078 186.79116,83.706611 C 187.16596,83.879113 187.44543,84.038836 187.62955,84.185779 C 187.81366,84.326337 187.90572,84.521199 187.90572,84.770365 C 187.90572,85.038701 187.79722,85.25273 187.58022,85.412452 C 187.36323,85.565786 187.10021,85.642454 186.79116,85.642453 C 186.33745,85.642454 185.90017,85.540231 185.47933,85.335785 L 185.42016,85.929955" - id="text2985" /> - <path - style="fill:none;fill-rule:evenodd;stroke:black;stroke-width:2.95839429;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" - d="M 12.925286,86.778391 L 13.286986,19.159668 L 58.155285,26.942569 L 57.772633,93.67717 L 12.925286,86.778391 z " - id="path2990" /> - <path - style="fill:none;fill-rule:evenodd;stroke:black;stroke-width:3;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;fill-opacity:1" - d="M 13.488233,19.049404 L 37.172883,11.162464 L 77.786022,19.420245 L 57.107048,26.22552 L 13.488233,19.049404 z " - id="path3877" /> - <path - style="fill:none;fill-rule:evenodd;stroke:black;stroke-width:3;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" - d="M 57.997556,93.629361 L 77.486975,86.74764 L 77.759697,19.547174 L 58.5016,26.445081 L 57.997556,93.629361 z " - id="path3879" - sodipodi:nodetypes="ccccc" /> - <path - style="fill:none;fill-rule:evenodd;stroke:black;stroke-width:2;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" - d="M 14.330613,38.606641 L 36.912066,32.135194 L 76.635736,40.056811 L 58.346077,46.531185 L 14.330613,38.606641 z " - id="path3881" - sodipodi:nodetypes="ccccc" /> - <path - style="fill:none;fill-rule:evenodd;stroke:black;stroke-width:2;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" - d="M 14.150271,65.640082 L 36.731724,59.168636 L 77.314157,65.640929 L 57.787539,72.680481 L 14.150271,65.640082 z " - id="path3883" - sodipodi:nodetypes="ccccc" /> - <path - style="fill:none;fill-rule:evenodd;stroke:black;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" - d="M 13.820355,86.361841 L 35.130498,79.541609 L 76.834867,85.878963" - id="path3887" /> - <path - style="fill:none;fill-rule:evenodd;stroke:black;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" - d="M 34.866065,79.042658 L 35.146638,69.563169" - id="path3889" /> - <path - style="fill:none;fill-rule:evenodd;stroke:black;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" - d="M 36.154699,58.803397 L 36.535174,42.88001" - id="path3891" /> - <path - style="fill:none;fill-rule:evenodd;stroke:black;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" - d="M 36.776858,31.759485 L 36.855284,23.494878" - id="path3893" - sodipodi:nodetypes="cc" /> - </g> -</svg> diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/example/lobster.ru b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/example/lobster.ru deleted file mode 100755 index cc7ffcae889..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/example/lobster.ru +++ /dev/null @@ -1,4 +0,0 @@ -require 'rack/lobster' - -use Rack::ShowExceptions -run Rack::Lobster.new diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/example/protectedlobster.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/example/protectedlobster.rb deleted file mode 100755 index 108b9d05e7e..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/example/protectedlobster.rb +++ /dev/null @@ -1,14 +0,0 @@ -require 'rack' -require 'rack/lobster' - -lobster = Rack::Lobster.new - -protected_lobster = Rack::Auth::Basic.new(lobster) do |username, password| - 'secret' == password -end - -protected_lobster.realm = 'Lobster 2.0' - -pretty_protected_lobster = Rack::ShowStatus.new(Rack::ShowExceptions.new(protected_lobster)) - -Rack::Handler::WEBrick.run pretty_protected_lobster, :Port => 9292 diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/example/protectedlobster.ru b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/example/protectedlobster.ru deleted file mode 100755 index b0da62f0ce2..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/example/protectedlobster.ru +++ /dev/null @@ -1,8 +0,0 @@ -require 'rack/lobster' - -use Rack::ShowExceptions -use Rack::Auth::Basic, "Lobster 2.0" do |username, password| - 'secret' == password -end - -run Rack::Lobster.new diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_auth_basic.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_auth_basic.rb deleted file mode 100755 index 0176efc8b30..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_auth_basic.rb +++ /dev/null @@ -1,73 +0,0 @@ -require 'test/spec' - -require 'rack/auth/basic' -require 'rack/mock' - -context 'Rack::Auth::Basic' do - - def realm - 'WallysWorld' - end - - def unprotected_app - lambda { |env| [ 200, {'Content-Type' => 'text/plain'}, ["Hi #{env['REMOTE_USER']}"] ] } - end - - def protected_app - app = Rack::Auth::Basic.new(unprotected_app) { |username, password| 'Boss' == username } - app.realm = realm - app - end - - setup do - @request = Rack::MockRequest.new(protected_app) - end - - def request_with_basic_auth(username, password, &block) - request 'HTTP_AUTHORIZATION' => 'Basic ' + ["#{username}:#{password}"].pack("m*"), &block - end - - def request(headers = {}) - yield @request.get('/', headers) - end - - def assert_basic_auth_challenge(response) - response.should.be.a.client_error - response.status.should.equal 401 - response.should.include 'WWW-Authenticate' - response.headers['WWW-Authenticate'].should =~ /Basic realm="#{Regexp.escape(realm)}"/ - response.body.should.be.empty - end - - specify 'should challenge correctly when no credentials are specified' do - request do |response| - assert_basic_auth_challenge response - end - end - - specify 'should rechallenge if incorrect credentials are specified' do - request_with_basic_auth 'joe', 'password' do |response| - assert_basic_auth_challenge response - end - end - - specify 'should return application output if correct credentials are specified' do - request_with_basic_auth 'Boss', 'password' do |response| - response.status.should.equal 200 - response.body.to_s.should.equal 'Hi Boss' - end - end - - specify 'should return 400 Bad Request if different auth scheme used' do - request 'HTTP_AUTHORIZATION' => 'Digest params' do |response| - response.should.be.a.client_error - response.status.should.equal 400 - response.should.not.include 'WWW-Authenticate' - end - end - - specify 'realm as optional constructor arg' do - app = Rack::Auth::Basic.new(unprotected_app, realm) { true } - assert_equal realm, app.realm - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_auth_digest.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_auth_digest.rb deleted file mode 100755 index 7413aa48ed0..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_auth_digest.rb +++ /dev/null @@ -1,232 +0,0 @@ -require 'test/spec' - -require 'rack/auth/digest/md5' -require 'rack/mock' - -context 'Rack::Auth::Digest::MD5' do - - def realm - 'WallysWorld' - end - - def unprotected_app - lambda do |env| - [ 200, {'Content-Type' => 'text/plain'}, ["Hi #{env['REMOTE_USER']}"] ] - end - end - - def protected_app - app = Rack::Auth::Digest::MD5.new(unprotected_app) do |username| - { 'Alice' => 'correct-password' }[username] - end - app.realm = realm - app.opaque = 'this-should-be-secret' - app - end - - def protected_app_with_hashed_passwords - app = Rack::Auth::Digest::MD5.new(unprotected_app) do |username| - username == 'Alice' ? Digest::MD5.hexdigest("Alice:#{realm}:correct-password") : nil - end - app.realm = realm - app.opaque = 'this-should-be-secret' - app.passwords_hashed = true - app - end - - def partially_protected_app - Rack::URLMap.new({ - '/' => unprotected_app, - '/protected' => protected_app - }) - end - - def protected_app_with_method_override - Rack::MethodOverride.new(protected_app) - end - - setup do - @request = Rack::MockRequest.new(protected_app) - end - - def request(method, path, headers = {}, &block) - response = @request.request(method, path, headers) - block.call(response) if block - return response - end - - class MockDigestRequest - def initialize(params) - @params = params - end - def method_missing(sym) - if @params.has_key? k = sym.to_s - return @params[k] - end - super - end - def method - @params['method'] - end - def response(password) - Rack::Auth::Digest::MD5.new(nil).send :digest, self, password - end - end - - def request_with_digest_auth(method, path, username, password, options = {}, &block) - request_options = {} - request_options[:input] = options.delete(:input) if options.include? :input - - response = request(method, path, request_options) - - return response unless response.status == 401 - - if wait = options.delete(:wait) - sleep wait - end - - challenge = response['WWW-Authenticate'].split(' ', 2).last - - params = Rack::Auth::Digest::Params.parse(challenge) - - params['username'] = username - params['nc'] = '00000001' - params['cnonce'] = 'nonsensenonce' - params['uri'] = path - - params['method'] = method - - params.update options - - params['response'] = MockDigestRequest.new(params).response(password) - - request(method, path, request_options.merge('HTTP_AUTHORIZATION' => "Digest #{params}"), &block) - end - - def assert_digest_auth_challenge(response) - response.should.be.a.client_error - response.status.should.equal 401 - response.should.include 'WWW-Authenticate' - response.headers['WWW-Authenticate'].should =~ /^Digest / - response.body.should.be.empty - end - - def assert_bad_request(response) - response.should.be.a.client_error - response.status.should.equal 400 - response.should.not.include 'WWW-Authenticate' - end - - specify 'should challenge when no credentials are specified' do - request 'GET', '/' do |response| - assert_digest_auth_challenge response - end - end - - specify 'should return application output if correct credentials given' do - request_with_digest_auth 'GET', '/', 'Alice', 'correct-password' do |response| - response.status.should.equal 200 - response.body.to_s.should.equal 'Hi Alice' - end - end - - specify 'should return application output if correct credentials given (hashed passwords)' do - @request = Rack::MockRequest.new(protected_app_with_hashed_passwords) - - request_with_digest_auth 'GET', '/', 'Alice', 'correct-password' do |response| - response.status.should.equal 200 - response.body.to_s.should.equal 'Hi Alice' - end - end - - specify 'should rechallenge if incorrect username given' do - request_with_digest_auth 'GET', '/', 'Bob', 'correct-password' do |response| - assert_digest_auth_challenge response - end - end - - specify 'should rechallenge if incorrect password given' do - request_with_digest_auth 'GET', '/', 'Alice', 'wrong-password' do |response| - assert_digest_auth_challenge response - end - end - - specify 'rechallenge if incorrect user and blank password given' do - request_with_digest_auth 'GET', '/', 'Bob', '' do |response| - assert_digest_auth_challenge response - end - end - - specify 'should rechallenge with stale parameter if nonce is stale' do - begin - Rack::Auth::Digest::Nonce.time_limit = 1 - - request_with_digest_auth 'GET', '/', 'Alice', 'correct-password', :wait => 2 do |response| - assert_digest_auth_challenge response - response.headers['WWW-Authenticate'].should =~ /\bstale=true\b/ - end - ensure - Rack::Auth::Digest::Nonce.time_limit = nil - end - end - - specify 'should return 400 Bad Request if incorrect qop given' do - request_with_digest_auth 'GET', '/', 'Alice', 'correct-password', 'qop' => 'auth-int' do |response| - assert_bad_request response - end - end - - specify 'should return 400 Bad Request if incorrect uri given' do - request_with_digest_auth 'GET', '/', 'Alice', 'correct-password', 'uri' => '/foo' do |response| - assert_bad_request response - end - end - - specify 'should return 400 Bad Request if different auth scheme used' do - request 'GET', '/', 'HTTP_AUTHORIZATION' => 'Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==' do |response| - assert_bad_request response - end - end - - specify 'should not require credentials for unprotected path' do - @request = Rack::MockRequest.new(partially_protected_app) - request 'GET', '/' do |response| - response.should.be.ok - end - end - - specify 'should challenge when no credentials are specified for protected path' do - @request = Rack::MockRequest.new(partially_protected_app) - request 'GET', '/protected' do |response| - assert_digest_auth_challenge response - end - end - - specify 'should return application output if correct credentials given for protected path' do - @request = Rack::MockRequest.new(partially_protected_app) - request_with_digest_auth 'GET', '/protected', 'Alice', 'correct-password' do |response| - response.status.should.equal 200 - response.body.to_s.should.equal 'Hi Alice' - end - end - - specify 'should return application output if correct credentials given for POST' do - request_with_digest_auth 'POST', '/', 'Alice', 'correct-password' do |response| - response.status.should.equal 200 - response.body.to_s.should.equal 'Hi Alice' - end - end - - specify 'should return application output if correct credentials given for PUT (using method override of POST)' do - @request = Rack::MockRequest.new(protected_app_with_method_override) - request_with_digest_auth 'POST', '/', 'Alice', 'correct-password', :input => "_method=put" do |response| - response.status.should.equal 200 - response.body.to_s.should.equal 'Hi Alice' - end - end - - specify 'realm as optional constructor arg' do - app = Rack::Auth::Digest::MD5.new(unprotected_app, realm) { true } - assert_equal realm, app.realm - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_builder.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_builder.rb deleted file mode 100755 index 3fad9810e3c..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_builder.rb +++ /dev/null @@ -1,84 +0,0 @@ -require 'test/spec' - -require 'rack/builder' -require 'rack/mock' -require 'rack/showexceptions' -require 'rack/auth/basic' - -context "Rack::Builder" do - specify "chains apps by default" do - app = Rack::Builder.new do - use Rack::ShowExceptions - run lambda { |env| raise "bzzzt" } - end.to_app - - Rack::MockRequest.new(app).get("/").should.be.server_error - Rack::MockRequest.new(app).get("/").should.be.server_error - Rack::MockRequest.new(app).get("/").should.be.server_error - end - - specify "has implicit #to_app" do - app = Rack::Builder.new do - use Rack::ShowExceptions - run lambda { |env| raise "bzzzt" } - end - - Rack::MockRequest.new(app).get("/").should.be.server_error - Rack::MockRequest.new(app).get("/").should.be.server_error - Rack::MockRequest.new(app).get("/").should.be.server_error - end - - specify "supports blocks on use" do - app = Rack::Builder.new do - use Rack::ShowExceptions - use Rack::Auth::Basic do |username, password| - 'secret' == password - end - - run lambda { |env| [200, {}, ['Hi Boss']] } - end - - response = Rack::MockRequest.new(app).get("/") - response.should.be.client_error - response.status.should.equal 401 - - # with auth... - response = Rack::MockRequest.new(app).get("/", - 'HTTP_AUTHORIZATION' => 'Basic ' + ["joe:secret"].pack("m*")) - response.status.should.equal 200 - response.body.to_s.should.equal 'Hi Boss' - end - - specify "has explicit #to_app" do - app = Rack::Builder.app do - use Rack::ShowExceptions - run lambda { |env| raise "bzzzt" } - end - - Rack::MockRequest.new(app).get("/").should.be.server_error - Rack::MockRequest.new(app).get("/").should.be.server_error - Rack::MockRequest.new(app).get("/").should.be.server_error - end - - specify "apps are initialized once" do - app = Rack::Builder.new do - class AppClass - def initialize - @called = 0 - end - def call(env) - raise "bzzzt" if @called > 0 - @called += 1 - [200, {'Content-Type' => 'text/plain'}, ['OK']] - end - end - - use Rack::ShowExceptions - run AppClass.new - end - - Rack::MockRequest.new(app).get("/").status.should.equal 200 - Rack::MockRequest.new(app).get("/").should.be.server_error - end - -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_camping.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_camping.rb deleted file mode 100755 index e7597f07e0a..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_camping.rb +++ /dev/null @@ -1,55 +0,0 @@ -require 'test/spec' -require 'stringio' -require 'uri' - -begin - require 'rack/mock' - - $-w, w = nil, $-w # yuck - - # campings dependencies also don't pull this in anymore: - class Object;def meta_def m,&b;(class<<self;self;end).send:define_method,m,&b end end - - require 'camping' - require 'rack/adapter/camping' - - Camping.goes :CampApp - module CampApp - module Controllers - class HW < R('/') - def get - @headers["X-Served-By"] = URI("http://rack.rubyforge.org") - "Camping works!" - end - - def post - "Data: #{input.foo}" - end - end - end - end - $-w = w - - context "Rack::Adapter::Camping" do - specify "works with GET" do - res = Rack::MockRequest.new(Rack::Adapter::Camping.new(CampApp)). - get("/") - - res.should.be.ok - res["Content-Type"].should.equal "text/html" - res["X-Served-By"].should.equal "http://rack.rubyforge.org" - - res.body.should.equal "Camping works!" - end - - specify "works with POST" do - res = Rack::MockRequest.new(Rack::Adapter::Camping.new(CampApp)). - post("/", :input => "foo=bar") - - res.should.be.ok - res.body.should.equal "Data: bar" - end - end -rescue LoadError - $stderr.puts "Skipping Rack::Adapter::Camping tests (Camping is required). `gem install camping` and try again." -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_cascade.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_cascade.rb deleted file mode 100755 index cf3c29b4821..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_cascade.rb +++ /dev/null @@ -1,48 +0,0 @@ -require 'test/spec' - -require 'rack/cascade' -require 'rack/mock' - -require 'rack/urlmap' -require 'rack/file' - -context "Rack::Cascade" do - docroot = File.expand_path(File.dirname(__FILE__)) - app1 = Rack::File.new(docroot) - - app2 = Rack::URLMap.new("/crash" => lambda { |env| raise "boom" }) - - app3 = Rack::URLMap.new("/foo" => lambda { |env| - [200, { "Content-Type" => "text/plain"}, [""]]}) - - specify "should dispatch onward on 404 by default" do - cascade = Rack::Cascade.new([app1, app2, app3]) - Rack::MockRequest.new(cascade).get("/cgi/test").should.be.ok - Rack::MockRequest.new(cascade).get("/foo").should.be.ok - Rack::MockRequest.new(cascade).get("/toobad").should.be.not_found - Rack::MockRequest.new(cascade).get("/cgi/../bla").should.be.forbidden - end - - specify "should dispatch onward on whatever is passed" do - cascade = Rack::Cascade.new([app1, app2, app3], [404, 403]) - Rack::MockRequest.new(cascade).get("/cgi/../bla").should.be.not_found - end - - specify "should return 404 if empty" do - Rack::MockRequest.new(Rack::Cascade.new([])).get('/').should.be.not_found - end - - specify "should append new app" do - cascade = Rack::Cascade.new([], [404, 403]) - Rack::MockRequest.new(cascade).get('/').should.be.not_found - cascade << app2 - Rack::MockRequest.new(cascade).get('/cgi/test').should.be.not_found - Rack::MockRequest.new(cascade).get('/cgi/../bla').should.be.not_found - cascade << app1 - Rack::MockRequest.new(cascade).get('/cgi/test').should.be.ok - Rack::MockRequest.new(cascade).get('/cgi/../bla').should.be.forbidden - Rack::MockRequest.new(cascade).get('/foo').should.be.not_found - cascade << app3 - Rack::MockRequest.new(cascade).get('/foo').should.be.ok - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_cgi.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_cgi.rb deleted file mode 100755 index df08656d06e..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_cgi.rb +++ /dev/null @@ -1,89 +0,0 @@ -require 'test/spec' -require 'testrequest' - -context "Rack::Handler::CGI" do - include TestRequest::Helpers - - setup do - @host = '0.0.0.0' - @port = 9203 - end - - # Keep this first. - specify "startup" do - $pid = fork { - Dir.chdir(File.join(File.dirname(__FILE__), "..", "test", "cgi")) - exec "lighttpd -D -f lighttpd.conf" - } - end - - specify "should respond" do - sleep 1 - lambda { - GET("/test") - }.should.not.raise - end - - specify "should be a lighttpd" do - GET("/test") - status.should.be 200 - response["SERVER_SOFTWARE"].should =~ /lighttpd/ - response["HTTP_VERSION"].should.equal "HTTP/1.1" - response["SERVER_PROTOCOL"].should.equal "HTTP/1.1" - response["SERVER_PORT"].should.equal @port.to_s - response["SERVER_NAME"].should =~ @host - end - - specify "should have rack headers" do - GET("/test") - response["rack.version"].should.equal [1,1] - response["rack.multithread"].should.be false - response["rack.multiprocess"].should.be true - response["rack.run_once"].should.be true - end - - specify "should have CGI headers on GET" do - GET("/test") - response["REQUEST_METHOD"].should.equal "GET" - response["SCRIPT_NAME"].should.equal "/test" - response["REQUEST_PATH"].should.equal "/" - response["PATH_INFO"].should.be nil - response["QUERY_STRING"].should.equal "" - response["test.postdata"].should.equal "" - - GET("/test/foo?quux=1") - response["REQUEST_METHOD"].should.equal "GET" - response["SCRIPT_NAME"].should.equal "/test" - response["REQUEST_PATH"].should.equal "/" - response["PATH_INFO"].should.equal "/foo" - response["QUERY_STRING"].should.equal "quux=1" - end - - specify "should have CGI headers on POST" do - POST("/test", {"rack-form-data" => "23"}, {'X-test-header' => '42'}) - status.should.equal 200 - response["REQUEST_METHOD"].should.equal "POST" - response["SCRIPT_NAME"].should.equal "/test" - response["REQUEST_PATH"].should.equal "/" - response["QUERY_STRING"].should.equal "" - response["HTTP_X_TEST_HEADER"].should.equal "42" - response["test.postdata"].should.equal "rack-form-data=23" - end - - specify "should support HTTP auth" do - GET("/test", {:user => "ruth", :passwd => "secret"}) - response["HTTP_AUTHORIZATION"].should.equal "Basic cnV0aDpzZWNyZXQ=" - end - - specify "should set status" do - GET("/test?secret") - status.should.equal 403 - response["rack.url_scheme"].should.equal "http" - end - - # Keep this last. - specify "shutdown" do - Process.kill 15, $pid - Process.wait($pid).should.equal $pid - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_chunked.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_chunked.rb deleted file mode 100755 index 39eea4824cd..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_chunked.rb +++ /dev/null @@ -1,62 +0,0 @@ -require 'rack/mock' -require 'rack/chunked' -require 'rack/utils' - -context "Rack::Chunked" do - - before do - @env = Rack::MockRequest. - env_for('/', 'HTTP_VERSION' => '1.1', 'REQUEST_METHOD' => 'GET') - end - - specify 'chunks responses with no Content-Length' do - app = lambda { |env| [200, {}, ['Hello', ' ', 'World!']] } - response = Rack::MockResponse.new(*Rack::Chunked.new(app).call(@env)) - response.headers.should.not.include 'Content-Length' - response.headers['Transfer-Encoding'].should.equal 'chunked' - response.body.should.equal "5\r\nHello\r\n1\r\n \r\n6\r\nWorld!\r\n0\r\n\r\n" - end - - specify 'chunks empty bodies properly' do - app = lambda { |env| [200, {}, []] } - response = Rack::MockResponse.new(*Rack::Chunked.new(app).call(@env)) - response.headers.should.not.include 'Content-Length' - response.headers['Transfer-Encoding'].should.equal 'chunked' - response.body.should.equal "0\r\n\r\n" - end - - specify 'does not modify response when Content-Length header present' do - app = lambda { |env| [200, {'Content-Length'=>'12'}, ['Hello', ' ', 'World!']] } - status, headers, body = Rack::Chunked.new(app).call(@env) - status.should.equal 200 - headers.should.not.include 'Transfer-Encoding' - headers.should.include 'Content-Length' - body.join.should.equal 'Hello World!' - end - - specify 'does not modify response when client is HTTP/1.0' do - app = lambda { |env| [200, {}, ['Hello', ' ', 'World!']] } - @env['HTTP_VERSION'] = 'HTTP/1.0' - status, headers, body = Rack::Chunked.new(app).call(@env) - status.should.equal 200 - headers.should.not.include 'Transfer-Encoding' - body.join.should.equal 'Hello World!' - end - - specify 'does not modify response when Transfer-Encoding header already present' do - app = lambda { |env| [200, {'Transfer-Encoding' => 'identity'}, ['Hello', ' ', 'World!']] } - status, headers, body = Rack::Chunked.new(app).call(@env) - status.should.equal 200 - headers['Transfer-Encoding'].should.equal 'identity' - body.join.should.equal 'Hello World!' - end - - [100, 204, 304].each do |status_code| - specify "does not modify response when status code is #{status_code}" do - app = lambda { |env| [status_code, {}, []] } - status, headers, body = Rack::Chunked.new(app).call(@env) - status.should.equal status_code - headers.should.not.include 'Transfer-Encoding' - end - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_commonlogger.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_commonlogger.rb deleted file mode 100755 index 46a72e86be8..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_commonlogger.rb +++ /dev/null @@ -1,61 +0,0 @@ -require 'test/spec' -require 'stringio' - -require 'rack/commonlogger' -require 'rack/lobster' -require 'rack/mock' - -context "Rack::CommonLogger" do - app = lambda { |env| - [200, - {"Content-Type" => "text/html", "Content-Length" => length.to_s}, - [obj]]} - app_without_length = lambda { |env| - [200, - {"Content-Type" => "text/html"}, - []]} - app_with_zero_length = lambda { |env| - [200, - {"Content-Type" => "text/html", "Content-Length" => "0"}, - []]} - - specify "should log to rack.errors by default" do - res = Rack::MockRequest.new(Rack::CommonLogger.new(app)).get("/") - - res.errors.should.not.be.empty - res.errors.should =~ /"GET \/ " 200 #{length} / - end - - specify "should log to anything with +write+" do - log = StringIO.new - res = Rack::MockRequest.new(Rack::CommonLogger.new(app, log)).get("/") - - log.string.should =~ /"GET \/ " 200 #{length} / - end - - specify "should log - content length if header is missing" do - res = Rack::MockRequest.new(Rack::CommonLogger.new(app_without_length)).get("/") - - res.errors.should.not.be.empty - res.errors.should =~ /"GET \/ " 200 - / - end - - specify "should log - content length if header is zero" do - res = Rack::MockRequest.new(Rack::CommonLogger.new(app_with_zero_length)).get("/") - - res.errors.should.not.be.empty - res.errors.should =~ /"GET \/ " 200 - / - end - - def length - self.class.length - end - - def self.length - 123 - end - - def self.obj - "hello world" - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_conditionalget.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_conditionalget.rb deleted file mode 100755 index ca34cc922c0..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_conditionalget.rb +++ /dev/null @@ -1,41 +0,0 @@ -require 'test/spec' -require 'time' - -require 'rack/mock' -require 'rack/conditionalget' - -context "Rack::ConditionalGet" do - specify "should set a 304 status and truncate body when If-Modified-Since hits" do - timestamp = Time.now.httpdate - app = Rack::ConditionalGet.new(lambda { |env| - [200, {'Last-Modified'=>timestamp}, ['TEST']] }) - - response = Rack::MockRequest.new(app). - get("/", 'HTTP_IF_MODIFIED_SINCE' => timestamp) - - response.status.should.equal 304 - response.body.should.be.empty - end - - specify "should set a 304 status and truncate body when If-None-Match hits" do - app = Rack::ConditionalGet.new(lambda { |env| - [200, {'Etag'=>'1234'}, ['TEST']] }) - - response = Rack::MockRequest.new(app). - get("/", 'HTTP_IF_NONE_MATCH' => '1234') - - response.status.should.equal 304 - response.body.should.be.empty - end - - specify "should not affect non-GET/HEAD requests" do - app = Rack::ConditionalGet.new(lambda { |env| - [200, {'Etag'=>'1234'}, ['TEST']] }) - - response = Rack::MockRequest.new(app). - post("/", 'HTTP_IF_NONE_MATCH' => '1234') - - response.status.should.equal 200 - response.body.should.equal 'TEST' - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_config.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_config.rb deleted file mode 100755 index a508ea4beb5..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_config.rb +++ /dev/null @@ -1,24 +0,0 @@ -require 'test/spec' -require 'rack/mock' -require 'rack/builder' -require 'rack/content_length' -require 'rack/config' - -context "Rack::Config" do - - specify "should accept a block that modifies the environment" do - app = Rack::Builder.new do - use Rack::Lint - use Rack::ContentLength - use Rack::Config do |env| - env['greeting'] = 'hello' - end - run lambda { |env| - [200, {'Content-Type' => 'text/plain'}, [env['greeting'] || '']] - } - end - response = Rack::MockRequest.new(app).get('/') - response.body.should.equal('hello') - end - -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_content_length.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_content_length.rb deleted file mode 100755 index 7db9345f860..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_content_length.rb +++ /dev/null @@ -1,43 +0,0 @@ -require 'rack/mock' -require 'rack/content_length' - -context "Rack::ContentLength" do - specify "sets Content-Length on String bodies if none is set" do - app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, "Hello, World!"] } - response = Rack::ContentLength.new(app).call({}) - response[1]['Content-Length'].should.equal '13' - end - - specify "sets Content-Length on Array bodies if none is set" do - app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] } - response = Rack::ContentLength.new(app).call({}) - response[1]['Content-Length'].should.equal '13' - end - - specify "does not set Content-Length on variable length bodies" do - body = lambda { "Hello World!" } - def body.each ; yield call ; end - - app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, body] } - response = Rack::ContentLength.new(app).call({}) - response[1]['Content-Length'].should.be.nil - end - - specify "does not change Content-Length if it is already set" do - app = lambda { |env| [200, {'Content-Type' => 'text/plain', 'Content-Length' => '1'}, "Hello, World!"] } - response = Rack::ContentLength.new(app).call({}) - response[1]['Content-Length'].should.equal '1' - end - - specify "does not set Content-Length on 304 responses" do - app = lambda { |env| [304, {'Content-Type' => 'text/plain'}, []] } - response = Rack::ContentLength.new(app).call({}) - response[1]['Content-Length'].should.equal nil - end - - specify "does not set Content-Length when Transfer-Encoding is chunked" do - app = lambda { |env| [200, {'Transfer-Encoding' => 'chunked'}, []] } - response = Rack::ContentLength.new(app).call({}) - response[1]['Content-Length'].should.equal nil - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_content_type.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_content_type.rb deleted file mode 100755 index 9975b94d62b..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_content_type.rb +++ /dev/null @@ -1,30 +0,0 @@ -require 'rack/mock' -require 'rack/content_type' - -context "Rack::ContentType" do - specify "sets Content-Type to default text/html if none is set" do - app = lambda { |env| [200, {}, "Hello, World!"] } - status, headers, body = Rack::ContentType.new(app).call({}) - headers['Content-Type'].should.equal 'text/html' - end - - specify "sets Content-Type to chosen default if none is set" do - app = lambda { |env| [200, {}, "Hello, World!"] } - status, headers, body = - Rack::ContentType.new(app, 'application/octet-stream').call({}) - headers['Content-Type'].should.equal 'application/octet-stream' - end - - specify "does not change Content-Type if it is already set" do - app = lambda { |env| [200, {'Content-Type' => 'foo/bar'}, "Hello, World!"] } - status, headers, body = Rack::ContentType.new(app).call({}) - headers['Content-Type'].should.equal 'foo/bar' - end - - specify "case insensitive detection of Content-Type" do - app = lambda { |env| [200, {'CONTENT-Type' => 'foo/bar'}, "Hello, World!"] } - status, headers, body = Rack::ContentType.new(app).call({}) - headers.to_a.select { |k,v| k.downcase == "content-type" }. - should.equal [["CONTENT-Type","foo/bar"]] - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_deflater.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_deflater.rb deleted file mode 100755 index c9bb318942f..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_deflater.rb +++ /dev/null @@ -1,127 +0,0 @@ -require 'test/spec' - -require 'rack/mock' -require 'rack/deflater' -require 'stringio' -require 'time' # for Time#httpdate - -context "Rack::Deflater" do - def build_response(status, body, accept_encoding, headers = {}) - body = [body] if body.respond_to? :to_str - app = lambda { |env| [status, {}, body] } - request = Rack::MockRequest.env_for("", headers.merge("HTTP_ACCEPT_ENCODING" => accept_encoding)) - response = Rack::Deflater.new(app).call(request) - - return response - end - - specify "should be able to deflate bodies that respond to each" do - body = Object.new - class << body; def each; yield("foo"); yield("bar"); end; end - - response = build_response(200, body, "deflate") - - response[0].should.equal(200) - response[1].should.equal({ - "Content-Encoding" => "deflate", - "Vary" => "Accept-Encoding" - }) - buf = '' - response[2].each { |part| buf << part } - buf.should.equal("K\313\317OJ,\002\000") - end - - # TODO: This is really just a special case of the above... - specify "should be able to deflate String bodies" do - response = build_response(200, "Hello world!", "deflate") - - response[0].should.equal(200) - response[1].should.equal({ - "Content-Encoding" => "deflate", - "Vary" => "Accept-Encoding" - }) - buf = '' - response[2].each { |part| buf << part } - buf.should.equal("\363H\315\311\311W(\317/\312IQ\004\000") - end - - specify "should be able to gzip bodies that respond to each" do - body = Object.new - class << body; def each; yield("foo"); yield("bar"); end; end - - response = build_response(200, body, "gzip") - - response[0].should.equal(200) - response[1].should.equal({ - "Content-Encoding" => "gzip", - "Vary" => "Accept-Encoding", - }) - - buf = '' - response[2].each { |part| buf << part } - io = StringIO.new(buf) - gz = Zlib::GzipReader.new(io) - gz.read.should.equal("foobar") - gz.close - end - - specify "should be able to fallback to no deflation" do - response = build_response(200, "Hello world!", "superzip") - - response[0].should.equal(200) - response[1].should.equal({ "Vary" => "Accept-Encoding" }) - response[2].should.equal(["Hello world!"]) - end - - specify "should be able to skip when there is no response entity body" do - response = build_response(304, [], "gzip") - - response[0].should.equal(304) - response[1].should.equal({}) - response[2].should.equal([]) - end - - specify "should handle the lack of an acceptable encoding" do - response1 = build_response(200, "Hello world!", "identity;q=0", "PATH_INFO" => "/") - response1[0].should.equal(406) - response1[1].should.equal({"Content-Type" => "text/plain", "Content-Length" => "71"}) - response1[2].should.equal(["An acceptable encoding for the requested resource / could not be found."]) - - response2 = build_response(200, "Hello world!", "identity;q=0", "SCRIPT_NAME" => "/foo", "PATH_INFO" => "/bar") - response2[0].should.equal(406) - response2[1].should.equal({"Content-Type" => "text/plain", "Content-Length" => "78"}) - response2[2].should.equal(["An acceptable encoding for the requested resource /foo/bar could not be found."]) - end - - specify "should handle gzip response with Last-Modified header" do - last_modified = Time.now.httpdate - - app = lambda { |env| [200, { "Last-Modified" => last_modified }, ["Hello World!"]] } - request = Rack::MockRequest.env_for("", "HTTP_ACCEPT_ENCODING" => "gzip") - response = Rack::Deflater.new(app).call(request) - - response[0].should.equal(200) - response[1].should.equal({ - "Content-Encoding" => "gzip", - "Vary" => "Accept-Encoding", - "Last-Modified" => last_modified - }) - - buf = '' - response[2].each { |part| buf << part } - io = StringIO.new(buf) - gz = Zlib::GzipReader.new(io) - gz.read.should.equal("Hello World!") - gz.close - end - - specify "should do nothing when no-transform Cache-Control directive present" do - app = lambda { |env| [200, {'Cache-Control' => 'no-transform'}, ['Hello World!']] } - request = Rack::MockRequest.env_for("", "HTTP_ACCEPT_ENCODING" => "gzip") - response = Rack::Deflater.new(app).call(request) - - response[0].should.equal(200) - response[1].should.not.include "Content-Encoding" - response[2].join.should.equal("Hello World!") - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_directory.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_directory.rb deleted file mode 100755 index d255c91da5c..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_directory.rb +++ /dev/null @@ -1,61 +0,0 @@ -require 'test/spec' - -require 'rack/directory' -require 'rack/lint' - -require 'rack/mock' - -context "Rack::Directory" do - DOCROOT = File.expand_path(File.dirname(__FILE__)) unless defined? DOCROOT - FILE_CATCH = proc{|env| [200, {'Content-Type'=>'text/plain', "Content-Length" => "7"}, ['passed!']] } - app = Rack::Directory.new DOCROOT, FILE_CATCH - - specify "serves directory indices" do - res = Rack::MockRequest.new(Rack::Lint.new(app)). - get("/cgi/") - - res.should.be.ok - res.should =~ /<html><head>/ - end - - specify "passes to app if file found" do - res = Rack::MockRequest.new(Rack::Lint.new(app)). - get("/cgi/test") - - res.should.be.ok - res.should =~ /passed!/ - end - - specify "serves uri with URL encoded filenames" do - res = Rack::MockRequest.new(Rack::Lint.new(app)). - get("/%63%67%69/") # "/cgi/test" - - res.should.be.ok - res.should =~ /<html><head>/ - - res = Rack::MockRequest.new(Rack::Lint.new(app)). - get("/cgi/%74%65%73%74") # "/cgi/test" - - res.should.be.ok - res.should =~ /passed!/ - end - - specify "does not allow directory traversal" do - res = Rack::MockRequest.new(Rack::Lint.new(app)). - get("/cgi/../test") - - res.should.be.forbidden - - res = Rack::MockRequest.new(Rack::Lint.new(app)). - get("/cgi/%2E%2E/test") - - res.should.be.forbidden - end - - specify "404s if it can't find the file" do - res = Rack::MockRequest.new(Rack::Lint.new(app)). - get("/cgi/blubb") - - res.should.be.not_found - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_etag.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_etag.rb deleted file mode 100755 index 73cd31ac02e..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_etag.rb +++ /dev/null @@ -1,17 +0,0 @@ -require 'test/spec' -require 'rack/mock' -require 'rack/etag' - -context "Rack::ETag" do - specify "sets ETag if none is set" do - app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] } - response = Rack::ETag.new(app).call({}) - response[1]['ETag'].should.equal "\"65a8e27d8879283831b664bd8b7f0ad4\"" - end - - specify "does not change ETag if it is already set" do - app = lambda { |env| [200, {'Content-Type' => 'text/plain', 'ETag' => '"abc"'}, ["Hello, World!"]] } - response = Rack::ETag.new(app).call({}) - response[1]['ETag'].should.equal "\"abc\"" - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_fastcgi.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_fastcgi.rb deleted file mode 100755 index 1ae55ace69b..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_fastcgi.rb +++ /dev/null @@ -1,89 +0,0 @@ -require 'test/spec' -require 'testrequest' - -context "Rack::Handler::FastCGI" do - include TestRequest::Helpers - - setup do - @host = '0.0.0.0' - @port = 9203 - end - - # Keep this first. - specify "startup" do - $pid = fork { - Dir.chdir(File.join(File.dirname(__FILE__), "..", "test", "cgi")) - exec "lighttpd -D -f lighttpd.conf" - } - end - - specify "should respond" do - sleep 1 - lambda { - GET("/test.fcgi") - }.should.not.raise - end - - specify "should be a lighttpd" do - GET("/test.fcgi") - status.should.be 200 - response["SERVER_SOFTWARE"].should =~ /lighttpd/ - response["HTTP_VERSION"].should.equal "HTTP/1.1" - response["SERVER_PROTOCOL"].should.equal "HTTP/1.1" - response["SERVER_PORT"].should.equal @port.to_s - response["SERVER_NAME"].should =~ @host - end - - specify "should have rack headers" do - GET("/test.fcgi") - response["rack.version"].should.equal [1,1] - response["rack.multithread"].should.be false - response["rack.multiprocess"].should.be true - response["rack.run_once"].should.be false - end - - specify "should have CGI headers on GET" do - GET("/test.fcgi") - response["REQUEST_METHOD"].should.equal "GET" - response["SCRIPT_NAME"].should.equal "/test.fcgi" - response["REQUEST_PATH"].should.equal "/" - response["PATH_INFO"].should.equal "" - response["QUERY_STRING"].should.equal "" - response["test.postdata"].should.equal "" - - GET("/test.fcgi/foo?quux=1") - response["REQUEST_METHOD"].should.equal "GET" - response["SCRIPT_NAME"].should.equal "/test.fcgi" - response["REQUEST_PATH"].should.equal "/" - response["PATH_INFO"].should.equal "/foo" - response["QUERY_STRING"].should.equal "quux=1" - end - - specify "should have CGI headers on POST" do - POST("/test.fcgi", {"rack-form-data" => "23"}, {'X-test-header' => '42'}) - status.should.equal 200 - response["REQUEST_METHOD"].should.equal "POST" - response["SCRIPT_NAME"].should.equal "/test.fcgi" - response["REQUEST_PATH"].should.equal "/" - response["QUERY_STRING"].should.equal "" - response["HTTP_X_TEST_HEADER"].should.equal "42" - response["test.postdata"].should.equal "rack-form-data=23" - end - - specify "should support HTTP auth" do - GET("/test.fcgi", {:user => "ruth", :passwd => "secret"}) - response["HTTP_AUTHORIZATION"].should.equal "Basic cnV0aDpzZWNyZXQ=" - end - - specify "should set status" do - GET("/test.fcgi?secret") - status.should.equal 403 - response["rack.url_scheme"].should.equal "http" - end - - # Keep this last. - specify "shutdown" do - Process.kill 15, $pid - Process.wait($pid).should.equal $pid - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_file.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_file.rb deleted file mode 100755 index 0a2f8ee81c8..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_file.rb +++ /dev/null @@ -1,75 +0,0 @@ -require 'test/spec' - -require 'rack/file' -require 'rack/lint' - -require 'rack/mock' - -context "Rack::File" do - DOCROOT = File.expand_path(File.dirname(__FILE__)) unless defined? DOCROOT - - specify "serves files" do - res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))). - get("/cgi/test") - - res.should.be.ok - res.should =~ /ruby/ - end - - specify "sets Last-Modified header" do - res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))). - get("/cgi/test") - - path = File.join(DOCROOT, "/cgi/test") - - res.should.be.ok - res["Last-Modified"].should.equal File.mtime(path).httpdate - end - - specify "serves files with URL encoded filenames" do - res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))). - get("/cgi/%74%65%73%74") # "/cgi/test" - - res.should.be.ok - res.should =~ /ruby/ - end - - specify "does not allow directory traversal" do - res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))). - get("/cgi/../test") - - res.should.be.forbidden - end - - specify "does not allow directory traversal with encoded periods" do - res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))). - get("/%2E%2E/README") - - res.should.be.forbidden - end - - specify "404s if it can't find the file" do - res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))). - get("/cgi/blubb") - - res.should.be.not_found - end - - specify "detects SystemCallErrors" do - res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))). - get("/cgi") - - res.should.be.not_found - end - - specify "returns bodies that respond to #to_path" do - env = Rack::MockRequest.env_for("/cgi/test") - status, headers, body = Rack::File.new(DOCROOT).call(env) - - path = File.join(DOCROOT, "/cgi/test") - - status.should.equal 200 - body.should.respond_to :to_path - body.to_path.should.equal path - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_handler.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_handler.rb deleted file mode 100755 index fcf19b78012..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_handler.rb +++ /dev/null @@ -1,43 +0,0 @@ -require 'test/spec' - -require 'rack/handler' - -class Rack::Handler::Lobster; end -class RockLobster; end - -context "Rack::Handler" do - specify "has registered default handlers" do - Rack::Handler.get('cgi').should.equal Rack::Handler::CGI - Rack::Handler.get('fastcgi').should.equal Rack::Handler::FastCGI - Rack::Handler.get('mongrel').should.equal Rack::Handler::Mongrel - Rack::Handler.get('webrick').should.equal Rack::Handler::WEBrick - end - - specify "handler that doesn't exist should raise a NameError" do - lambda { - Rack::Handler.get('boom') - }.should.raise(NameError) - end - - specify "should get unregistered, but already required, handler by name" do - Rack::Handler.get('Lobster').should.equal Rack::Handler::Lobster - end - - specify "should register custom handler" do - Rack::Handler.register('rock_lobster', 'RockLobster') - Rack::Handler.get('rock_lobster').should.equal RockLobster - end - - specify "should not need registration for properly coded handlers even if not already required" do - begin - $:.push "test/unregistered_handler" - Rack::Handler.get('Unregistered').should.equal Rack::Handler::Unregistered - lambda { - Rack::Handler.get('UnRegistered') - }.should.raise(NameError) - Rack::Handler.get('UnregisteredLongOne').should.equal Rack::Handler::UnregisteredLongOne - ensure - $:.delete "test/unregistered_handler" - end - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_head.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_head.rb deleted file mode 100755 index 48d3f81ff2a..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_head.rb +++ /dev/null @@ -1,30 +0,0 @@ -require 'rack/head' -require 'rack/mock' - -context "Rack::Head" do - def test_response(headers = {}) - app = lambda { |env| [200, {"Content-type" => "test/plain", "Content-length" => "3"}, ["foo"]] } - request = Rack::MockRequest.env_for("/", headers) - response = Rack::Head.new(app).call(request) - - return response - end - - specify "passes GET, POST, PUT, DELETE, OPTIONS, TRACE requests" do - %w[GET POST PUT DELETE OPTIONS TRACE].each do |type| - resp = test_response("REQUEST_METHOD" => type) - - resp[0].should.equal(200) - resp[1].should.equal({"Content-type" => "test/plain", "Content-length" => "3"}) - resp[2].should.equal(["foo"]) - end - end - - specify "removes body from HEAD requests" do - resp = test_response("REQUEST_METHOD" => "HEAD") - - resp[0].should.equal(200) - resp[1].should.equal({"Content-type" => "test/plain", "Content-length" => "3"}) - resp[2].should.equal([]) - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_lint.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_lint.rb deleted file mode 100755 index bbf75c17a40..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_lint.rb +++ /dev/null @@ -1,528 +0,0 @@ -require 'test/spec' -require 'stringio' - -require 'rack/lint' -require 'rack/mock' - -context "Rack::Lint" do - def env(*args) - Rack::MockRequest.env_for("/", *args) - end - - specify "passes valid request" do - lambda { - Rack::Lint.new(lambda { |env| - [200, {"Content-type" => "test/plain", "Content-length" => "3"}, ["foo"]] - }).call(env({})) - }.should.not.raise - end - - specify "notices fatal errors" do - lambda { Rack::Lint.new(nil).call }.should.raise(Rack::Lint::LintError). - message.should.match(/No env given/) - end - - specify "notices environment errors" do - lambda { Rack::Lint.new(nil).call 5 }.should.raise(Rack::Lint::LintError). - message.should.match(/not a Hash/) - - lambda { - e = env - e.delete("REQUEST_METHOD") - Rack::Lint.new(nil).call(e) - }.should.raise(Rack::Lint::LintError). - message.should.match(/missing required key REQUEST_METHOD/) - - lambda { - e = env - e.delete("SERVER_NAME") - Rack::Lint.new(nil).call(e) - }.should.raise(Rack::Lint::LintError). - message.should.match(/missing required key SERVER_NAME/) - - - lambda { - Rack::Lint.new(nil).call(env("HTTP_CONTENT_TYPE" => "text/plain")) - }.should.raise(Rack::Lint::LintError). - message.should.match(/contains HTTP_CONTENT_TYPE/) - - lambda { - Rack::Lint.new(nil).call(env("HTTP_CONTENT_LENGTH" => "42")) - }.should.raise(Rack::Lint::LintError). - message.should.match(/contains HTTP_CONTENT_LENGTH/) - - lambda { - Rack::Lint.new(nil).call(env("FOO" => Object.new)) - }.should.raise(Rack::Lint::LintError). - message.should.match(/non-string value/) - - lambda { - Rack::Lint.new(nil).call(env("rack.version" => "0.2")) - }.should.raise(Rack::Lint::LintError). - message.should.match(/must be an Array/) - - lambda { - Rack::Lint.new(nil).call(env("rack.url_scheme" => "gopher")) - }.should.raise(Rack::Lint::LintError). - message.should.match(/url_scheme unknown/) - - lambda { - Rack::Lint.new(nil).call(env("rack.session" => [])) - }.should.raise(Rack::Lint::LintError). - message.should.equal("session [] must respond to store and []=") - - lambda { - Rack::Lint.new(nil).call(env("rack.logger" => [])) - }.should.raise(Rack::Lint::LintError). - message.should.equal("logger [] must respond to info") - - lambda { - Rack::Lint.new(nil).call(env("REQUEST_METHOD" => "FUCKUP?")) - }.should.raise(Rack::Lint::LintError). - message.should.match(/REQUEST_METHOD/) - - lambda { - Rack::Lint.new(nil).call(env("SCRIPT_NAME" => "howdy")) - }.should.raise(Rack::Lint::LintError). - message.should.match(/must start with/) - - lambda { - Rack::Lint.new(nil).call(env("PATH_INFO" => "../foo")) - }.should.raise(Rack::Lint::LintError). - message.should.match(/must start with/) - - lambda { - Rack::Lint.new(nil).call(env("CONTENT_LENGTH" => "xcii")) - }.should.raise(Rack::Lint::LintError). - message.should.match(/Invalid CONTENT_LENGTH/) - - lambda { - e = env - e.delete("PATH_INFO") - e.delete("SCRIPT_NAME") - Rack::Lint.new(nil).call(e) - }.should.raise(Rack::Lint::LintError). - message.should.match(/One of .* must be set/) - - lambda { - Rack::Lint.new(nil).call(env("SCRIPT_NAME" => "/")) - }.should.raise(Rack::Lint::LintError). - message.should.match(/cannot be .* make it ''/) - end - - specify "notices input errors" do - lambda { - Rack::Lint.new(nil).call(env("rack.input" => "")) - }.should.raise(Rack::Lint::LintError). - message.should.match(/does not respond to #gets/) - - lambda { - input = Object.new - def input.binmode? - false - end - Rack::Lint.new(nil).call(env("rack.input" => input)) - }.should.raise(Rack::Lint::LintError). - message.should.match(/is not opened in binary mode/) - - lambda { - input = Object.new - def input.external_encoding - result = Object.new - def result.name - "US-ASCII" - end - result - end - Rack::Lint.new(nil).call(env("rack.input" => input)) - }.should.raise(Rack::Lint::LintError). - message.should.match(/does not have ASCII-8BIT as its external encoding/) - end - - specify "notices error errors" do - lambda { - Rack::Lint.new(nil).call(env("rack.errors" => "")) - }.should.raise(Rack::Lint::LintError). - message.should.match(/does not respond to #puts/) - end - - specify "notices status errors" do - lambda { - Rack::Lint.new(lambda { |env| - ["cc", {}, ""] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.match(/must be >=100 seen as integer/) - - lambda { - Rack::Lint.new(lambda { |env| - [42, {}, ""] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.match(/must be >=100 seen as integer/) - end - - specify "notices header errors" do - lambda { - Rack::Lint.new(lambda { |env| - [200, Object.new, []] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.equal("headers object should respond to #each, but doesn't (got Object as headers)") - - lambda { - Rack::Lint.new(lambda { |env| - [200, {true=>false}, []] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.equal("header key must be a string, was TrueClass") - - lambda { - Rack::Lint.new(lambda { |env| - [200, {"Status" => "404"}, []] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.match(/must not contain Status/) - - lambda { - Rack::Lint.new(lambda { |env| - [200, {"Content-Type:" => "text/plain"}, []] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.match(/must not contain :/) - - lambda { - Rack::Lint.new(lambda { |env| - [200, {"Content-" => "text/plain"}, []] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.match(/must not end/) - - lambda { - Rack::Lint.new(lambda { |env| - [200, {"..%%quark%%.." => "text/plain"}, []] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.equal("invalid header name: ..%%quark%%..") - - lambda { - Rack::Lint.new(lambda { |env| - [200, {"Foo" => Object.new}, []] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.equal("a header value must be a String, but the value of 'Foo' is a Object") - - lambda { - Rack::Lint.new(lambda { |env| - [200, {"Foo" => [1, 2, 3]}, []] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.equal("a header value must be a String, but the value of 'Foo' is a Array") - - - lambda { - Rack::Lint.new(lambda { |env| - [200, {"Foo-Bar" => "text\000plain"}, []] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.match(/invalid header/) - - # line ends (010) should be allowed in header values. - lambda { - Rack::Lint.new(lambda { |env| - [200, {"Foo-Bar" => "one\ntwo\nthree", "Content-Length" => "0", "Content-Type" => "text/plain" }, []] - }).call(env({})) - }.should.not.raise(Rack::Lint::LintError) - end - - specify "notices content-type errors" do - lambda { - Rack::Lint.new(lambda { |env| - [200, {"Content-length" => "0"}, []] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.match(/No Content-Type/) - - [100, 101, 204, 304].each do |status| - lambda { - Rack::Lint.new(lambda { |env| - [status, {"Content-type" => "text/plain", "Content-length" => "0"}, []] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.match(/Content-Type header found/) - end - end - - specify "notices content-length errors" do - [100, 101, 204, 304].each do |status| - lambda { - Rack::Lint.new(lambda { |env| - [status, {"Content-length" => "0"}, []] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.match(/Content-Length header found/) - end - - lambda { - Rack::Lint.new(lambda { |env| - [200, {"Content-type" => "text/plain", "Content-Length" => "1"}, []] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.match(/Content-Length header was 1, but should be 0/) - end - - specify "notices body errors" do - lambda { - status, header, body = Rack::Lint.new(lambda { |env| - [200, {"Content-type" => "text/plain","Content-length" => "3"}, [1,2,3]] - }).call(env({})) - body.each { |part| } - }.should.raise(Rack::Lint::LintError). - message.should.match(/yielded non-string/) - end - - specify "notices input handling errors" do - lambda { - Rack::Lint.new(lambda { |env| - env["rack.input"].gets("\r\n") - [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.match(/gets called with arguments/) - - lambda { - Rack::Lint.new(lambda { |env| - env["rack.input"].read(1, 2, 3) - [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.match(/read called with too many arguments/) - - lambda { - Rack::Lint.new(lambda { |env| - env["rack.input"].read("foo") - [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.match(/read called with non-integer and non-nil length/) - - lambda { - Rack::Lint.new(lambda { |env| - env["rack.input"].read(-1) - [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.match(/read called with a negative length/) - - lambda { - Rack::Lint.new(lambda { |env| - env["rack.input"].read(nil, nil) - [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.match(/read called with non-String buffer/) - - lambda { - Rack::Lint.new(lambda { |env| - env["rack.input"].read(nil, 1) - [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.match(/read called with non-String buffer/) - - lambda { - Rack::Lint.new(lambda { |env| - env["rack.input"].rewind(0) - [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.match(/rewind called with arguments/) - - weirdio = Object.new - class << weirdio - def gets - 42 - end - - def read - 23 - end - - def each - yield 23 - yield 42 - end - - def rewind - raise Errno::ESPIPE, "Errno::ESPIPE" - end - end - - eof_weirdio = Object.new - class << eof_weirdio - def gets - nil - end - - def read(*args) - nil - end - - def each - end - - def rewind - end - end - - lambda { - Rack::Lint.new(lambda { |env| - env["rack.input"].gets - [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []] - }).call(env("rack.input" => weirdio)) - }.should.raise(Rack::Lint::LintError). - message.should.match(/gets didn't return a String/) - - lambda { - Rack::Lint.new(lambda { |env| - env["rack.input"].each { |x| } - [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []] - }).call(env("rack.input" => weirdio)) - }.should.raise(Rack::Lint::LintError). - message.should.match(/each didn't yield a String/) - - lambda { - Rack::Lint.new(lambda { |env| - env["rack.input"].read - [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []] - }).call(env("rack.input" => weirdio)) - }.should.raise(Rack::Lint::LintError). - message.should.match(/read didn't return nil or a String/) - - lambda { - Rack::Lint.new(lambda { |env| - env["rack.input"].read - [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []] - }).call(env("rack.input" => eof_weirdio)) - }.should.raise(Rack::Lint::LintError). - message.should.match(/read\(nil\) returned nil on EOF/) - - lambda { - Rack::Lint.new(lambda { |env| - env["rack.input"].rewind - [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []] - }).call(env("rack.input" => weirdio)) - }.should.raise(Rack::Lint::LintError). - message.should.match(/rewind raised Errno::ESPIPE/) - - - lambda { - Rack::Lint.new(lambda { |env| - env["rack.input"].close - [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.match(/close must not be called/) - end - - specify "notices error handling errors" do - lambda { - Rack::Lint.new(lambda { |env| - env["rack.errors"].write(42) - [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.match(/write not called with a String/) - - lambda { - Rack::Lint.new(lambda { |env| - env["rack.errors"].close - [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []] - }).call(env({})) - }.should.raise(Rack::Lint::LintError). - message.should.match(/close must not be called/) - end - - specify "notices HEAD errors" do - lambda { - Rack::Lint.new(lambda { |env| - [200, {"Content-type" => "test/plain", "Content-length" => "3"}, []] - }).call(env({"REQUEST_METHOD" => "HEAD"})) - }.should.not.raise - - lambda { - Rack::Lint.new(lambda { |env| - [200, {"Content-type" => "test/plain", "Content-length" => "3"}, ["foo"]] - }).call(env({"REQUEST_METHOD" => "HEAD"})) - }.should.raise(Rack::Lint::LintError). - message.should.match(/body was given for HEAD/) - end - - specify "passes valid read calls" do - hello_str = "hello world" - hello_str.force_encoding("ASCII-8BIT") if hello_str.respond_to? :force_encoding - lambda { - Rack::Lint.new(lambda { |env| - env["rack.input"].read - [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []] - }).call(env({"rack.input" => StringIO.new(hello_str)})) - }.should.not.raise(Rack::Lint::LintError) - - lambda { - Rack::Lint.new(lambda { |env| - env["rack.input"].read(0) - [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []] - }).call(env({"rack.input" => StringIO.new(hello_str)})) - }.should.not.raise(Rack::Lint::LintError) - - lambda { - Rack::Lint.new(lambda { |env| - env["rack.input"].read(1) - [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []] - }).call(env({"rack.input" => StringIO.new(hello_str)})) - }.should.not.raise(Rack::Lint::LintError) - - lambda { - Rack::Lint.new(lambda { |env| - env["rack.input"].read(nil) - [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []] - }).call(env({"rack.input" => StringIO.new(hello_str)})) - }.should.not.raise(Rack::Lint::LintError) - - lambda { - Rack::Lint.new(lambda { |env| - env["rack.input"].read(nil, '') - [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []] - }).call(env({"rack.input" => StringIO.new(hello_str)})) - }.should.not.raise(Rack::Lint::LintError) - - lambda { - Rack::Lint.new(lambda { |env| - env["rack.input"].read(1, '') - [201, {"Content-type" => "text/plain", "Content-length" => "0"}, []] - }).call(env({"rack.input" => StringIO.new(hello_str)})) - }.should.not.raise(Rack::Lint::LintError) - end -end - -context "Rack::Lint::InputWrapper" do - specify "delegates :size to underlying IO object" do - class IOMock - def size - 101 - end - end - - wrapper = Rack::Lint::InputWrapper.new(IOMock.new) - wrapper.size.should == 101 - end - - specify "delegates :rewind to underlying IO object" do - io = StringIO.new("123") - wrapper = Rack::Lint::InputWrapper.new(io) - wrapper.read.should.equal "123" - wrapper.read.should.equal "" - wrapper.rewind - wrapper.read.should.equal "123" - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_lobster.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_lobster.rb deleted file mode 100755 index 7be267a28c0..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_lobster.rb +++ /dev/null @@ -1,45 +0,0 @@ -require 'test/spec' - -require 'rack/lobster' -require 'rack/mock' - -context "Rack::Lobster::LambdaLobster" do - specify "should be a single lambda" do - Rack::Lobster::LambdaLobster.should.be.kind_of Proc - end - - specify "should look like a lobster" do - res = Rack::MockRequest.new(Rack::Lobster::LambdaLobster).get("/") - res.should.be.ok - res.body.should.include "(,(,,(,,,(" - res.body.should.include "?flip" - end - - specify "should be flippable" do - res = Rack::MockRequest.new(Rack::Lobster::LambdaLobster).get("/?flip") - res.should.be.ok - res.body.should.include "(,,,(,,(,(" - end -end - -context "Rack::Lobster" do - specify "should look like a lobster" do - res = Rack::MockRequest.new(Rack::Lobster.new).get("/") - res.should.be.ok - res.body.should.include "(,(,,(,,,(" - res.body.should.include "?flip" - res.body.should.include "crash" - end - - specify "should be flippable" do - res = Rack::MockRequest.new(Rack::Lobster.new).get("/?flip=left") - res.should.be.ok - res.body.should.include "(,,,(,,(,(" - end - - specify "should provide crashing for testing purposes" do - lambda { - Rack::MockRequest.new(Rack::Lobster.new).get("/?flip=crash") - }.should.raise - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_lock.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_lock.rb deleted file mode 100755 index 18af2b2347e..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_lock.rb +++ /dev/null @@ -1,38 +0,0 @@ -require 'test/spec' - -require 'rack/mock' -require 'rack/lock' - -context "Rack::Lock" do - class Lock - attr_reader :synchronized - - def initialize - @synchronized = false - end - - def synchronize - @synchronized = true - yield - end - end - - specify "should call synchronize on lock" do - lock = Lock.new - env = Rack::MockRequest.env_for("/") - app = Rack::Lock.new(lambda { |env| }, lock) - lock.synchronized.should.equal false - app.call(env) - lock.synchronized.should.equal true - end - - specify "should set multithread flag to false" do - app = Rack::Lock.new(lambda { |env| env['rack.multithread'] }) - app.call(Rack::MockRequest.env_for("/")).should.equal false - end - - specify "should reset original multithread flag when exiting lock" do - app = Rack::Lock.new(lambda { |env| env }) - app.call(Rack::MockRequest.env_for("/"))['rack.multithread'].should.equal true - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_logger.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_logger.rb deleted file mode 100755 index 2033006774e..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_logger.rb +++ /dev/null @@ -1,21 +0,0 @@ -require 'rack/logger' -require 'rack/lint' -require 'stringio' - -context "Rack::Logger" do - specify "logs to rack.errors" do - app = lambda { |env| - log = env['rack.logger'] - log.debug("Created logger") - log.info("Program started") - log.warn("Nothing to do!") - - [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] - } - - errors = StringIO.new - Rack::Logger.new(app).call({'rack.errors' => errors}) - errors.string.should.match "Program started" - errors.string.should.match "Nothing to do" - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_methodoverride.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_methodoverride.rb deleted file mode 100755 index 57452394c31..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_methodoverride.rb +++ /dev/null @@ -1,60 +0,0 @@ -require 'test/spec' - -require 'rack/mock' -require 'rack/methodoverride' -require 'stringio' - -context "Rack::MethodOverride" do - specify "should not affect GET requests" do - env = Rack::MockRequest.env_for("/?_method=delete", :method => "GET") - app = Rack::MethodOverride.new(lambda { |env| Rack::Request.new(env) }) - req = app.call(env) - - req.env["REQUEST_METHOD"].should.equal "GET" - end - - specify "_method parameter should modify REQUEST_METHOD for POST requests" do - env = Rack::MockRequest.env_for("/", :method => "POST", :input => "_method=put") - app = Rack::MethodOverride.new(lambda { |env| Rack::Request.new(env) }) - req = app.call(env) - - req.env["REQUEST_METHOD"].should.equal "PUT" - end - - specify "X-HTTP-Method-Override header should modify REQUEST_METHOD for POST requests" do - env = Rack::MockRequest.env_for("/", - :method => "POST", - "HTTP_X_HTTP_METHOD_OVERRIDE" => "PUT" - ) - app = Rack::MethodOverride.new(lambda { |env| Rack::Request.new(env) }) - req = app.call(env) - - req.env["REQUEST_METHOD"].should.equal "PUT" - end - - specify "should not modify REQUEST_METHOD if the method is unknown" do - env = Rack::MockRequest.env_for("/", :method => "POST", :input => "_method=foo") - app = Rack::MethodOverride.new(lambda { |env| Rack::Request.new(env) }) - req = app.call(env) - - req.env["REQUEST_METHOD"].should.equal "POST" - end - - specify "should not modify REQUEST_METHOD when _method is nil" do - env = Rack::MockRequest.env_for("/", :method => "POST", :input => "foo=bar") - app = Rack::MethodOverride.new(lambda { |env| Rack::Request.new(env) }) - req = app.call(env) - - req.env["REQUEST_METHOD"].should.equal "POST" - end - - specify "should store the original REQUEST_METHOD prior to overriding" do - env = Rack::MockRequest.env_for("/", - :method => "POST", - :input => "_method=options") - app = Rack::MethodOverride.new(lambda { |env| Rack::Request.new(env) }) - req = app.call(env) - - req.env["rack.methodoverride.original_method"].should.equal "POST" - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_mock.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_mock.rb deleted file mode 100755 index a03bedc21c5..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_mock.rb +++ /dev/null @@ -1,243 +0,0 @@ -require 'yaml' -require 'rack/mock' -require 'rack/request' -require 'rack/response' - -app = lambda { |env| - req = Rack::Request.new(env) - - env["mock.postdata"] = env["rack.input"].read - if req.GET["error"] - env["rack.errors"].puts req.GET["error"] - env["rack.errors"].flush - end - - Rack::Response.new(env.to_yaml, - req.GET["status"] || 200, - "Content-Type" => "text/yaml").finish -} - -context "Rack::MockRequest" do - specify "should return a MockResponse" do - res = Rack::MockRequest.new(app).get("") - res.should.be.kind_of Rack::MockResponse - end - - specify "should be able to only return the environment" do - env = Rack::MockRequest.env_for("") - env.should.be.kind_of Hash - env.should.include "rack.version" - end - - specify "should provide sensible defaults" do - res = Rack::MockRequest.new(app).request - - env = YAML.load(res.body) - env["REQUEST_METHOD"].should.equal "GET" - env["SERVER_NAME"].should.equal "example.org" - env["SERVER_PORT"].should.equal "80" - env["QUERY_STRING"].should.equal "" - env["PATH_INFO"].should.equal "/" - env["SCRIPT_NAME"].should.equal "" - env["rack.url_scheme"].should.equal "http" - env["mock.postdata"].should.be.empty - end - - specify "should allow GET/POST/PUT/DELETE" do - res = Rack::MockRequest.new(app).get("", :input => "foo") - env = YAML.load(res.body) - env["REQUEST_METHOD"].should.equal "GET" - - res = Rack::MockRequest.new(app).post("", :input => "foo") - env = YAML.load(res.body) - env["REQUEST_METHOD"].should.equal "POST" - - res = Rack::MockRequest.new(app).put("", :input => "foo") - env = YAML.load(res.body) - env["REQUEST_METHOD"].should.equal "PUT" - - res = Rack::MockRequest.new(app).delete("", :input => "foo") - env = YAML.load(res.body) - env["REQUEST_METHOD"].should.equal "DELETE" - - Rack::MockRequest.env_for("/", :method => "OPTIONS")["REQUEST_METHOD"]. - should.equal "OPTIONS" - end - - specify "should set content length" do - env = Rack::MockRequest.env_for("/", :input => "foo") - env["CONTENT_LENGTH"].should.equal "3" - end - - specify "should allow posting" do - res = Rack::MockRequest.new(app).get("", :input => "foo") - env = YAML.load(res.body) - env["mock.postdata"].should.equal "foo" - - res = Rack::MockRequest.new(app).post("", :input => StringIO.new("foo")) - env = YAML.load(res.body) - env["mock.postdata"].should.equal "foo" - end - - specify "should use all parts of an URL" do - res = Rack::MockRequest.new(app). - get("https://bla.example.org:9292/meh/foo?bar") - res.should.be.kind_of Rack::MockResponse - - env = YAML.load(res.body) - env["REQUEST_METHOD"].should.equal "GET" - env["SERVER_NAME"].should.equal "bla.example.org" - env["SERVER_PORT"].should.equal "9292" - env["QUERY_STRING"].should.equal "bar" - env["PATH_INFO"].should.equal "/meh/foo" - env["rack.url_scheme"].should.equal "https" - end - - specify "should set SSL port and HTTP flag on when using https" do - res = Rack::MockRequest.new(app). - get("https://example.org/foo") - res.should.be.kind_of Rack::MockResponse - - env = YAML.load(res.body) - env["REQUEST_METHOD"].should.equal "GET" - env["SERVER_NAME"].should.equal "example.org" - env["SERVER_PORT"].should.equal "443" - env["QUERY_STRING"].should.equal "" - env["PATH_INFO"].should.equal "/foo" - env["rack.url_scheme"].should.equal "https" - env["HTTPS"].should.equal "on" - end - - specify "should prepend slash to uri path" do - res = Rack::MockRequest.new(app). - get("foo") - res.should.be.kind_of Rack::MockResponse - - env = YAML.load(res.body) - env["REQUEST_METHOD"].should.equal "GET" - env["SERVER_NAME"].should.equal "example.org" - env["SERVER_PORT"].should.equal "80" - env["QUERY_STRING"].should.equal "" - env["PATH_INFO"].should.equal "/foo" - env["rack.url_scheme"].should.equal "http" - end - - specify "should properly convert method name to an uppercase string" do - res = Rack::MockRequest.new(app).request(:get) - env = YAML.load(res.body) - env["REQUEST_METHOD"].should.equal "GET" - end - - specify "should accept params and build query string for GET requests" do - res = Rack::MockRequest.new(app).get("/foo?baz=2", :params => {:foo => {:bar => "1"}}) - env = YAML.load(res.body) - env["REQUEST_METHOD"].should.equal "GET" - env["QUERY_STRING"].should.match "baz=2" - env["QUERY_STRING"].should.match "foo[bar]=1" - env["PATH_INFO"].should.equal "/foo" - env["mock.postdata"].should.equal "" - end - - specify "should accept raw input in params for GET requests" do - res = Rack::MockRequest.new(app).get("/foo?baz=2", :params => "foo[bar]=1") - env = YAML.load(res.body) - env["REQUEST_METHOD"].should.equal "GET" - env["QUERY_STRING"].should.match "baz=2" - env["QUERY_STRING"].should.match "foo[bar]=1" - env["PATH_INFO"].should.equal "/foo" - env["mock.postdata"].should.equal "" - end - - specify "should accept params and build url encoded params for POST requests" do - res = Rack::MockRequest.new(app).post("/foo", :params => {:foo => {:bar => "1"}}) - env = YAML.load(res.body) - env["REQUEST_METHOD"].should.equal "POST" - env["QUERY_STRING"].should.equal "" - env["PATH_INFO"].should.equal "/foo" - env["CONTENT_TYPE"].should.equal "application/x-www-form-urlencoded" - env["mock.postdata"].should.equal "foo[bar]=1" - end - - specify "should accept raw input in params for POST requests" do - res = Rack::MockRequest.new(app).post("/foo", :params => "foo[bar]=1") - env = YAML.load(res.body) - env["REQUEST_METHOD"].should.equal "POST" - env["QUERY_STRING"].should.equal "" - env["PATH_INFO"].should.equal "/foo" - env["CONTENT_TYPE"].should.equal "application/x-www-form-urlencoded" - env["mock.postdata"].should.equal "foo[bar]=1" - end - - specify "should accept params and build multipart encoded params for POST requests" do - files = Rack::Utils::Multipart::UploadedFile.new(File.join(File.dirname(__FILE__), "multipart", "file1.txt")) - res = Rack::MockRequest.new(app).post("/foo", :params => { "submit-name" => "Larry", "files" => files }) - env = YAML.load(res.body) - env["REQUEST_METHOD"].should.equal "POST" - env["QUERY_STRING"].should.equal "" - env["PATH_INFO"].should.equal "/foo" - env["CONTENT_TYPE"].should.equal "multipart/form-data; boundary=AaB03x" - env["mock.postdata"].length.should.equal 206 - end - - specify "should behave valid according to the Rack spec" do - lambda { - res = Rack::MockRequest.new(app). - get("https://bla.example.org:9292/meh/foo?bar", :lint => true) - }.should.not.raise(Rack::Lint::LintError) - end -end - -context "Rack::MockResponse" do - specify "should provide access to the HTTP status" do - res = Rack::MockRequest.new(app).get("") - res.should.be.successful - res.should.be.ok - - res = Rack::MockRequest.new(app).get("/?status=404") - res.should.not.be.successful - res.should.be.client_error - res.should.be.not_found - - res = Rack::MockRequest.new(app).get("/?status=501") - res.should.not.be.successful - res.should.be.server_error - - res = Rack::MockRequest.new(app).get("/?status=307") - res.should.be.redirect - - res = Rack::MockRequest.new(app).get("/?status=201", :lint => true) - res.should.be.empty - end - - specify "should provide access to the HTTP headers" do - res = Rack::MockRequest.new(app).get("") - res.should.include "Content-Type" - res.headers["Content-Type"].should.equal "text/yaml" - res.original_headers["Content-Type"].should.equal "text/yaml" - res["Content-Type"].should.equal "text/yaml" - res.content_type.should.equal "text/yaml" - res.content_length.should.be 414 # needs change often. - res.location.should.be.nil - end - - specify "should provide access to the HTTP body" do - res = Rack::MockRequest.new(app).get("") - res.body.should =~ /rack/ - res.should =~ /rack/ - res.should.match(/rack/) - res.should.satisfy { |r| r.match(/rack/) } - end - - specify "should provide access to the Rack errors" do - res = Rack::MockRequest.new(app).get("/?error=foo", :lint => true) - res.should.be.ok - res.errors.should.not.be.empty - res.errors.should.include "foo" - end - - specify "should optionally make Rack errors fatal" do - lambda { - Rack::MockRequest.new(app).get("/?error=foo", :fatal => true) - }.should.raise(Rack::MockRequest::FatalWarning) - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_mongrel.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_mongrel.rb deleted file mode 100755 index 4b38689132b..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_mongrel.rb +++ /dev/null @@ -1,189 +0,0 @@ -require 'test/spec' - -begin -require 'rack/handler/mongrel' -require 'rack/urlmap' -require 'rack/lint' -require 'testrequest' -require 'timeout' - -Thread.abort_on_exception = true -$tcp_defer_accept_opts = nil -$tcp_cork_opts = nil - -context "Rack::Handler::Mongrel" do - include TestRequest::Helpers - - setup do - server = Mongrel::HttpServer.new(@host='0.0.0.0', @port=9201) - server.register('/test', - Rack::Handler::Mongrel.new(Rack::Lint.new(TestRequest.new))) - server.register('/stream', - Rack::Handler::Mongrel.new(Rack::Lint.new(StreamingRequest))) - @acc = server.run - end - - specify "should respond" do - lambda { - GET("/test") - }.should.not.raise - end - - specify "should be a Mongrel" do - GET("/test") - status.should.be 200 - response["SERVER_SOFTWARE"].should =~ /Mongrel/ - response["HTTP_VERSION"].should.equal "HTTP/1.1" - response["SERVER_PROTOCOL"].should.equal "HTTP/1.1" - response["SERVER_PORT"].should.equal "9201" - response["SERVER_NAME"].should.equal "0.0.0.0" - end - - specify "should have rack headers" do - GET("/test") - response["rack.version"].should.equal [1,1] - response["rack.multithread"].should.be true - response["rack.multiprocess"].should.be false - response["rack.run_once"].should.be false - end - - specify "should have CGI headers on GET" do - GET("/test") - response["REQUEST_METHOD"].should.equal "GET" - response["SCRIPT_NAME"].should.equal "/test" - response["REQUEST_PATH"].should.equal "/test" - response["PATH_INFO"].should.be.equal "" - response["QUERY_STRING"].should.equal "" - response["test.postdata"].should.equal "" - - GET("/test/foo?quux=1") - response["REQUEST_METHOD"].should.equal "GET" - response["SCRIPT_NAME"].should.equal "/test" - response["REQUEST_PATH"].should.equal "/test/foo" - response["PATH_INFO"].should.equal "/foo" - response["QUERY_STRING"].should.equal "quux=1" - end - - specify "should have CGI headers on POST" do - POST("/test", {"rack-form-data" => "23"}, {'X-test-header' => '42'}) - status.should.equal 200 - response["REQUEST_METHOD"].should.equal "POST" - response["SCRIPT_NAME"].should.equal "/test" - response["REQUEST_PATH"].should.equal "/test" - response["QUERY_STRING"].should.equal "" - response["HTTP_X_TEST_HEADER"].should.equal "42" - response["test.postdata"].should.equal "rack-form-data=23" - end - - specify "should support HTTP auth" do - GET("/test", {:user => "ruth", :passwd => "secret"}) - response["HTTP_AUTHORIZATION"].should.equal "Basic cnV0aDpzZWNyZXQ=" - end - - specify "should set status" do - GET("/test?secret") - status.should.equal 403 - response["rack.url_scheme"].should.equal "http" - end - - specify "should provide a .run" do - block_ran = false - Thread.new { - Rack::Handler::Mongrel.run(lambda {}, {:Port => 9211}) { |server| - server.should.be.kind_of Mongrel::HttpServer - block_ran = true - } - } - sleep 1 - block_ran.should.be true - end - - specify "should provide a .run that maps a hash" do - block_ran = false - Thread.new { - map = {'/'=>lambda{},'/foo'=>lambda{}} - Rack::Handler::Mongrel.run(map, :map => true, :Port => 9221) { |server| - server.should.be.kind_of Mongrel::HttpServer - server.classifier.uris.size.should.be 2 - server.classifier.uris.should.not.include '/arf' - server.classifier.uris.should.include '/' - server.classifier.uris.should.include '/foo' - block_ran = true - } - } - sleep 1 - block_ran.should.be true - end - - specify "should provide a .run that maps a urlmap" do - block_ran = false - Thread.new { - map = Rack::URLMap.new({'/'=>lambda{},'/bar'=>lambda{}}) - Rack::Handler::Mongrel.run(map, {:map => true, :Port => 9231}) { |server| - server.should.be.kind_of Mongrel::HttpServer - server.classifier.uris.size.should.be 2 - server.classifier.uris.should.not.include '/arf' - server.classifier.uris.should.include '/' - server.classifier.uris.should.include '/bar' - block_ran = true - } - } - sleep 1 - block_ran.should.be true - end - - specify "should provide a .run that maps a urlmap restricting by host" do - block_ran = false - Thread.new { - map = Rack::URLMap.new({ - '/' => lambda{}, - '/foo' => lambda{}, - '/bar' => lambda{}, - 'http://localhost/' => lambda{}, - 'http://localhost/bar' => lambda{}, - 'http://falsehost/arf' => lambda{}, - 'http://falsehost/qux' => lambda{} - }) - opt = {:map => true, :Port => 9241, :Host => 'localhost'} - Rack::Handler::Mongrel.run(map, opt) { |server| - server.should.be.kind_of Mongrel::HttpServer - server.classifier.uris.should.include '/' - server.classifier.handler_map['/'].size.should.be 2 - server.classifier.uris.should.include '/foo' - server.classifier.handler_map['/foo'].size.should.be 1 - server.classifier.uris.should.include '/bar' - server.classifier.handler_map['/bar'].size.should.be 2 - server.classifier.uris.should.not.include '/qux' - server.classifier.uris.should.not.include '/arf' - server.classifier.uris.size.should.be 3 - block_ran = true - } - } - sleep 1 - block_ran.should.be true - end - - specify "should stream #each part of the response" do - body = '' - begin - Timeout.timeout(1) do - Net::HTTP.start(@host, @port) do |http| - get = Net::HTTP::Get.new('/stream') - http.request(get) do |response| - response.read_body { |part| body << part } - end - end - end - rescue Timeout::Error - end - body.should.not.be.empty - end - - teardown do - @acc.raise Mongrel::StopServer - end -end - -rescue LoadError - $stderr.puts "Skipping Rack::Handler::Mongrel tests (Mongrel is required). `gem install mongrel` and try again." -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_nulllogger.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_nulllogger.rb deleted file mode 100755 index b3c2bc9c658..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_nulllogger.rb +++ /dev/null @@ -1,13 +0,0 @@ -require 'rack/nulllogger' -require 'rack/lint' -require 'rack/mock' - -context "Rack::NullLogger" do - specify "acks as a nop logger" do - app = lambda { |env| - env['rack.logger'].warn "b00m" - [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] - } - Rack::NullLogger.new(app).call({}) - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_recursive.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_recursive.rb deleted file mode 100755 index afc1a0d9a9c..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_recursive.rb +++ /dev/null @@ -1,77 +0,0 @@ -require 'test/spec' - -require 'rack/recursive' -require 'rack/urlmap' -require 'rack/response' -require 'rack/mock' - -context "Rack::Recursive" do - setup do - - @app1 = lambda { |env| - res = Rack::Response.new - res["X-Path-Info"] = env["PATH_INFO"] - res["X-Query-String"] = env["QUERY_STRING"] - res.finish do |res| - res.write "App1" - end - } - - @app2 = lambda { |env| - Rack::Response.new.finish do |res| - res.write "App2" - _, _, body = env['rack.recursive.include'].call(env, "/app1") - body.each { |b| - res.write b - } - end - } - - @app3 = lambda { |env| - raise Rack::ForwardRequest.new("/app1") - } - - @app4 = lambda { |env| - raise Rack::ForwardRequest.new("http://example.org/app1/quux?meh") - } - - end - - specify "should allow for subrequests" do - res = Rack::MockRequest.new(Rack::Recursive.new( - Rack::URLMap.new("/app1" => @app1, - "/app2" => @app2))). - get("/app2") - - res.should.be.ok - res.body.should.equal "App2App1" - end - - specify "should raise error on requests not below the app" do - app = Rack::URLMap.new("/app1" => @app1, - "/app" => Rack::Recursive.new( - Rack::URLMap.new("/1" => @app1, - "/2" => @app2))) - - lambda { - Rack::MockRequest.new(app).get("/app/2") - }.should.raise(ArgumentError). - message.should =~ /can only include below/ - end - - specify "should support forwarding" do - app = Rack::Recursive.new(Rack::URLMap.new("/app1" => @app1, - "/app3" => @app3, - "/app4" => @app4)) - - res = Rack::MockRequest.new(app).get("/app3") - res.should.be.ok - res.body.should.equal "App1" - - res = Rack::MockRequest.new(app).get("/app4") - res.should.be.ok - res.body.should.equal "App1" - res["X-Path-Info"].should.equal "/quux" - res["X-Query-String"].should.equal "meh" - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_request.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_request.rb deleted file mode 100755 index a34a9675f9c..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_request.rb +++ /dev/null @@ -1,594 +0,0 @@ -require 'test/spec' -require 'stringio' - -require 'rack/request' -require 'rack/mock' - -context "Rack::Request" do - specify "wraps the rack variables" do - req = Rack::Request.new(Rack::MockRequest.env_for("http://example.com:8080/")) - - req.body.should.respond_to? :gets - req.scheme.should.equal "http" - req.request_method.should.equal "GET" - - req.should.be.get - req.should.not.be.post - req.should.not.be.put - req.should.not.be.delete - req.should.not.be.head - - req.script_name.should.equal "" - req.path_info.should.equal "/" - req.query_string.should.equal "" - - req.host.should.equal "example.com" - req.port.should.equal 8080 - - req.content_length.should.equal "0" - req.content_type.should.be.nil - end - - specify "can figure out the correct host" do - req = Rack::Request.new \ - Rack::MockRequest.env_for("/", "HTTP_HOST" => "www2.example.org") - req.host.should.equal "www2.example.org" - - req = Rack::Request.new \ - Rack::MockRequest.env_for("/", "SERVER_NAME" => "example.org", "SERVER_PORT" => "9292") - req.host.should.equal "example.org" - - req = Rack::Request.new \ - Rack::MockRequest.env_for("/", "HTTP_HOST" => "localhost:81", "HTTP_X_FORWARDED_HOST" => "example.org:9292") - req.host.should.equal "example.org" - - env = Rack::MockRequest.env_for("/", "SERVER_ADDR" => "192.168.1.1", "SERVER_PORT" => "9292") - env.delete("SERVER_NAME") - req = Rack::Request.new(env) - req.host.should.equal "192.168.1.1" - - env = Rack::MockRequest.env_for("/") - env.delete("SERVER_NAME") - req = Rack::Request.new(env) - req.host.should.equal "" - end - - specify "can parse the query string" do - req = Rack::Request.new(Rack::MockRequest.env_for("/?foo=bar&quux=bla")) - req.query_string.should.equal "foo=bar&quux=bla" - req.GET.should.equal "foo" => "bar", "quux" => "bla" - req.POST.should.be.empty - req.params.should.equal "foo" => "bar", "quux" => "bla" - end - - specify "raises if rack.input is missing" do - req = Rack::Request.new({}) - lambda { req.POST }.should.raise(RuntimeError) - end - - specify "can parse POST data when method is POST and no Content-Type given" do - req = Rack::Request.new \ - Rack::MockRequest.env_for("/?foo=quux", - "REQUEST_METHOD" => 'POST', - :input => "foo=bar&quux=bla") - req.content_type.should.be.nil - req.media_type.should.be.nil - req.query_string.should.equal "foo=quux" - req.GET.should.equal "foo" => "quux" - req.POST.should.equal "foo" => "bar", "quux" => "bla" - req.params.should.equal "foo" => "bar", "quux" => "bla" - end - - specify "limit the keys from the GET query string" do - env = Rack::MockRequest.env_for("/?foo=bar") - - old, Rack::Utils.key_space_limit = Rack::Utils.key_space_limit, 1 - begin - req = Rack::Request.new(env) - lambda { req.GET }.should.raise(RangeError) - ensure - Rack::Utils.key_space_limit = old - end - end - - specify "limit the keys from the POST form data" do - env = Rack::MockRequest.env_for("", - "REQUEST_METHOD" => 'POST', - :input => "foo=bar&quux=bla") - - old, Rack::Utils.key_space_limit = Rack::Utils.key_space_limit, 1 - begin - req = Rack::Request.new(env) - lambda { req.POST }.should.raise(RangeError) - ensure - Rack::Utils.key_space_limit = old - end - end - - specify "can parse POST data with explicit content type regardless of method" do - req = Rack::Request.new \ - Rack::MockRequest.env_for("/", - "CONTENT_TYPE" => 'application/x-www-form-urlencoded;foo=bar', - :input => "foo=bar&quux=bla") - req.content_type.should.equal 'application/x-www-form-urlencoded;foo=bar' - req.media_type.should.equal 'application/x-www-form-urlencoded' - req.media_type_params['foo'].should.equal 'bar' - req.POST.should.equal "foo" => "bar", "quux" => "bla" - req.params.should.equal "foo" => "bar", "quux" => "bla" - end - - specify "does not parse POST data when media type is not form-data" do - req = Rack::Request.new \ - Rack::MockRequest.env_for("/?foo=quux", - "REQUEST_METHOD" => 'POST', - "CONTENT_TYPE" => 'text/plain;charset=utf-8', - :input => "foo=bar&quux=bla") - req.content_type.should.equal 'text/plain;charset=utf-8' - req.media_type.should.equal 'text/plain' - req.media_type_params['charset'].should.equal 'utf-8' - req.POST.should.be.empty - req.params.should.equal "foo" => "quux" - req.body.read.should.equal "foo=bar&quux=bla" - end - - specify "can parse POST data on PUT when media type is form-data" do - req = Rack::Request.new \ - Rack::MockRequest.env_for("/?foo=quux", - "REQUEST_METHOD" => 'PUT', - "CONTENT_TYPE" => 'application/x-www-form-urlencoded', - :input => "foo=bar&quux=bla") - req.POST.should.equal "foo" => "bar", "quux" => "bla" - req.body.read.should.equal "foo=bar&quux=bla" - end - - specify "rewinds input after parsing POST data" do - input = StringIO.new("foo=bar&quux=bla") - req = Rack::Request.new \ - Rack::MockRequest.env_for("/", - "CONTENT_TYPE" => 'application/x-www-form-urlencoded;foo=bar', - :input => input) - req.params.should.equal "foo" => "bar", "quux" => "bla" - input.read.should.equal "foo=bar&quux=bla" - end - - specify "cleans up Safari's ajax POST body" do - req = Rack::Request.new \ - Rack::MockRequest.env_for("/", - 'REQUEST_METHOD' => 'POST', :input => "foo=bar&quux=bla\0") - req.POST.should.equal "foo" => "bar", "quux" => "bla" - end - - specify "can get value by key from params with #[]" do - req = Rack::Request.new \ - Rack::MockRequest.env_for("?foo=quux") - req['foo'].should.equal 'quux' - req[:foo].should.equal 'quux' - end - - specify "can set value to key on params with #[]=" do - req = Rack::Request.new \ - Rack::MockRequest.env_for("?foo=duh") - req['foo'].should.equal 'duh' - req[:foo].should.equal 'duh' - req.params.should.equal 'foo' => 'duh' - - req['foo'] = 'bar' - req.params.should.equal 'foo' => 'bar' - req['foo'].should.equal 'bar' - req[:foo].should.equal 'bar' - - req[:foo] = 'jaz' - req.params.should.equal 'foo' => 'jaz' - req['foo'].should.equal 'jaz' - req[:foo].should.equal 'jaz' - end - - specify "values_at answers values by keys in order given" do - req = Rack::Request.new \ - Rack::MockRequest.env_for("?foo=baz&wun=der&bar=ful") - req.values_at('foo').should.equal ['baz'] - req.values_at('foo', 'wun').should.equal ['baz', 'der'] - req.values_at('bar', 'foo', 'wun').should.equal ['ful', 'baz', 'der'] - end - - specify "referrer should be extracted correct" do - req = Rack::Request.new \ - Rack::MockRequest.env_for("/", "HTTP_REFERER" => "/some/path") - req.referer.should.equal "/some/path" - - req = Rack::Request.new \ - Rack::MockRequest.env_for("/") - req.referer.should.equal "/" - end - - specify "user agent should be extracted correct" do - req = Rack::Request.new \ - Rack::MockRequest.env_for("/", "HTTP_USER_AGENT" => "Mozilla/4.0 (compatible)") - req.user_agent.should.equal "Mozilla/4.0 (compatible)" - - req = Rack::Request.new \ - Rack::MockRequest.env_for("/") - req.user_agent.should.equal nil - end - - specify "can cache, but invalidates the cache" do - req = Rack::Request.new \ - Rack::MockRequest.env_for("/?foo=quux", - "CONTENT_TYPE" => "application/x-www-form-urlencoded", - :input => "foo=bar&quux=bla") - req.GET.should.equal "foo" => "quux" - req.GET.should.equal "foo" => "quux" - req.env["QUERY_STRING"] = "bla=foo" - req.GET.should.equal "bla" => "foo" - req.GET.should.equal "bla" => "foo" - - req.POST.should.equal "foo" => "bar", "quux" => "bla" - req.POST.should.equal "foo" => "bar", "quux" => "bla" - req.env["rack.input"] = StringIO.new("foo=bla&quux=bar") - req.POST.should.equal "foo" => "bla", "quux" => "bar" - req.POST.should.equal "foo" => "bla", "quux" => "bar" - end - - specify "can figure out if called via XHR" do - req = Rack::Request.new(Rack::MockRequest.env_for("")) - req.should.not.be.xhr - - req = Rack::Request.new \ - Rack::MockRequest.env_for("", "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest") - req.should.be.xhr - end - - specify "can parse cookies" do - req = Rack::Request.new \ - Rack::MockRequest.env_for("", "HTTP_COOKIE" => "foo=bar;quux=h&m") - req.cookies.should.equal "foo" => "bar", "quux" => "h&m" - req.cookies.should.equal "foo" => "bar", "quux" => "h&m" - req.env.delete("HTTP_COOKIE") - req.cookies.should.equal({}) - end - - specify "parses cookies according to RFC 2109" do - req = Rack::Request.new \ - Rack::MockRequest.env_for('', 'HTTP_COOKIE' => 'foo=bar;foo=car') - req.cookies.should.equal 'foo' => 'bar' - end - - specify "provides setters" do - req = Rack::Request.new(e=Rack::MockRequest.env_for("")) - req.script_name.should.equal "" - req.script_name = "/foo" - req.script_name.should.equal "/foo" - e["SCRIPT_NAME"].should.equal "/foo" - - req.path_info.should.equal "/" - req.path_info = "/foo" - req.path_info.should.equal "/foo" - e["PATH_INFO"].should.equal "/foo" - end - - specify "provides the original env" do - req = Rack::Request.new(e=Rack::MockRequest.env_for("")) - req.env.should.be e - end - - specify "can restore the URL" do - Rack::Request.new(Rack::MockRequest.env_for("")).url. - should.equal "http://example.org/" - Rack::Request.new(Rack::MockRequest.env_for("", "SCRIPT_NAME" => "/foo")).url. - should.equal "http://example.org/foo/" - Rack::Request.new(Rack::MockRequest.env_for("/foo")).url. - should.equal "http://example.org/foo" - Rack::Request.new(Rack::MockRequest.env_for("?foo")).url. - should.equal "http://example.org/?foo" - Rack::Request.new(Rack::MockRequest.env_for("http://example.org:8080/")).url. - should.equal "http://example.org:8080/" - Rack::Request.new(Rack::MockRequest.env_for("https://example.org/")).url. - should.equal "https://example.org/" - - Rack::Request.new(Rack::MockRequest.env_for("https://example.com:8080/foo?foo")).url. - should.equal "https://example.com:8080/foo?foo" - end - - specify "can restore the full path" do - Rack::Request.new(Rack::MockRequest.env_for("")).fullpath. - should.equal "/" - Rack::Request.new(Rack::MockRequest.env_for("", "SCRIPT_NAME" => "/foo")).fullpath. - should.equal "/foo/" - Rack::Request.new(Rack::MockRequest.env_for("/foo")).fullpath. - should.equal "/foo" - Rack::Request.new(Rack::MockRequest.env_for("?foo")).fullpath. - should.equal "/?foo" - Rack::Request.new(Rack::MockRequest.env_for("http://example.org:8080/")).fullpath. - should.equal "/" - Rack::Request.new(Rack::MockRequest.env_for("https://example.org/")).fullpath. - should.equal "/" - - Rack::Request.new(Rack::MockRequest.env_for("https://example.com:8080/foo?foo")).fullpath. - should.equal "/foo?foo" - end - - specify "can handle multiple media type parameters" do - req = Rack::Request.new \ - Rack::MockRequest.env_for("/", - "CONTENT_TYPE" => 'text/plain; foo=BAR,baz=bizzle dizzle;BLING=bam') - req.should.not.be.form_data - req.media_type_params.should.include 'foo' - req.media_type_params['foo'].should.equal 'BAR' - req.media_type_params.should.include 'baz' - req.media_type_params['baz'].should.equal 'bizzle dizzle' - req.media_type_params.should.not.include 'BLING' - req.media_type_params.should.include 'bling' - req.media_type_params['bling'].should.equal 'bam' - end - - specify "raise RangeError if the key space is exhausted" do - input = <<EOF ---AaB03x\r -Content-Disposition: form-data; name="text"\r -Content-Type: text/plain; charset=US-ASCII\r -\r -contents\r ---AaB03x--\r -EOF - - env = Rack::MockRequest.env_for("/", - "CONTENT_TYPE" => "multipart/form-data, boundary=AaB03x", - "CONTENT_LENGTH" => input.size, - :input => input) - - old, Rack::Utils.key_space_limit = Rack::Utils.key_space_limit, 1 - begin - lambda { Rack::Utils::Multipart.parse_multipart(env) }.should.raise(RangeError) - ensure - Rack::Utils.key_space_limit = old - end - end - - specify "can parse multipart form data" do - # Adapted from RFC 1867. - input = <<EOF ---AaB03x\r -content-disposition: form-data; name="reply"\r -\r -yes\r ---AaB03x\r -content-disposition: form-data; name="fileupload"; filename="dj.jpg"\r -Content-Type: image/jpeg\r -Content-Transfer-Encoding: base64\r -\r -/9j/4AAQSkZJRgABAQAAAQABAAD//gA+Q1JFQVRPUjogZ2QtanBlZyB2MS4wICh1c2luZyBJSkcg\r ---AaB03x--\r -EOF - req = Rack::Request.new Rack::MockRequest.env_for("/", - "CONTENT_TYPE" => "multipart/form-data, boundary=AaB03x", - "CONTENT_LENGTH" => input.size, - :input => input) - - req.POST.should.include "fileupload" - req.POST.should.include "reply" - - req.should.be.form_data - req.content_length.should.equal input.size - req.media_type.should.equal 'multipart/form-data' - req.media_type_params.should.include 'boundary' - req.media_type_params['boundary'].should.equal 'AaB03x' - - req.POST["reply"].should.equal "yes" - - f = req.POST["fileupload"] - f.should.be.kind_of Hash - f[:type].should.equal "image/jpeg" - f[:filename].should.equal "dj.jpg" - f.should.include :tempfile - f[:tempfile].size.should.equal 76 - end - - specify "can parse big multipart form data" do - input = <<EOF ---AaB03x\r -content-disposition: form-data; name="huge"; filename="huge"\r -\r -#{"x"*32768}\r ---AaB03x\r -content-disposition: form-data; name="mean"; filename="mean"\r -\r ---AaB03xha\r ---AaB03x--\r -EOF - req = Rack::Request.new Rack::MockRequest.env_for("/", - "CONTENT_TYPE" => "multipart/form-data, boundary=AaB03x", - "CONTENT_LENGTH" => input.size, - :input => input) - - req.POST["huge"][:tempfile].size.should.equal 32768 - req.POST["mean"][:tempfile].size.should.equal 10 - req.POST["mean"][:tempfile].read.should.equal "--AaB03xha" - end - - specify "can detect invalid multipart form data" do - input = <<EOF ---AaB03x\r -content-disposition: form-data; name="huge"; filename="huge"\r -EOF - req = Rack::Request.new Rack::MockRequest.env_for("/", - "CONTENT_TYPE" => "multipart/form-data, boundary=AaB03x", - "CONTENT_LENGTH" => input.size, - :input => input) - - lambda { req.POST }.should.raise(EOFError) - - input = <<EOF ---AaB03x\r -content-disposition: form-data; name="huge"; filename="huge"\r -\r -foo\r -EOF - req = Rack::Request.new Rack::MockRequest.env_for("/", - "CONTENT_TYPE" => "multipart/form-data, boundary=AaB03x", - "CONTENT_LENGTH" => input.size, - :input => input) - - lambda { req.POST }.should.raise(EOFError) - - input = <<EOF ---AaB03x\r -content-disposition: form-data; name="huge"; filename="huge"\r -\r -foo\r -EOF - req = Rack::Request.new Rack::MockRequest.env_for("/", - "CONTENT_TYPE" => "multipart/form-data, boundary=AaB03x", - "CONTENT_LENGTH" => input.size, - :input => input) - - lambda { req.POST }.should.raise(EOFError) - end - - specify "shouldn't try to interpret binary as utf8" do - begin - original_kcode = $KCODE - $KCODE='UTF8' - - input = <<EOF ---AaB03x\r -content-disposition: form-data; name="fileupload"; filename="junk.a"\r -content-type: application/octet-stream\r -\r -#{[0x36,0xCF,0x0A,0xF8].pack('c*')}\r ---AaB03x--\r -EOF - - req = Rack::Request.new Rack::MockRequest.env_for("/", - "CONTENT_TYPE" => "multipart/form-data, boundary=AaB03x", - "CONTENT_LENGTH" => input.size, - :input => input) - - lambda{req.POST}.should.not.raise(EOFError) - req.POST["fileupload"][:tempfile].size.should.equal 4 - ensure - $KCODE = original_kcode - end - end - - - specify "should work around buggy 1.8.* Tempfile equality" do - input = <<EOF ---AaB03x\r -content-disposition: form-data; name="huge"; filename="huge"\r -\r -foo\r ---AaB03x-- -EOF - - rack_input = Tempfile.new("rackspec") - rack_input.write(input) - rack_input.rewind - - req = Rack::Request.new Rack::MockRequest.env_for("/", - "CONTENT_TYPE" => "multipart/form-data, boundary=AaB03x", - "CONTENT_LENGTH" => input.size, - :input => rack_input) - - lambda {req.POST}.should.not.raise - lambda {req.POST}.should.blaming("input re-processed!").not.raise - end - - specify "does conform to the Rack spec" do - app = lambda { |env| - content = Rack::Request.new(env).POST["file"].inspect - size = content.respond_to?(:bytesize) ? content.bytesize : content.size - [200, {"Content-Type" => "text/html", "Content-Length" => size.to_s}, [content]] - } - - input = <<EOF ---AaB03x\r -content-disposition: form-data; name="reply"\r -\r -yes\r ---AaB03x\r -content-disposition: form-data; name="fileupload"; filename="dj.jpg"\r -Content-Type: image/jpeg\r -Content-Transfer-Encoding: base64\r -\r -/9j/4AAQSkZJRgABAQAAAQABAAD//gA+Q1JFQVRPUjogZ2QtanBlZyB2MS4wICh1c2luZyBJSkcg\r ---AaB03x--\r -EOF - input.force_encoding("ASCII-8BIT") if input.respond_to? :force_encoding - res = Rack::MockRequest.new(Rack::Lint.new(app)).get "/", - "CONTENT_TYPE" => "multipart/form-data, boundary=AaB03x", - "CONTENT_LENGTH" => input.size.to_s, "rack.input" => StringIO.new(input) - - res.should.be.ok - end - - specify "should parse Accept-Encoding correctly" do - parser = lambda do |x| - Rack::Request.new(Rack::MockRequest.env_for("", "HTTP_ACCEPT_ENCODING" => x)).accept_encoding - end - - parser.call(nil).should.equal([]) - - parser.call("compress, gzip").should.equal([["compress", 1.0], ["gzip", 1.0]]) - parser.call("").should.equal([]) - parser.call("*").should.equal([["*", 1.0]]) - parser.call("compress;q=0.5, gzip;q=1.0").should.equal([["compress", 0.5], ["gzip", 1.0]]) - parser.call("gzip;q=1.0, identity; q=0.5, *;q=0").should.equal([["gzip", 1.0], ["identity", 0.5], ["*", 0] ]) - - lambda { parser.call("gzip ; q=1.0") }.should.raise(RuntimeError) - end - - specify 'should provide ip information' do - app = lambda { |env| - request = Rack::Request.new(env) - response = Rack::Response.new - response.write request.ip - response.finish - } - - mock = Rack::MockRequest.new(Rack::Lint.new(app)) - res = mock.get '/', 'REMOTE_ADDR' => '123.123.123.123' - res.body.should.equal '123.123.123.123' - - res = mock.get '/', - 'REMOTE_ADDR' => '123.123.123.123', - 'HTTP_X_FORWARDED_FOR' => '234.234.234.234' - - res.body.should.equal '234.234.234.234' - - res = mock.get '/', - 'REMOTE_ADDR' => '123.123.123.123', - 'HTTP_X_FORWARDED_FOR' => '234.234.234.234,212.212.212.212' - - res.body.should.equal '212.212.212.212' - end - - class MyRequest < Rack::Request - def params - {:foo => "bar"} - end - end - - specify "should allow subclass request to be instantiated after parent request" do - env = Rack::MockRequest.env_for("/?foo=bar") - - req1 = Rack::Request.new(env) - req1.GET.should.equal "foo" => "bar" - req1.params.should.equal "foo" => "bar" - - req2 = MyRequest.new(env) - req2.GET.should.equal "foo" => "bar" - req2.params.should.equal :foo => "bar" - end - - specify "should allow parent request to be instantiated after subclass request" do - env = Rack::MockRequest.env_for("/?foo=bar") - - req1 = MyRequest.new(env) - req1.GET.should.equal "foo" => "bar" - req1.params.should.equal :foo => "bar" - - req2 = Rack::Request.new(env) - req2.GET.should.equal "foo" => "bar" - req2.params.should.equal "foo" => "bar" - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_response.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_response.rb deleted file mode 100755 index 31c7f3ad520..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_response.rb +++ /dev/null @@ -1,221 +0,0 @@ -require 'test/spec' -require 'set' - -require 'rack/response' - -context "Rack::Response" do - specify "has sensible default values" do - response = Rack::Response.new - status, header, body = response.finish - status.should.equal 200 - header.should.equal "Content-Type" => "text/html" - body.each { |part| - part.should.equal "" - } - - response = Rack::Response.new - status, header, body = *response - status.should.equal 200 - header.should.equal "Content-Type" => "text/html" - body.each { |part| - part.should.equal "" - } - end - - specify "can be written to" do - response = Rack::Response.new - - status, header, body = response.finish do - response.write "foo" - response.write "bar" - response.write "baz" - end - - parts = [] - body.each { |part| parts << part } - - parts.should.equal ["foo", "bar", "baz"] - end - - specify "can set and read headers" do - response = Rack::Response.new - response["Content-Type"].should.equal "text/html" - response["Content-Type"] = "text/plain" - response["Content-Type"].should.equal "text/plain" - end - - specify "can set cookies" do - response = Rack::Response.new - - response.set_cookie "foo", "bar" - response["Set-Cookie"].should.equal "foo=bar" - response.set_cookie "foo2", "bar2" - response["Set-Cookie"].should.equal ["foo=bar", "foo2=bar2"].join("\n") - response.set_cookie "foo3", "bar3" - response["Set-Cookie"].should.equal ["foo=bar", "foo2=bar2", "foo3=bar3"].join("\n") - end - - specify "formats the Cookie expiration date accordingly to RFC 2109" do - response = Rack::Response.new - - response.set_cookie "foo", {:value => "bar", :expires => Time.now+10} - response["Set-Cookie"].should.match( - /expires=..., \d\d-...-\d\d\d\d \d\d:\d\d:\d\d .../) - end - - specify "can set secure cookies" do - response = Rack::Response.new - response.set_cookie "foo", {:value => "bar", :secure => true} - response["Set-Cookie"].should.equal "foo=bar; secure" - end - - specify "can set http only cookies" do - response = Rack::Response.new - response.set_cookie "foo", {:value => "bar", :httponly => true} - response["Set-Cookie"].should.equal "foo=bar; HttpOnly" - end - - specify "can delete cookies" do - response = Rack::Response.new - response.set_cookie "foo", "bar" - response.set_cookie "foo2", "bar2" - response.delete_cookie "foo" - response["Set-Cookie"].should.equal ["foo2=bar2", - "foo=; expires=Thu, 01-Jan-1970 00:00:00 GMT"].join("\n") - end - - specify "can do redirects" do - response = Rack::Response.new - response.redirect "/foo" - status, header, body = response.finish - - status.should.equal 302 - header["Location"].should.equal "/foo" - - response = Rack::Response.new - response.redirect "/foo", 307 - status, header, body = response.finish - - status.should.equal 307 - end - - specify "has a useful constructor" do - r = Rack::Response.new("foo") - status, header, body = r.finish - str = ""; body.each { |part| str << part } - str.should.equal "foo" - - r = Rack::Response.new(["foo", "bar"]) - status, header, body = r.finish - str = ""; body.each { |part| str << part } - str.should.equal "foobar" - - r = Rack::Response.new(["foo", "bar"].to_set) - r.write "foo" - status, header, body = r.finish - str = ""; body.each { |part| str << part } - str.should.equal "foobarfoo" - - r = Rack::Response.new([], 500) - r.status.should.equal 500 - - r = Rack::Response.new([], "200 OK") - r.status.should.equal 200 - end - - specify "has a constructor that can take a block" do - r = Rack::Response.new { |res| - res.status = 404 - res.write "foo" - } - status, header, body = r.finish - str = ""; body.each { |part| str << part } - str.should.equal "foo" - status.should.equal 404 - end - - specify "doesn't return invalid responses" do - r = Rack::Response.new(["foo", "bar"], 204) - status, header, body = r.finish - str = ""; body.each { |part| str << part } - str.should.be.empty - header["Content-Type"].should.equal nil - - lambda { - Rack::Response.new(Object.new) - }.should.raise(TypeError). - message.should =~ /stringable or iterable required/ - end - - specify "knows if it's empty" do - r = Rack::Response.new - r.should.be.empty - r.write "foo" - r.should.not.be.empty - - r = Rack::Response.new - r.should.be.empty - r.finish - r.should.be.empty - - r = Rack::Response.new - r.should.be.empty - r.finish { } - r.should.not.be.empty - end - - specify "should provide access to the HTTP status" do - res = Rack::Response.new - res.status = 200 - res.should.be.successful - res.should.be.ok - - res.status = 404 - res.should.not.be.successful - res.should.be.client_error - res.should.be.not_found - - res.status = 501 - res.should.not.be.successful - res.should.be.server_error - - res.status = 307 - res.should.be.redirect - end - - specify "should provide access to the HTTP headers" do - res = Rack::Response.new - res["Content-Type"] = "text/yaml" - - res.should.include "Content-Type" - res.headers["Content-Type"].should.equal "text/yaml" - res["Content-Type"].should.equal "text/yaml" - res.content_type.should.equal "text/yaml" - res.content_length.should.be.nil - res.location.should.be.nil - end - - specify "does not add or change Content-Length when #finish()ing" do - res = Rack::Response.new - res.status = 200 - res.finish - res.headers["Content-Length"].should.be.nil - - res = Rack::Response.new - res.status = 200 - res.headers["Content-Length"] = "10" - res.finish - res.headers["Content-Length"].should.equal "10" - end - - specify "updates Content-Length when body appended to using #write" do - res = Rack::Response.new - res.status = 200 - res.headers["Content-Length"].should.be.nil - res.write "Hi" - res.headers["Content-Length"].should.equal "2" - res.write " there" - res.headers["Content-Length"].should.equal "8" - end - -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_rewindable_input.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_rewindable_input.rb deleted file mode 100755 index 78bebfc90ae..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_rewindable_input.rb +++ /dev/null @@ -1,118 +0,0 @@ -require 'test/spec' -require 'stringio' -require 'rack/rewindable_input' - -shared_context "a rewindable IO object" do - setup do - @rio = Rack::RewindableInput.new(@io) - end - - teardown do - @rio.close - end - - specify "should be able to handle to read()" do - @rio.read.should.equal "hello world" - end - - specify "should be able to handle to read(nil)" do - @rio.read(nil).should.equal "hello world" - end - - specify "should be able to handle to read(length)" do - @rio.read(1).should.equal "h" - end - - specify "should be able to handle to read(length, buffer)" do - buffer = "" - result = @rio.read(1, buffer) - result.should.equal "h" - result.object_id.should.equal buffer.object_id - end - - specify "should be able to handle to read(nil, buffer)" do - buffer = "" - result = @rio.read(nil, buffer) - result.should.equal "hello world" - result.object_id.should.equal buffer.object_id - end - - specify "should rewind to the beginning when #rewind is called" do - @rio.read(1) - @rio.rewind - @rio.read.should.equal "hello world" - end - - specify "should be able to handle gets" do - @rio.gets.should == "hello world" - end - - specify "should be able to handle each" do - array = [] - @rio.each do |data| - array << data - end - array.should.equal(["hello world"]) - end - - specify "should not buffer into a Tempfile if no data has been read yet" do - @rio.instance_variable_get(:@rewindable_io).should.be.nil - end - - specify "should buffer into a Tempfile when data has been consumed for the first time" do - @rio.read(1) - tempfile = @rio.instance_variable_get(:@rewindable_io) - tempfile.should.not.be.nil - @rio.read(1) - tempfile2 = @rio.instance_variable_get(:@rewindable_io) - tempfile2.should.equal tempfile - end - - specify "should close the underlying tempfile upon calling #close" do - @rio.read(1) - tempfile = @rio.instance_variable_get(:@rewindable_io) - @rio.close - tempfile.should.be.closed - end - - specify "should be possibel to call #close when no data has been buffered yet" do - @rio.close - end - - specify "should be possible to call #close multiple times" do - @rio.close - @rio.close - end -end - -context "Rack::RewindableInput" do - context "given an IO object that is already rewindable" do - setup do - @io = StringIO.new("hello world") - end - - it_should_behave_like "a rewindable IO object" - end - - context "given an IO object that is not rewindable" do - setup do - @io = StringIO.new("hello world") - @io.instance_eval do - undef :rewind - end - end - - it_should_behave_like "a rewindable IO object" - end - - context "given an IO object whose rewind method raises Errno::ESPIPE" do - setup do - @io = StringIO.new("hello world") - def @io.rewind - raise Errno::ESPIPE, "You can't rewind this!" - end - end - - it_should_behave_like "a rewindable IO object" - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_runtime.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_runtime.rb deleted file mode 100755 index 62d8095646d..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_runtime.rb +++ /dev/null @@ -1,35 +0,0 @@ -require 'test/spec' -require 'rack/mock' -require 'rack/runtime' - -context "Rack::Runtime" do - specify "sets X-Runtime is none is set" do - app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, "Hello, World!"] } - response = Rack::Runtime.new(app).call({}) - response[1]['X-Runtime'].should =~ /[\d\.]+/ - end - - specify "does not set the X-Runtime if it is already set" do - app = lambda { |env| [200, {'Content-Type' => 'text/plain', "X-Runtime" => "foobar"}, "Hello, World!"] } - response = Rack::Runtime.new(app).call({}) - response[1]['X-Runtime'].should == "foobar" - end - - specify "should allow a suffix to be set" do - app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, "Hello, World!"] } - response = Rack::Runtime.new(app, "Test").call({}) - response[1]['X-Runtime-Test'].should =~ /[\d\.]+/ - end - - specify "should allow multiple timers to be set" do - app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, "Hello, World!"] } - runtime1 = Rack::Runtime.new(app, "App") - runtime2 = Rack::Runtime.new(runtime1, "All") - response = runtime2.call({}) - - response[1]['X-Runtime-App'].should =~ /[\d\.]+/ - response[1]['X-Runtime-All'].should =~ /[\d\.]+/ - - Float(response[1]['X-Runtime-All']).should > Float(response[1]['X-Runtime-App']) - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_sendfile.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_sendfile.rb deleted file mode 100755 index 8cfe2017b52..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_sendfile.rb +++ /dev/null @@ -1,86 +0,0 @@ -require 'test/spec' -require 'rack/mock' -require 'rack/sendfile' - -context "Rack::File" do - specify "should respond to #to_path" do - Rack::File.new(Dir.pwd).should.respond_to :to_path - end -end - -context "Rack::Sendfile" do - def sendfile_body - res = ['Hello World'] - def res.to_path ; "/tmp/hello.txt" ; end - res - end - - def simple_app(body=sendfile_body) - lambda { |env| [200, {'Content-Type' => 'text/plain'}, body] } - end - - def sendfile_app(body=sendfile_body) - Rack::Sendfile.new(simple_app(body)) - end - - setup do - @request = Rack::MockRequest.new(sendfile_app) - end - - def request(headers={}) - yield @request.get('/', headers) - end - - specify "does nothing when no X-Sendfile-Type header present" do - request do |response| - response.should.be.ok - response.body.should.equal 'Hello World' - response.headers.should.not.include 'X-Sendfile' - end - end - - specify "sets X-Sendfile response header and discards body" do - request 'HTTP_X_SENDFILE_TYPE' => 'X-Sendfile' do |response| - response.should.be.ok - response.body.should.be.empty - response.headers['X-Sendfile'].should.equal '/tmp/hello.txt' - end - end - - specify "sets X-Lighttpd-Send-File response header and discards body" do - request 'HTTP_X_SENDFILE_TYPE' => 'X-Lighttpd-Send-File' do |response| - response.should.be.ok - response.body.should.be.empty - response.headers['X-Lighttpd-Send-File'].should.equal '/tmp/hello.txt' - end - end - - specify "sets X-Accel-Redirect response header and discards body" do - headers = { - 'HTTP_X_SENDFILE_TYPE' => 'X-Accel-Redirect', - 'HTTP_X_ACCEL_MAPPING' => '/tmp/=/foo/bar/' - } - request headers do |response| - response.should.be.ok - response.body.should.be.empty - response.headers['X-Accel-Redirect'].should.equal '/foo/bar/hello.txt' - end - end - - specify 'writes to rack.error when no X-Accel-Mapping is specified' do - request 'HTTP_X_SENDFILE_TYPE' => 'X-Accel-Redirect' do |response| - response.should.be.ok - response.body.should.equal 'Hello World' - response.headers.should.not.include 'X-Accel-Redirect' - response.errors.should.include 'X-Accel-Mapping' - end - end - - specify 'does nothing when body does not respond to #to_path' do - @request = Rack::MockRequest.new(sendfile_app(['Not a file...'])) - request 'HTTP_X_SENDFILE_TYPE' => 'X-Sendfile' do |response| - response.body.should.equal 'Not a file...' - response.headers.should.not.include 'X-Sendfile' - end - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_session_cookie.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_session_cookie.rb deleted file mode 100755 index fba3f83bfa1..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_session_cookie.rb +++ /dev/null @@ -1,73 +0,0 @@ -require 'test/spec' - -require 'rack/session/cookie' -require 'rack/mock' -require 'rack/response' - -context "Rack::Session::Cookie" do - incrementor = lambda { |env| - env["rack.session"]["counter"] ||= 0 - env["rack.session"]["counter"] += 1 - Rack::Response.new(env["rack.session"].inspect).to_a - } - - specify "creates a new cookie" do - res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor)).get("/") - res["Set-Cookie"].should.match("rack.session=") - res.body.should.equal '{"counter"=>1}' - end - - specify "loads from a cookie" do - res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor)).get("/") - cookie = res["Set-Cookie"] - res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor)). - get("/", "HTTP_COOKIE" => cookie) - res.body.should.equal '{"counter"=>2}' - cookie = res["Set-Cookie"] - res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor)). - get("/", "HTTP_COOKIE" => cookie) - res.body.should.equal '{"counter"=>3}' - end - - specify "survives broken cookies" do - res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor)). - get("/", "HTTP_COOKIE" => "rack.session=blarghfasel") - res.body.should.equal '{"counter"=>1}' - end - - bigcookie = lambda { |env| - env["rack.session"]["cookie"] = "big" * 3000 - Rack::Response.new(env["rack.session"].inspect).to_a - } - - specify "barks on too big cookies" do - lambda { - Rack::MockRequest.new(Rack::Session::Cookie.new(bigcookie)). - get("/", :fatal => true) - }.should.raise(Rack::MockRequest::FatalWarning) - end - - specify "loads from a cookie wih integrity hash" do - res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test')).get("/") - cookie = res["Set-Cookie"] - res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test')). - get("/", "HTTP_COOKIE" => cookie) - res.body.should.equal '{"counter"=>2}' - cookie = res["Set-Cookie"] - res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test')). - get("/", "HTTP_COOKIE" => cookie) - res.body.should.equal '{"counter"=>3}' - end - - specify "ignores tampered with session cookies" do - app = Rack::Session::Cookie.new(incrementor, :secret => 'test') - response1 = Rack::MockRequest.new(app).get("/") - _, digest = response1["Set-Cookie"].split("--") - tampered_with_cookie = "hackerman-was-here" + "--" + digest - response2 = Rack::MockRequest.new(app).get("/", "HTTP_COOKIE" => - tampered_with_cookie) - - # The tampered-with cookie is ignored, so we get back an identical Set-Cookie - response2["Set-Cookie"].should.equal(response1["Set-Cookie"]) - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_session_memcache.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_session_memcache.rb deleted file mode 100755 index faac796ebd9..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_session_memcache.rb +++ /dev/null @@ -1,273 +0,0 @@ -require 'test/spec' - -begin - require 'rack/session/memcache' - require 'rack/mock' - require 'rack/response' - require 'thread' - - context "Rack::Session::Memcache" do - session_key = Rack::Session::Memcache::DEFAULT_OPTIONS[:key] - session_match = /#{session_key}=([0-9a-fA-F]+);/ - incrementor = lambda do |env| - env["rack.session"]["counter"] ||= 0 - env["rack.session"]["counter"] += 1 - Rack::Response.new(env["rack.session"].inspect).to_a - end - drop_session = proc do |env| - env['rack.session.options'][:drop] = true - incrementor.call(env) - end - renew_session = proc do |env| - env['rack.session.options'][:renew] = true - incrementor.call(env) - end - defer_session = proc do |env| - env['rack.session.options'][:defer] = true - incrementor.call(env) - end - - specify "faults on no connection" do - if RUBY_VERSION < "1.9" - lambda do - Rack::Session::Memcache.new incrementor, :memcache_server => 'nosuchserver' - end.should.raise - else - lambda do - Rack::Session::Memcache.new incrementor, :memcache_server => 'nosuchserver' - end.should.raise ArgumentError - end - end - - specify "connect to existing server" do - test_pool = MemCache.new incrementor, :namespace => 'test:rack:session' - end - - specify "creates a new cookie" do - pool = Rack::Session::Memcache.new(incrementor) - res = Rack::MockRequest.new(pool).get("/") - res["Set-Cookie"].should.match("#{session_key}=") - res.body.should.equal '{"counter"=>1}' - end - - specify "determines session from a cookie" do - pool = Rack::Session::Memcache.new(incrementor) - req = Rack::MockRequest.new(pool) - res = req.get("/") - cookie = res["Set-Cookie"] - req.get("/", "HTTP_COOKIE" => cookie). - body.should.equal '{"counter"=>2}' - req.get("/", "HTTP_COOKIE" => cookie). - body.should.equal '{"counter"=>3}' - end - - specify "survives nonexistant cookies" do - bad_cookie = "rack.session=blarghfasel" - pool = Rack::Session::Memcache.new(incrementor) - res = Rack::MockRequest.new(pool). - get("/", "HTTP_COOKIE" => bad_cookie) - res.body.should.equal '{"counter"=>1}' - cookie = res["Set-Cookie"][session_match] - cookie.should.not.match(/#{bad_cookie}/) - end - - specify "maintains freshness" do - pool = Rack::Session::Memcache.new(incrementor, :expire_after => 3) - res = Rack::MockRequest.new(pool).get('/') - res.body.should.include '"counter"=>1' - cookie = res["Set-Cookie"] - res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie) - res["Set-Cookie"].should.equal cookie - res.body.should.include '"counter"=>2' - puts 'Sleeping to expire session' if $DEBUG - sleep 4 - res = Rack::MockRequest.new(pool).get('/', "HTTP_COOKIE" => cookie) - res["Set-Cookie"].should.not.equal cookie - res.body.should.include '"counter"=>1' - end - - specify "deletes cookies with :drop option" do - pool = Rack::Session::Memcache.new(incrementor) - req = Rack::MockRequest.new(pool) - drop = Rack::Utils::Context.new(pool, drop_session) - dreq = Rack::MockRequest.new(drop) - - res0 = req.get("/") - session = (cookie = res0["Set-Cookie"])[session_match] - res0.body.should.equal '{"counter"=>1}' - - res1 = req.get("/", "HTTP_COOKIE" => cookie) - res1["Set-Cookie"][session_match].should.equal session - res1.body.should.equal '{"counter"=>2}' - - res2 = dreq.get("/", "HTTP_COOKIE" => cookie) - res2["Set-Cookie"].should.equal nil - res2.body.should.equal '{"counter"=>3}' - - res3 = req.get("/", "HTTP_COOKIE" => cookie) - res3["Set-Cookie"][session_match].should.not.equal session - res3.body.should.equal '{"counter"=>1}' - end - - specify "provides new session id with :renew option" do - pool = Rack::Session::Memcache.new(incrementor) - req = Rack::MockRequest.new(pool) - renew = Rack::Utils::Context.new(pool, renew_session) - rreq = Rack::MockRequest.new(renew) - - res0 = req.get("/") - session = (cookie = res0["Set-Cookie"])[session_match] - res0.body.should.equal '{"counter"=>1}' - - res1 = req.get("/", "HTTP_COOKIE" => cookie) - res1["Set-Cookie"][session_match].should.equal session - res1.body.should.equal '{"counter"=>2}' - - res2 = rreq.get("/", "HTTP_COOKIE" => cookie) - new_cookie = res2["Set-Cookie"] - new_session = new_cookie[session_match] - new_session.should.not.equal session - res2.body.should.equal '{"counter"=>3}' - - res3 = req.get("/", "HTTP_COOKIE" => new_cookie) - res3["Set-Cookie"][session_match].should.equal new_session - res3.body.should.equal '{"counter"=>4}' - end - - specify "omits cookie with :defer option" do - pool = Rack::Session::Memcache.new(incrementor) - req = Rack::MockRequest.new(pool) - defer = Rack::Utils::Context.new(pool, defer_session) - dreq = Rack::MockRequest.new(defer) - - res0 = req.get("/") - session = (cookie = res0["Set-Cookie"])[session_match] - res0.body.should.equal '{"counter"=>1}' - - res1 = req.get("/", "HTTP_COOKIE" => cookie) - res1["Set-Cookie"][session_match].should.equal session - res1.body.should.equal '{"counter"=>2}' - - res2 = dreq.get("/", "HTTP_COOKIE" => cookie) - res2["Set-Cookie"].should.equal nil - res2.body.should.equal '{"counter"=>3}' - - res3 = req.get("/", "HTTP_COOKIE" => cookie) - res3["Set-Cookie"][session_match].should.equal session - res3.body.should.equal '{"counter"=>4}' - end - - specify "deep hashes are correctly updated" do - store = nil - hash_check = proc do |env| - session = env['rack.session'] - unless session.include? 'test' - session.update :a => :b, :c => { :d => :e }, - :f => { :g => { :h => :i} }, 'test' => true - else - session[:f][:g][:h] = :j - end - [200, {}, session.inspect] - end - pool = Rack::Session::Memcache.new(hash_check) - req = Rack::MockRequest.new(pool) - - res0 = req.get("/") - session_id = (cookie = res0["Set-Cookie"])[session_match, 1] - ses0 = pool.pool.get(session_id, true) - - res1 = req.get("/", "HTTP_COOKIE" => cookie) - ses1 = pool.pool.get(session_id, true) - - ses1.should.not.equal ses0 - end - - # anyone know how to do this better? - specify "multithread: should cleanly merge sessions" do - next unless $DEBUG - warn 'Running multithread test for Session::Memcache' - pool = Rack::Session::Memcache.new(incrementor) - req = Rack::MockRequest.new(pool) - - res = req.get('/') - res.body.should.equal '{"counter"=>1}' - cookie = res["Set-Cookie"] - session_id = cookie[session_match, 1] - - delta_incrementor = lambda do |env| - # emulate disconjoinment of threading - env['rack.session'] = env['rack.session'].dup - Thread.stop - env['rack.session'][(Time.now.usec*rand).to_i] = true - incrementor.call(env) - end - tses = Rack::Utils::Context.new pool, delta_incrementor - treq = Rack::MockRequest.new(tses) - tnum = rand(7).to_i+5 - r = Array.new(tnum) do - Thread.new(treq) do |run| - run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true) - end - end.reverse.map{|t| t.run.join.value } - r.each do |request| - request['Set-Cookie'].should.equal cookie - request.body.should.include '"counter"=>2' - end - - session = pool.pool.get(session_id) - session.size.should.be tnum+1 # counter - session['counter'].should.be 2 # meeeh - - tnum = rand(7).to_i+5 - r = Array.new(tnum) do |i| - delta_time = proc do |env| - env['rack.session'][i] = Time.now - Thread.stop - env['rack.session'] = env['rack.session'].dup - env['rack.session'][i] -= Time.now - incrementor.call(env) - end - app = Rack::Utils::Context.new pool, time_delta - req = Rack::MockRequest.new app - Thread.new(req) do |run| - run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true) - end - end.reverse.map{|t| t.run.join.value } - r.each do |request| - request['Set-Cookie'].should.equal cookie - request.body.should.include '"counter"=>3' - end - - session = pool.pool.get(session_id) - session.size.should.be tnum+1 - session['counter'].should.be 3 - - drop_counter = proc do |env| - env['rack.session'].delete 'counter' - env['rack.session']['foo'] = 'bar' - [200, {'Content-Type'=>'text/plain'}, env['rack.session'].inspect] - end - tses = Rack::Utils::Context.new pool, drop_counter - treq = Rack::MockRequest.new(tses) - tnum = rand(7).to_i+5 - r = Array.new(tnum) do - Thread.new(treq) do |run| - run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true) - end - end.reverse.map{|t| t.run.join.value } - r.each do |request| - request['Set-Cookie'].should.equal cookie - request.body.should.include '"foo"=>"bar"' - end - - session = pool.pool.get(session_id) - session.size.should.be r.size+1 - session['counter'].should.be.nil? - session['foo'].should.equal 'bar' - end - end -rescue RuntimeError - $stderr.puts "Skipping Rack::Session::Memcache tests. Start memcached and try again." -rescue LoadError - $stderr.puts "Skipping Rack::Session::Memcache tests (Memcache is required). `gem install memcache-client` and try again." -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_session_pool.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_session_pool.rb deleted file mode 100755 index 6be382ec758..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_session_pool.rb +++ /dev/null @@ -1,172 +0,0 @@ -require 'test/spec' - -require 'rack/session/pool' -require 'rack/mock' -require 'rack/response' -require 'thread' - -context "Rack::Session::Pool" do - session_key = Rack::Session::Pool::DEFAULT_OPTIONS[:key] - session_match = /#{session_key}=[0-9a-fA-F]+;/ - incrementor = lambda do |env| - env["rack.session"]["counter"] ||= 0 - env["rack.session"]["counter"] += 1 - Rack::Response.new(env["rack.session"].inspect).to_a - end - drop_session = proc do |env| - env['rack.session.options'][:drop] = true - incrementor.call(env) - end - renew_session = proc do |env| - env['rack.session.options'][:renew] = true - incrementor.call(env) - end - defer_session = proc do |env| - env['rack.session.options'][:defer] = true - incrementor.call(env) - end - - specify "creates a new cookie" do - pool = Rack::Session::Pool.new(incrementor) - res = Rack::MockRequest.new(pool).get("/") - res["Set-Cookie"].should.match session_match - res.body.should.equal '{"counter"=>1}' - end - - specify "determines session from a cookie" do - pool = Rack::Session::Pool.new(incrementor) - req = Rack::MockRequest.new(pool) - cookie = req.get("/")["Set-Cookie"] - req.get("/", "HTTP_COOKIE" => cookie). - body.should.equal '{"counter"=>2}' - req.get("/", "HTTP_COOKIE" => cookie). - body.should.equal '{"counter"=>3}' - end - - specify "survives nonexistant cookies" do - pool = Rack::Session::Pool.new(incrementor) - res = Rack::MockRequest.new(pool). - get("/", "HTTP_COOKIE" => "#{session_key}=blarghfasel") - res.body.should.equal '{"counter"=>1}' - end - - specify "deletes cookies with :drop option" do - pool = Rack::Session::Pool.new(incrementor) - req = Rack::MockRequest.new(pool) - drop = Rack::Utils::Context.new(pool, drop_session) - dreq = Rack::MockRequest.new(drop) - - res0 = req.get("/") - session = (cookie = res0["Set-Cookie"])[session_match] - res0.body.should.equal '{"counter"=>1}' - pool.pool.size.should.be 1 - - res1 = req.get("/", "HTTP_COOKIE" => cookie) - res1["Set-Cookie"][session_match].should.equal session - res1.body.should.equal '{"counter"=>2}' - pool.pool.size.should.be 1 - - res2 = dreq.get("/", "HTTP_COOKIE" => cookie) - res2["Set-Cookie"].should.equal nil - res2.body.should.equal '{"counter"=>3}' - pool.pool.size.should.be 0 - - res3 = req.get("/", "HTTP_COOKIE" => cookie) - res3["Set-Cookie"][session_match].should.not.equal session - res3.body.should.equal '{"counter"=>1}' - pool.pool.size.should.be 1 - end - - specify "provides new session id with :renew option" do - pool = Rack::Session::Pool.new(incrementor) - req = Rack::MockRequest.new(pool) - renew = Rack::Utils::Context.new(pool, renew_session) - rreq = Rack::MockRequest.new(renew) - - res0 = req.get("/") - session = (cookie = res0["Set-Cookie"])[session_match] - res0.body.should.equal '{"counter"=>1}' - pool.pool.size.should.be 1 - - res1 = req.get("/", "HTTP_COOKIE" => cookie) - res1["Set-Cookie"][session_match].should.equal session - res1.body.should.equal '{"counter"=>2}' - pool.pool.size.should.be 1 - - res2 = rreq.get("/", "HTTP_COOKIE" => cookie) - new_cookie = res2["Set-Cookie"] - new_session = new_cookie[session_match] - new_session.should.not.equal session - res2.body.should.equal '{"counter"=>3}' - pool.pool.size.should.be 1 - - res3 = req.get("/", "HTTP_COOKIE" => new_cookie) - res3["Set-Cookie"][session_match].should.equal new_session - res3.body.should.equal '{"counter"=>4}' - pool.pool.size.should.be 1 - end - - specify "omits cookie with :defer option" do - pool = Rack::Session::Pool.new(incrementor) - req = Rack::MockRequest.new(pool) - defer = Rack::Utils::Context.new(pool, defer_session) - dreq = Rack::MockRequest.new(defer) - - res0 = req.get("/") - session = (cookie = res0["Set-Cookie"])[session_match] - res0.body.should.equal '{"counter"=>1}' - pool.pool.size.should.be 1 - - res1 = req.get("/", "HTTP_COOKIE" => cookie) - res1["Set-Cookie"][session_match].should.equal session - res1.body.should.equal '{"counter"=>2}' - pool.pool.size.should.be 1 - - res2 = dreq.get("/", "HTTP_COOKIE" => cookie) - res2["Set-Cookie"].should.equal nil - res2.body.should.equal '{"counter"=>3}' - pool.pool.size.should.be 1 - - res3 = req.get("/", "HTTP_COOKIE" => cookie) - res3["Set-Cookie"][session_match].should.equal session - res3.body.should.equal '{"counter"=>4}' - pool.pool.size.should.be 1 - end - - # anyone know how to do this better? - specify "multithread: should merge sessions" do - next unless $DEBUG - warn 'Running multithread tests for Session::Pool' - pool = Rack::Session::Pool.new(incrementor) - req = Rack::MockRequest.new(pool) - - res = req.get('/') - res.body.should.equal '{"counter"=>1}' - cookie = res["Set-Cookie"] - sess_id = cookie[/#{pool.key}=([^,;]+)/,1] - - delta_incrementor = lambda do |env| - # emulate disconjoinment of threading - env['rack.session'] = env['rack.session'].dup - Thread.stop - env['rack.session'][(Time.now.usec*rand).to_i] = true - incrementor.call(env) - end - tses = Rack::Utils::Context.new pool, delta_incrementor - treq = Rack::MockRequest.new(tses) - tnum = rand(7).to_i+5 - r = Array.new(tnum) do - Thread.new(treq) do |run| - run.get('/', "HTTP_COOKIE" => cookie, 'rack.multithread' => true) - end - end.reverse.map{|t| t.run.join.value } - r.each do |res| - res['Set-Cookie'].should.equal cookie - res.body.should.include '"counter"=>2' - end - - session = pool.pool[sess_id] - session.size.should.be tnum+1 # counter - session['counter'].should.be 2 # meeeh - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_showexceptions.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_showexceptions.rb deleted file mode 100755 index bdbc1201341..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_showexceptions.rb +++ /dev/null @@ -1,21 +0,0 @@ -require 'test/spec' - -require 'rack/showexceptions' -require 'rack/mock' - -context "Rack::ShowExceptions" do - specify "catches exceptions" do - res = nil - req = Rack::MockRequest.new(Rack::ShowExceptions.new(lambda { |env| - raise RuntimeError - })) - lambda { - res = req.get("/") - }.should.not.raise - res.should.be.a.server_error - res.status.should.equal 500 - - res.should =~ /RuntimeError/ - res.should =~ /ShowExceptions/ - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_showstatus.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_showstatus.rb deleted file mode 100755 index 7870013412f..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_showstatus.rb +++ /dev/null @@ -1,72 +0,0 @@ -require 'test/spec' - -require 'rack/showstatus' -require 'rack/mock' - -context "Rack::ShowStatus" do - specify "should provide a default status message" do - req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env| - [404, {"Content-Type" => "text/plain", "Content-Length" => "0"}, []] - })) - - res = req.get("/", :lint => true) - res.should.be.not_found - res.should.be.not.empty - - res["Content-Type"].should.equal("text/html") - res.should =~ /404/ - res.should =~ /Not Found/ - end - - specify "should let the app provide additional information" do - req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env| - env["rack.showstatus.detail"] = "gone too meta." - [404, {"Content-Type" => "text/plain", "Content-Length" => "0"}, []] - })) - - res = req.get("/", :lint => true) - res.should.be.not_found - res.should.be.not.empty - - res["Content-Type"].should.equal("text/html") - res.should =~ /404/ - res.should =~ /Not Found/ - res.should =~ /too meta/ - end - - specify "should not replace existing messages" do - req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env| - [404, {"Content-Type" => "text/plain", "Content-Length" => "4"}, ["foo!"]] - })) - res = req.get("/", :lint => true) - res.should.be.not_found - - res.body.should == "foo!" - end - - specify "should pass on original headers" do - headers = {"WWW-Authenticate" => "Basic blah"} - - req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env| [401, headers, []] })) - res = req.get("/", :lint => true) - - res["WWW-Authenticate"].should.equal("Basic blah") - end - - specify "should replace existing messages if there is detail" do - req = Rack::MockRequest.new(Rack::ShowStatus.new(lambda { |env| - env["rack.showstatus.detail"] = "gone too meta." - [404, {"Content-Type" => "text/plain", "Content-Length" => "4"}, ["foo!"]] - })) - - res = req.get("/", :lint => true) - res.should.be.not_found - res.should.be.not.empty - - res["Content-Type"].should.equal("text/html") - res["Content-Length"].should.not.equal("4") - res.should =~ /404/ - res.should =~ /too meta/ - res.body.should.not =~ /foo/ - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_static.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_static.rb deleted file mode 100755 index 19d2ecb7eaf..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_static.rb +++ /dev/null @@ -1,37 +0,0 @@ -require 'test/spec' - -require 'rack/static' -require 'rack/mock' - -class DummyApp - def call(env) - [200, {}, ["Hello World"]] - end -end - -context "Rack::Static" do - root = File.expand_path(File.dirname(__FILE__)) - OPTIONS = {:urls => ["/cgi"], :root => root} - - setup do - @request = Rack::MockRequest.new(Rack::Static.new(DummyApp.new, OPTIONS)) - end - - specify "serves files" do - res = @request.get("/cgi/test") - res.should.be.ok - res.body.should =~ /ruby/ - end - - specify "404s if url root is known but it can't find the file" do - res = @request.get("/cgi/foo") - res.should.be.not_found - end - - specify "calls down the chain if url root is not known" do - res = @request.get("/something/else") - res.should.be.ok - res.body.should == "Hello World" - end - -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_thin.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_thin.rb deleted file mode 100755 index 324f64986fa..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_thin.rb +++ /dev/null @@ -1,91 +0,0 @@ -require 'test/spec' - -begin -require 'rack/handler/thin' -require 'testrequest' -require 'timeout' - -context "Rack::Handler::Thin" do - include TestRequest::Helpers - - setup do - @app = Rack::Lint.new(TestRequest.new) - @server = nil - Thin::Logging.silent = true - @thread = Thread.new do - Rack::Handler::Thin.run(@app, :Host => @host='0.0.0.0', :Port => @port=9204) do |server| - @server = server - end - end - Thread.pass until @server && @server.running? - end - - specify "should respond" do - lambda { - GET("/") - }.should.not.raise - end - - specify "should be a Thin" do - GET("/") - status.should.be 200 - response["SERVER_SOFTWARE"].should =~ /thin/ - response["HTTP_VERSION"].should.equal "HTTP/1.1" - response["SERVER_PROTOCOL"].should.equal "HTTP/1.1" - response["SERVER_PORT"].should.equal "9204" - response["SERVER_NAME"].should.equal "0.0.0.0" - end - - specify "should have rack headers" do - GET("/") - response["rack.version"].should.equal [0,3] - response["rack.multithread"].should.be false - response["rack.multiprocess"].should.be false - response["rack.run_once"].should.be false - end - - specify "should have CGI headers on GET" do - GET("/") - response["REQUEST_METHOD"].should.equal "GET" - response["REQUEST_PATH"].should.equal "/" - response["PATH_INFO"].should.be.equal "/" - response["QUERY_STRING"].should.equal "" - response["test.postdata"].should.equal "" - - GET("/test/foo?quux=1") - response["REQUEST_METHOD"].should.equal "GET" - response["REQUEST_PATH"].should.equal "/test/foo" - response["PATH_INFO"].should.equal "/test/foo" - response["QUERY_STRING"].should.equal "quux=1" - end - - specify "should have CGI headers on POST" do - POST("/", {"rack-form-data" => "23"}, {'X-test-header' => '42'}) - status.should.equal 200 - response["REQUEST_METHOD"].should.equal "POST" - response["REQUEST_PATH"].should.equal "/" - response["QUERY_STRING"].should.equal "" - response["HTTP_X_TEST_HEADER"].should.equal "42" - response["test.postdata"].should.equal "rack-form-data=23" - end - - specify "should support HTTP auth" do - GET("/test", {:user => "ruth", :passwd => "secret"}) - response["HTTP_AUTHORIZATION"].should.equal "Basic cnV0aDpzZWNyZXQ=" - end - - specify "should set status" do - GET("/test?secret") - status.should.equal 403 - response["rack.url_scheme"].should.equal "http" - end - - teardown do - @server.stop! - @thread.kill - end -end - -rescue LoadError - $stderr.puts "Skipping Rack::Handler::Thin tests (Thin is required). `gem install thin` and try again." -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_urlmap.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_urlmap.rb deleted file mode 100755 index 3d8fe60538f..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_urlmap.rb +++ /dev/null @@ -1,215 +0,0 @@ -require 'test/spec' - -require 'rack/urlmap' -require 'rack/mock' - -context "Rack::URLMap" do - specify "dispatches paths correctly" do - app = lambda { |env| - [200, { - 'X-ScriptName' => env['SCRIPT_NAME'], - 'X-PathInfo' => env['PATH_INFO'], - 'Content-Type' => 'text/plain' - }, [""]] - } - map = Rack::URLMap.new({ - 'http://foo.org/bar' => app, - '/foo' => app, - '/foo/bar' => app - }) - - res = Rack::MockRequest.new(map).get("/") - res.should.be.not_found - - res = Rack::MockRequest.new(map).get("/qux") - res.should.be.not_found - - res = Rack::MockRequest.new(map).get("/foo") - res.should.be.ok - res["X-ScriptName"].should.equal "/foo" - res["X-PathInfo"].should.equal "" - - res = Rack::MockRequest.new(map).get("/foo/") - res.should.be.ok - res["X-ScriptName"].should.equal "/foo" - res["X-PathInfo"].should.equal "/" - - res = Rack::MockRequest.new(map).get("/foo/bar") - res.should.be.ok - res["X-ScriptName"].should.equal "/foo/bar" - res["X-PathInfo"].should.equal "" - - res = Rack::MockRequest.new(map).get("/foo/bar/") - res.should.be.ok - res["X-ScriptName"].should.equal "/foo/bar" - res["X-PathInfo"].should.equal "/" - - res = Rack::MockRequest.new(map).get("/foo///bar//quux") - res.status.should.equal 200 - res.should.be.ok - res["X-ScriptName"].should.equal "/foo/bar" - res["X-PathInfo"].should.equal "//quux" - - res = Rack::MockRequest.new(map).get("/foo/quux", "SCRIPT_NAME" => "/bleh") - res.should.be.ok - res["X-ScriptName"].should.equal "/bleh/foo" - res["X-PathInfo"].should.equal "/quux" - - res = Rack::MockRequest.new(map).get("/bar", 'HTTP_HOST' => 'foo.org') - res.should.be.ok - res["X-ScriptName"].should.equal "/bar" - res["X-PathInfo"].should.be.empty - - res = Rack::MockRequest.new(map).get("/bar/", 'HTTP_HOST' => 'foo.org') - res.should.be.ok - res["X-ScriptName"].should.equal "/bar" - res["X-PathInfo"].should.equal '/' - end - - - specify "dispatches hosts correctly" do - map = Rack::URLMap.new("http://foo.org/" => lambda { |env| - [200, - { "Content-Type" => "text/plain", - "X-Position" => "foo.org", - "X-Host" => env["HTTP_HOST"] || env["SERVER_NAME"], - }, [""]]}, - "http://subdomain.foo.org/" => lambda { |env| - [200, - { "Content-Type" => "text/plain", - "X-Position" => "subdomain.foo.org", - "X-Host" => env["HTTP_HOST"] || env["SERVER_NAME"], - }, [""]]}, - "http://bar.org/" => lambda { |env| - [200, - { "Content-Type" => "text/plain", - "X-Position" => "bar.org", - "X-Host" => env["HTTP_HOST"] || env["SERVER_NAME"], - }, [""]]}, - "/" => lambda { |env| - [200, - { "Content-Type" => "text/plain", - "X-Position" => "default.org", - "X-Host" => env["HTTP_HOST"] || env["SERVER_NAME"], - }, [""]]} - ) - - res = Rack::MockRequest.new(map).get("/") - res.should.be.ok - res["X-Position"].should.equal "default.org" - - res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "bar.org") - res.should.be.ok - res["X-Position"].should.equal "bar.org" - - res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "foo.org") - res.should.be.ok - res["X-Position"].should.equal "foo.org" - - res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "subdomain.foo.org", "SERVER_NAME" => "foo.org") - res.should.be.ok - res["X-Position"].should.equal "subdomain.foo.org" - - res = Rack::MockRequest.new(map).get("http://foo.org/") - res.should.be.ok - res["X-Position"].should.equal "default.org" - - res = Rack::MockRequest.new(map).get("/", "HTTP_HOST" => "example.org") - res.should.be.ok - res["X-Position"].should.equal "default.org" - - res = Rack::MockRequest.new(map).get("/", - "HTTP_HOST" => "example.org:9292", - "SERVER_PORT" => "9292") - res.should.be.ok - res["X-Position"].should.equal "default.org" - end - - specify "should be nestable" do - map = Rack::URLMap.new("/foo" => - Rack::URLMap.new("/bar" => - Rack::URLMap.new("/quux" => lambda { |env| - [200, - { "Content-Type" => "text/plain", - "X-Position" => "/foo/bar/quux", - "X-PathInfo" => env["PATH_INFO"], - "X-ScriptName" => env["SCRIPT_NAME"], - }, [""]]} - ))) - - res = Rack::MockRequest.new(map).get("/foo/bar") - res.should.be.not_found - - res = Rack::MockRequest.new(map).get("/foo/bar/quux") - res.should.be.ok - res["X-Position"].should.equal "/foo/bar/quux" - res["X-PathInfo"].should.equal "" - res["X-ScriptName"].should.equal "/foo/bar/quux" - end - - specify "should route root apps correctly" do - map = Rack::URLMap.new("/" => lambda { |env| - [200, - { "Content-Type" => "text/plain", - "X-Position" => "root", - "X-PathInfo" => env["PATH_INFO"], - "X-ScriptName" => env["SCRIPT_NAME"] - }, [""]]}, - "/foo" => lambda { |env| - [200, - { "Content-Type" => "text/plain", - "X-Position" => "foo", - "X-PathInfo" => env["PATH_INFO"], - "X-ScriptName" => env["SCRIPT_NAME"] - }, [""]]} - ) - - res = Rack::MockRequest.new(map).get("/foo/bar") - res.should.be.ok - res["X-Position"].should.equal "foo" - res["X-PathInfo"].should.equal "/bar" - res["X-ScriptName"].should.equal "/foo" - - res = Rack::MockRequest.new(map).get("/foo") - res.should.be.ok - res["X-Position"].should.equal "foo" - res["X-PathInfo"].should.equal "" - res["X-ScriptName"].should.equal "/foo" - - res = Rack::MockRequest.new(map).get("/bar") - res.should.be.ok - res["X-Position"].should.equal "root" - res["X-PathInfo"].should.equal "/bar" - res["X-ScriptName"].should.equal "" - - res = Rack::MockRequest.new(map).get("") - res.should.be.ok - res["X-Position"].should.equal "root" - res["X-PathInfo"].should.equal "/" - res["X-ScriptName"].should.equal "" - end - - specify "should not squeeze slashes" do - map = Rack::URLMap.new("/" => lambda { |env| - [200, - { "Content-Type" => "text/plain", - "X-Position" => "root", - "X-PathInfo" => env["PATH_INFO"], - "X-ScriptName" => env["SCRIPT_NAME"] - }, [""]]}, - "/foo" => lambda { |env| - [200, - { "Content-Type" => "text/plain", - "X-Position" => "foo", - "X-PathInfo" => env["PATH_INFO"], - "X-ScriptName" => env["SCRIPT_NAME"] - }, [""]]} - ) - - res = Rack::MockRequest.new(map).get("/http://example.org/bar") - res.should.be.ok - res["X-Position"].should.equal "root" - res["X-PathInfo"].should.equal "/http://example.org/bar" - res["X-ScriptName"].should.equal "" - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_utils.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_utils.rb deleted file mode 100755 index 227f878546b..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_utils.rb +++ /dev/null @@ -1,552 +0,0 @@ -require 'test/spec' - -require 'rack/utils' -require 'rack/lint' -require 'rack/mock' - -context "Rack::Utils" do - specify "should escape correctly" do - Rack::Utils.escape("fo<o>bar").should.equal "fo%3Co%3Ebar" - Rack::Utils.escape("a space").should.equal "a+space" - Rack::Utils.escape("q1!2\"'w$5&7/z8)?\\"). - should.equal "q1%212%22%27w%245%267%2Fz8%29%3F%5C" - end - - specify "should escape correctly for multibyte characters" do - matz_name = "\xE3\x81\xBE\xE3\x81\xA4\xE3\x82\x82\xE3\x81\xA8".unpack("a*")[0] # Matsumoto - matz_name.force_encoding("UTF-8") if matz_name.respond_to? :force_encoding - Rack::Utils.escape(matz_name).should.equal '%E3%81%BE%E3%81%A4%E3%82%82%E3%81%A8' - matz_name_sep = "\xE3\x81\xBE\xE3\x81\xA4 \xE3\x82\x82\xE3\x81\xA8".unpack("a*")[0] # Matsu moto - matz_name_sep.force_encoding("UTF-8") if matz_name_sep.respond_to? :force_encoding - Rack::Utils.escape(matz_name_sep).should.equal '%E3%81%BE%E3%81%A4+%E3%82%82%E3%81%A8' - end - - specify "should unescape correctly" do - Rack::Utils.unescape("fo%3Co%3Ebar").should.equal "fo<o>bar" - Rack::Utils.unescape("a+space").should.equal "a space" - Rack::Utils.unescape("a%20space").should.equal "a space" - Rack::Utils.unescape("q1%212%22%27w%245%267%2Fz8%29%3F%5C"). - should.equal "q1!2\"'w$5&7/z8)?\\" - end - - specify "should parse query strings correctly" do - Rack::Utils.parse_query("foo=bar"). - should.equal "foo" => "bar" - Rack::Utils.parse_query("foo=\"bar\""). - should.equal "foo" => "\"bar\"" - Rack::Utils.parse_query("foo=bar&foo=quux"). - should.equal "foo" => ["bar", "quux"] - Rack::Utils.parse_query("foo=1&bar=2"). - should.equal "foo" => "1", "bar" => "2" - Rack::Utils.parse_query("my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F"). - should.equal "my weird field" => "q1!2\"'w$5&7/z8)?" - Rack::Utils.parse_query("foo%3Dbaz=bar").should.equal "foo=baz" => "bar" - end - - specify "should parse nested query strings correctly" do - Rack::Utils.parse_nested_query("foo"). - should.equal "foo" => nil - Rack::Utils.parse_nested_query("foo="). - should.equal "foo" => "" - Rack::Utils.parse_nested_query("foo=bar"). - should.equal "foo" => "bar" - Rack::Utils.parse_nested_query("foo=\"bar\""). - should.equal "foo" => "\"bar\"" - - Rack::Utils.parse_nested_query("foo=bar&foo=quux"). - should.equal "foo" => "quux" - Rack::Utils.parse_nested_query("foo&foo="). - should.equal "foo" => "" - Rack::Utils.parse_nested_query("foo=1&bar=2"). - should.equal "foo" => "1", "bar" => "2" - Rack::Utils.parse_nested_query("&foo=1&&bar=2"). - should.equal "foo" => "1", "bar" => "2" - Rack::Utils.parse_nested_query("foo&bar="). - should.equal "foo" => nil, "bar" => "" - Rack::Utils.parse_nested_query("foo=bar&baz="). - should.equal "foo" => "bar", "baz" => "" - Rack::Utils.parse_nested_query("my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F"). - should.equal "my weird field" => "q1!2\"'w$5&7/z8)?" - - Rack::Utils.parse_nested_query("foo[]"). - should.equal "foo" => [nil] - Rack::Utils.parse_nested_query("foo[]="). - should.equal "foo" => [""] - Rack::Utils.parse_nested_query("foo[]=bar"). - should.equal "foo" => ["bar"] - - Rack::Utils.parse_nested_query("foo[]=1&foo[]=2"). - should.equal "foo" => ["1", "2"] - Rack::Utils.parse_nested_query("foo=bar&baz[]=1&baz[]=2&baz[]=3"). - should.equal "foo" => "bar", "baz" => ["1", "2", "3"] - Rack::Utils.parse_nested_query("foo[]=bar&baz[]=1&baz[]=2&baz[]=3"). - should.equal "foo" => ["bar"], "baz" => ["1", "2", "3"] - - Rack::Utils.parse_nested_query("x[y][z]=1"). - should.equal "x" => {"y" => {"z" => "1"}} - Rack::Utils.parse_nested_query("x[y][z][]=1"). - should.equal "x" => {"y" => {"z" => ["1"]}} - Rack::Utils.parse_nested_query("x[y][z]=1&x[y][z]=2"). - should.equal "x" => {"y" => {"z" => "2"}} - Rack::Utils.parse_nested_query("x[y][z][]=1&x[y][z][]=2"). - should.equal "x" => {"y" => {"z" => ["1", "2"]}} - - Rack::Utils.parse_nested_query("x[y][][z]=1"). - should.equal "x" => {"y" => [{"z" => "1"}]} - Rack::Utils.parse_nested_query("x[y][][z][]=1"). - should.equal "x" => {"y" => [{"z" => ["1"]}]} - Rack::Utils.parse_nested_query("x[y][][z]=1&x[y][][w]=2"). - should.equal "x" => {"y" => [{"z" => "1", "w" => "2"}]} - - Rack::Utils.parse_nested_query("x[y][][v][w]=1"). - should.equal "x" => {"y" => [{"v" => {"w" => "1"}}]} - Rack::Utils.parse_nested_query("x[y][][z]=1&x[y][][v][w]=2"). - should.equal "x" => {"y" => [{"z" => "1", "v" => {"w" => "2"}}]} - - Rack::Utils.parse_nested_query("x[y][][z]=1&x[y][][z]=2"). - should.equal "x" => {"y" => [{"z" => "1"}, {"z" => "2"}]} - Rack::Utils.parse_nested_query("x[y][][z]=1&x[y][][w]=a&x[y][][z]=2&x[y][][w]=3"). - should.equal "x" => {"y" => [{"z" => "1", "w" => "a"}, {"z" => "2", "w" => "3"}]} - - lambda { Rack::Utils.parse_nested_query("x[y]=1&x[y]z=2") }. - should.raise(TypeError). - message.should.equal "expected Hash (got String) for param `y'" - - lambda { Rack::Utils.parse_nested_query("x[y]=1&x[]=1") }. - should.raise(TypeError). - message.should.equal "expected Array (got Hash) for param `x'" - - lambda { Rack::Utils.parse_nested_query("x[y]=1&x[y][][w]=2") }. - should.raise(TypeError). - message.should.equal "expected Array (got String) for param `y'" - end - - specify "should build query strings correctly" do - Rack::Utils.build_query("foo" => "bar").should.equal "foo=bar" - Rack::Utils.build_query("foo" => ["bar", "quux"]). - should.equal "foo=bar&foo=quux" - Rack::Utils.build_query("foo" => "1", "bar" => "2"). - should.equal "foo=1&bar=2" - Rack::Utils.build_query("my weird field" => "q1!2\"'w$5&7/z8)?"). - should.equal "my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F" - end - - specify "should build nested query strings correctly" do - Rack::Utils.build_nested_query("foo" => nil).should.equal "foo" - Rack::Utils.build_nested_query("foo" => "").should.equal "foo=" - Rack::Utils.build_nested_query("foo" => "bar").should.equal "foo=bar" - - Rack::Utils.build_nested_query("foo" => "1", "bar" => "2"). - should.equal "foo=1&bar=2" - Rack::Utils.build_nested_query("my weird field" => "q1!2\"'w$5&7/z8)?"). - should.equal "my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F" - - Rack::Utils.build_nested_query("foo" => [nil]). - should.equal "foo[]" - Rack::Utils.build_nested_query("foo" => [""]). - should.equal "foo[]=" - Rack::Utils.build_nested_query("foo" => ["bar"]). - should.equal "foo[]=bar" - - # The ordering of the output query string is unpredictable with 1.8's - # unordered hash. Test that build_nested_query performs the inverse - # function of parse_nested_query. - [{"foo" => nil, "bar" => ""}, - {"foo" => "bar", "baz" => ""}, - {"foo" => ["1", "2"]}, - {"foo" => "bar", "baz" => ["1", "2", "3"]}, - {"foo" => ["bar"], "baz" => ["1", "2", "3"]}, - {"foo" => ["1", "2"]}, - {"foo" => "bar", "baz" => ["1", "2", "3"]}, - {"x" => {"y" => {"z" => "1"}}}, - {"x" => {"y" => {"z" => ["1"]}}}, - {"x" => {"y" => {"z" => ["1", "2"]}}}, - {"x" => {"y" => [{"z" => "1"}]}}, - {"x" => {"y" => [{"z" => ["1"]}]}}, - {"x" => {"y" => [{"z" => "1", "w" => "2"}]}}, - {"x" => {"y" => [{"v" => {"w" => "1"}}]}}, - {"x" => {"y" => [{"z" => "1", "v" => {"w" => "2"}}]}}, - {"x" => {"y" => [{"z" => "1"}, {"z" => "2"}]}}, - {"x" => {"y" => [{"z" => "1", "w" => "a"}, {"z" => "2", "w" => "3"}]}} - ].each { |params| - qs = Rack::Utils.build_nested_query(params) - Rack::Utils.parse_nested_query(qs).should.equal params - } - - lambda { Rack::Utils.build_nested_query("foo=bar") }. - should.raise(ArgumentError). - message.should.equal "value must be a Hash" - end - - specify "should figure out which encodings are acceptable" do - helper = lambda do |a, b| - request = Rack::Request.new(Rack::MockRequest.env_for("", "HTTP_ACCEPT_ENCODING" => a)) - Rack::Utils.select_best_encoding(a, b) - end - - helper.call(%w(), [["x", 1]]).should.equal(nil) - helper.call(%w(identity), [["identity", 0.0]]).should.equal(nil) - helper.call(%w(identity), [["*", 0.0]]).should.equal(nil) - - helper.call(%w(identity), [["compress", 1.0], ["gzip", 1.0]]).should.equal("identity") - - helper.call(%w(compress gzip identity), [["compress", 1.0], ["gzip", 1.0]]).should.equal("compress") - helper.call(%w(compress gzip identity), [["compress", 0.5], ["gzip", 1.0]]).should.equal("gzip") - - helper.call(%w(foo bar identity), []).should.equal("identity") - helper.call(%w(foo bar identity), [["*", 1.0]]).should.equal("foo") - helper.call(%w(foo bar identity), [["*", 1.0], ["foo", 0.9]]).should.equal("bar") - - helper.call(%w(foo bar identity), [["foo", 0], ["bar", 0]]).should.equal("identity") - helper.call(%w(foo bar baz identity), [["*", 0], ["identity", 0.1]]).should.equal("identity") - end - - specify "should return the bytesize of String" do - Rack::Utils.bytesize("FOO\xE2\x82\xAC").should.equal 6 - end - - specify "should return status code for integer" do - Rack::Utils.status_code(200).should.equal 200 - end - - specify "should return status code for string" do - Rack::Utils.status_code("200").should.equal 200 - end - - specify "should return status code for symbol" do - Rack::Utils.status_code(:ok).should.equal 200 - end -end - -context "Rack::Utils::HeaderHash" do - specify "should retain header case" do - h = Rack::Utils::HeaderHash.new("Content-MD5" => "d5ff4e2a0 ...") - h['ETag'] = 'Boo!' - h.to_hash.should.equal "Content-MD5" => "d5ff4e2a0 ...", "ETag" => 'Boo!' - end - - specify "should check existence of keys case insensitively" do - h = Rack::Utils::HeaderHash.new("Content-MD5" => "d5ff4e2a0 ...") - h.should.include 'content-md5' - h.should.not.include 'ETag' - end - - specify "should merge case-insensitively" do - h = Rack::Utils::HeaderHash.new("ETag" => 'HELLO', "content-length" => '123') - merged = h.merge("Etag" => 'WORLD', 'Content-Length' => '321', "Foo" => 'BAR') - merged.should.equal "Etag"=>'WORLD', "Content-Length"=>'321', "Foo"=>'BAR' - end - - specify "should overwrite case insensitively and assume the new key's case" do - h = Rack::Utils::HeaderHash.new("Foo-Bar" => "baz") - h["foo-bar"] = "bizzle" - h["FOO-BAR"].should.equal "bizzle" - h.length.should.equal 1 - h.to_hash.should.equal "foo-bar" => "bizzle" - end - - specify "should be converted to real Hash" do - h = Rack::Utils::HeaderHash.new("foo" => "bar") - h.to_hash.should.be.instance_of Hash - end - - specify "should convert Array values to Strings when converting to Hash" do - h = Rack::Utils::HeaderHash.new("foo" => ["bar", "baz"]) - h.to_hash.should.equal({ "foo" => "bar\nbaz" }) - end - - specify "should replace hashes correctly" do - h = Rack::Utils::HeaderHash.new("Foo-Bar" => "baz") - j = {"foo" => "bar"} - h.replace(j) - h["foo"].should.equal "bar" - end - - specify "should be able to delete the given key case-sensitively" do - h = Rack::Utils::HeaderHash.new("foo" => "bar") - h.delete("foo") - h["foo"].should.be.nil - h["FOO"].should.be.nil - end - - specify "should be able to delete the given key case-insensitively" do - h = Rack::Utils::HeaderHash.new("foo" => "bar") - h.delete("FOO") - h["foo"].should.be.nil - h["FOO"].should.be.nil - end - - specify "should return the deleted value when #delete is called on an existing key" do - h = Rack::Utils::HeaderHash.new("foo" => "bar") - h.delete("Foo").should.equal("bar") - end - - specify "should return nil when #delete is called on a non-existant key" do - h = Rack::Utils::HeaderHash.new("foo" => "bar") - h.delete("Hello").should.be.nil - end - - specify "should avoid unnecessary object creation if possible" do - a = Rack::Utils::HeaderHash.new("foo" => "bar") - b = Rack::Utils::HeaderHash.new(a) - b.object_id.should.equal(a.object_id) - b.should.equal(a) - end - - specify "should convert Array values to Strings when responding to #each" do - h = Rack::Utils::HeaderHash.new("foo" => ["bar", "baz"]) - h.each do |k,v| - k.should.equal("foo") - v.should.equal("bar\nbaz") - end - end - -end - -context "Rack::Utils::Context" do - class ContextTest - attr_reader :app - def initialize app; @app=app; end - def call env; context env; end - def context env, app=@app; app.call(env); end - end - test_target1 = proc{|e| e.to_s+' world' } - test_target2 = proc{|e| e.to_i+2 } - test_target3 = proc{|e| nil } - test_target4 = proc{|e| [200,{'Content-Type'=>'text/plain', 'Content-Length'=>'0'},['']] } - test_app = ContextTest.new test_target4 - - specify "should set context correctly" do - test_app.app.should.equal test_target4 - c1 = Rack::Utils::Context.new(test_app, test_target1) - c1.for.should.equal test_app - c1.app.should.equal test_target1 - c2 = Rack::Utils::Context.new(test_app, test_target2) - c2.for.should.equal test_app - c2.app.should.equal test_target2 - end - - specify "should alter app on recontexting" do - c1 = Rack::Utils::Context.new(test_app, test_target1) - c2 = c1.recontext(test_target2) - c2.for.should.equal test_app - c2.app.should.equal test_target2 - c3 = c2.recontext(test_target3) - c3.for.should.equal test_app - c3.app.should.equal test_target3 - end - - specify "should run different apps" do - c1 = Rack::Utils::Context.new test_app, test_target1 - c2 = c1.recontext test_target2 - c3 = c2.recontext test_target3 - c4 = c3.recontext test_target4 - a4 = Rack::Lint.new c4 - a5 = Rack::Lint.new test_app - r1 = c1.call('hello') - r1.should.equal 'hello world' - r2 = c2.call(2) - r2.should.equal 4 - r3 = c3.call(:misc_symbol) - r3.should.be.nil - r4 = Rack::MockRequest.new(a4).get('/') - r4.status.should.be 200 - r5 = Rack::MockRequest.new(a5).get('/') - r5.status.should.be 200 - r4.body.should.equal r5.body - end -end - -context "Rack::Utils::Multipart" do - specify "should return nil if content type is not multipart" do - env = Rack::MockRequest.env_for("/", - "CONTENT_TYPE" => 'application/x-www-form-urlencoded') - Rack::Utils::Multipart.parse_multipart(env).should.equal nil - end - - specify "should parse multipart upload with text file" do - env = Rack::MockRequest.env_for("/", multipart_fixture(:text)) - params = Rack::Utils::Multipart.parse_multipart(env) - params["submit-name"].should.equal "Larry" - params["files"][:type].should.equal "text/plain" - params["files"][:filename].should.equal "file1.txt" - params["files"][:head].should.equal "Content-Disposition: form-data; " + - "name=\"files\"; filename=\"file1.txt\"\r\n" + - "Content-Type: text/plain\r\n" - params["files"][:name].should.equal "files" - params["files"][:tempfile].read.should.equal "contents" - end - - specify "should parse multipart upload with nested parameters" do - env = Rack::MockRequest.env_for("/", multipart_fixture(:nested)) - params = Rack::Utils::Multipart.parse_multipart(env) - params["foo"]["submit-name"].should.equal "Larry" - params["foo"]["files"][:type].should.equal "text/plain" - params["foo"]["files"][:filename].should.equal "file1.txt" - params["foo"]["files"][:head].should.equal "Content-Disposition: form-data; " + - "name=\"foo[files]\"; filename=\"file1.txt\"\r\n" + - "Content-Type: text/plain\r\n" - params["foo"]["files"][:name].should.equal "foo[files]" - params["foo"]["files"][:tempfile].read.should.equal "contents" - end - - specify "should parse multipart upload with binary file" do - env = Rack::MockRequest.env_for("/", multipart_fixture(:binary)) - params = Rack::Utils::Multipart.parse_multipart(env) - params["submit-name"].should.equal "Larry" - params["files"][:type].should.equal "image/png" - params["files"][:filename].should.equal "rack-logo.png" - params["files"][:head].should.equal "Content-Disposition: form-data; " + - "name=\"files\"; filename=\"rack-logo.png\"\r\n" + - "Content-Type: image/png\r\n" - params["files"][:name].should.equal "files" - params["files"][:tempfile].read.length.should.equal 26473 - end - - specify "should parse multipart upload with empty file" do - env = Rack::MockRequest.env_for("/", multipart_fixture(:empty)) - params = Rack::Utils::Multipart.parse_multipart(env) - params["submit-name"].should.equal "Larry" - params["files"][:type].should.equal "text/plain" - params["files"][:filename].should.equal "file1.txt" - params["files"][:head].should.equal "Content-Disposition: form-data; " + - "name=\"files\"; filename=\"file1.txt\"\r\n" + - "Content-Type: text/plain\r\n" - params["files"][:name].should.equal "files" - params["files"][:tempfile].read.should.equal "" - end - - specify "should parse multipart upload with filename with semicolons" do - env = Rack::MockRequest.env_for("/", multipart_fixture(:semicolon)) - params = Rack::Utils::Multipart.parse_multipart(env) - params["files"][:type].should.equal "text/plain" - params["files"][:filename].should.equal "fi;le1.txt" - params["files"][:head].should.equal "Content-Disposition: form-data; " + - "name=\"files\"; filename=\"fi;le1.txt\"\r\n" + - "Content-Type: text/plain\r\n" - params["files"][:name].should.equal "files" - params["files"][:tempfile].read.should.equal "contents" - end - - specify "should not include file params if no file was selected" do - env = Rack::MockRequest.env_for("/", multipart_fixture(:none)) - params = Rack::Utils::Multipart.parse_multipart(env) - params["submit-name"].should.equal "Larry" - params["files"].should.equal nil - params.keys.should.not.include "files" - end - - specify "should parse IE multipart upload and clean up filename" do - env = Rack::MockRequest.env_for("/", multipart_fixture(:ie)) - params = Rack::Utils::Multipart.parse_multipart(env) - params["files"][:type].should.equal "text/plain" - params["files"][:filename].should.equal "file1.txt" - params["files"][:head].should.equal "Content-Disposition: form-data; " + - "name=\"files\"; " + - 'filename="C:\Documents and Settings\Administrator\Desktop\file1.txt"' + - "\r\nContent-Type: text/plain\r\n" - params["files"][:name].should.equal "files" - params["files"][:tempfile].read.should.equal "contents" - end - - specify "rewinds input after parsing upload" do - options = multipart_fixture(:text) - input = options[:input] - env = Rack::MockRequest.env_for("/", options) - params = Rack::Utils::Multipart.parse_multipart(env) - params["submit-name"].should.equal "Larry" - params["files"][:filename].should.equal "file1.txt" - input.read.length.should.equal 197 - end - - specify "builds multipart body" do - files = Rack::Utils::Multipart::UploadedFile.new(multipart_file("file1.txt")) - data = Rack::Utils::Multipart.build_multipart("submit-name" => "Larry", "files" => files) - - options = { - "CONTENT_TYPE" => "multipart/form-data; boundary=AaB03x", - "CONTENT_LENGTH" => data.length.to_s, - :input => StringIO.new(data) - } - env = Rack::MockRequest.env_for("/", options) - params = Rack::Utils::Multipart.parse_multipart(env) - params["submit-name"].should.equal "Larry" - params["files"][:filename].should.equal "file1.txt" - params["files"][:tempfile].read.should.equal "contents" - end - - specify "builds nested multipart body" do - files = Rack::Utils::Multipart::UploadedFile.new(multipart_file("file1.txt")) - data = Rack::Utils::Multipart.build_multipart("people" => [{"submit-name" => "Larry", "files" => files}]) - - options = { - "CONTENT_TYPE" => "multipart/form-data; boundary=AaB03x", - "CONTENT_LENGTH" => data.length.to_s, - :input => StringIO.new(data) - } - env = Rack::MockRequest.env_for("/", options) - params = Rack::Utils::Multipart.parse_multipart(env) - params["people"][0]["submit-name"].should.equal "Larry" - params["people"][0]["files"][:filename].should.equal "file1.txt" - params["people"][0]["files"][:tempfile].read.should.equal "contents" - end - - specify "can parse fields that end at the end of the buffer" do - input = File.read(multipart_file("bad_robots")) - - req = Rack::Request.new Rack::MockRequest.env_for("/", - "CONTENT_TYPE" => "multipart/form-data, boundary=1yy3laWhgX31qpiHinh67wJXqKalukEUTvqTzmon", - "CONTENT_LENGTH" => input.size, - :input => input) - - req.POST['file.path'].should.equal "/var/tmp/uploads/4/0001728414" - req.POST['addresses'].should.not.equal nil - end - - specify "builds complete params with the chunk size of 16384 slicing exactly on boundary" do - data = File.open(multipart_file("fail_16384_nofile")) { |f| f.read }.gsub(/\n/, "\r\n") - options = { - "CONTENT_TYPE" => "multipart/form-data; boundary=----WebKitFormBoundaryWsY0GnpbI5U7ztzo", - "CONTENT_LENGTH" => data.length.to_s, - :input => StringIO.new(data) - } - env = Rack::MockRequest.env_for("/", options) - params = Rack::Utils::Multipart.parse_multipart(env) - - params.should.not.equal nil - params.keys.should.include "AAAAAAAAAAAAAAAAAAA" - params["AAAAAAAAAAAAAAAAAAA"].keys.should.include "PLAPLAPLA_MEMMEMMEMM_ATTRATTRER" - params["AAAAAAAAAAAAAAAAAAA"]["PLAPLAPLA_MEMMEMMEMM_ATTRATTRER"].keys.should.include "new" - params["AAAAAAAAAAAAAAAAAAA"]["PLAPLAPLA_MEMMEMMEMM_ATTRATTRER"]["new"].keys.should.include "-2" - params["AAAAAAAAAAAAAAAAAAA"]["PLAPLAPLA_MEMMEMMEMM_ATTRATTRER"]["new"]["-2"].keys.should.include "ba_unit_id" - params["AAAAAAAAAAAAAAAAAAA"]["PLAPLAPLA_MEMMEMMEMM_ATTRATTRER"]["new"]["-2"]["ba_unit_id"].should.equal "1017" - end - - specify "should return nil if no UploadedFiles were used" do - data = Rack::Utils::Multipart.build_multipart("people" => [{"submit-name" => "Larry", "files" => "contents"}]) - data.should.equal nil - end - - specify "should raise ArgumentError if params is not a Hash" do - lambda { Rack::Utils::Multipart.build_multipart("foo=bar") }. - should.raise(ArgumentError). - message.should.equal "value must be a Hash" - end - - private - def multipart_fixture(name) - file = multipart_file(name) - data = File.open(file, 'rb') { |io| io.read } - - type = "multipart/form-data; boundary=AaB03x" - length = data.respond_to?(:bytesize) ? data.bytesize : data.size - - { "CONTENT_TYPE" => type, - "CONTENT_LENGTH" => length.to_s, - :input => StringIO.new(data) } - end - - def multipart_file(name) - File.join(File.dirname(__FILE__), "multipart", name.to_s) - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_webrick.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_webrick.rb deleted file mode 100755 index 599425c4f3d..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rack_webrick.rb +++ /dev/null @@ -1,130 +0,0 @@ -require 'test/spec' - -require 'rack/handler/webrick' -require 'rack/lint' -require 'rack/response' -require 'testrequest' - -Thread.abort_on_exception = true - -context "Rack::Handler::WEBrick" do - include TestRequest::Helpers - - setup do - @server = WEBrick::HTTPServer.new(:Host => @host='0.0.0.0', - :Port => @port=9202, - :Logger => WEBrick::Log.new(nil, WEBrick::BasicLog::WARN), - :AccessLog => []) - @server.mount "/test", Rack::Handler::WEBrick, - Rack::Lint.new(TestRequest.new) - Thread.new { @server.start } - trap(:INT) { @server.shutdown } - end - - specify "should respond" do - lambda { - GET("/test") - }.should.not.raise - end - - specify "should be a WEBrick" do - GET("/test") - status.should.be 200 - response["SERVER_SOFTWARE"].should =~ /WEBrick/ - response["HTTP_VERSION"].should.equal "HTTP/1.1" - response["SERVER_PROTOCOL"].should.equal "HTTP/1.1" - response["SERVER_PORT"].should.equal "9202" - response["SERVER_NAME"].should.equal "0.0.0.0" - end - - specify "should have rack headers" do - GET("/test") - response["rack.version"].should.equal [1,1] - response["rack.multithread"].should.be true - response["rack.multiprocess"].should.be false - response["rack.run_once"].should.be false - end - - specify "should have CGI headers on GET" do - GET("/test") - response["REQUEST_METHOD"].should.equal "GET" - response["SCRIPT_NAME"].should.equal "/test" - response["REQUEST_PATH"].should.equal "/" - response["PATH_INFO"].should.be.equal "" - response["QUERY_STRING"].should.equal "" - response["test.postdata"].should.equal "" - - GET("/test/foo?quux=1") - response["REQUEST_METHOD"].should.equal "GET" - response["SCRIPT_NAME"].should.equal "/test" - response["REQUEST_PATH"].should.equal "/" - response["PATH_INFO"].should.equal "/foo" - response["QUERY_STRING"].should.equal "quux=1" - - GET("/test/foo%25encoding?quux=1") - response["REQUEST_METHOD"].should.equal "GET" - response["SCRIPT_NAME"].should.equal "/test" - response["REQUEST_PATH"].should.equal "/" - response["PATH_INFO"].should.equal "/foo%25encoding" - response["QUERY_STRING"].should.equal "quux=1" - end - - specify "should have CGI headers on POST" do - POST("/test", {"rack-form-data" => "23"}, {'X-test-header' => '42'}) - status.should.equal 200 - response["REQUEST_METHOD"].should.equal "POST" - response["SCRIPT_NAME"].should.equal "/test" - response["REQUEST_PATH"].should.equal "/" - response["QUERY_STRING"].should.equal "" - response["HTTP_X_TEST_HEADER"].should.equal "42" - response["test.postdata"].should.equal "rack-form-data=23" - end - - specify "should support HTTP auth" do - GET("/test", {:user => "ruth", :passwd => "secret"}) - response["HTTP_AUTHORIZATION"].should.equal "Basic cnV0aDpzZWNyZXQ=" - end - - specify "should set status" do - GET("/test?secret") - status.should.equal 403 - response["rack.url_scheme"].should.equal "http" - end - - specify "should correctly set cookies" do - @server.mount "/cookie-test", Rack::Handler::WEBrick, - Rack::Lint.new(lambda { |req| - res = Rack::Response.new - res.set_cookie "one", "1" - res.set_cookie "two", "2" - res.finish - }) - - Net::HTTP.start(@host, @port) { |http| - res = http.get("/cookie-test") - res.code.to_i.should.equal 200 - res.get_fields("set-cookie").should.equal ["one=1", "two=2"] - } - end - - specify "should provide a .run" do - block_ran = false - catch(:done) { - Rack::Handler::WEBrick.run(lambda {}, - {:Port => 9210, - :Logger => WEBrick::Log.new(nil, WEBrick::BasicLog::WARN), - :AccessLog => []}) { |server| - block_ran = true - server.should.be.kind_of WEBrick::HTTPServer - @s = server - throw :done - } - } - block_ran.should.be true - @s.shutdown - end - - teardown do - @server.shutdown - end -end diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rackup.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rackup.rb deleted file mode 100755 index 55e7dc89e3b..00000000000 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/test/spec_rackup.rb +++ /dev/null @@ -1,164 +0,0 @@ -require 'test/spec' -require 'testrequest' -require 'rack/server' -require 'open3' - -begin -require "mongrel" - -context "rackup" do - include TestRequest::Helpers - - def run_rackup(*args) - options = args.last.is_a?(Hash) ? args.pop : {} - flags = args.first - @host = options[:host] || "0.0.0.0" - @port = options[:port] || 9292 - - Dir.chdir("#{root}/test/rackup") do - @in, @rackup, @err = Open3.popen3("#{ruby} -S #{rackup} #{flags}") - end - - return if options[:port] == false - - # Wait until the server is available - i = 0 - begin - GET("/") - rescue - i += 1 - if i > 40 - Dir["#{root}/**/*.pid"].each {|f| - Process.kill(9, File.read(f)) rescue nil - File.delete(f) - } - raise "Server did not start" - end - sleep 0.05 - retry - end - end - - def output - @rackup.read - end - - after do - # This doesn't actually return a response, so we rescue - GET "/die" rescue nil - - Dir["#{root}/**/*.pid"].each do |file| - Process.kill(9, File.read(file).strip.to_i) rescue nil - File.delete(file) - end - - File.delete("#{root}/log_output") if File.exist?("#{root}/log_output") - end - - specify "rackup" do - run_rackup - response["PATH_INFO"].should.equal '/' - response["test.$DEBUG"].should.be false - response["test.$EVAL"].should.be nil - response["test.$VERBOSE"].should.be false - response["test.Ping"].should.be nil - response["SERVER_SOFTWARE"].should.not =~ /webrick/ - end - - specify "rackup --help" do - run_rackup "--help", :port => false - output.should.match /--port/ - end - - specify "rackup --port" do - run_rackup "--port 9000", :port => 9000 - response["SERVER_PORT"].should.equal "9000" - end - - specify "rackup --debug" do - run_rackup "--debug" - response["test.$DEBUG"].should.be true - end - - specify "rackup --eval" do - run_rackup %{--eval "BUKKIT = 'BUKKIT'"} - response["test.$EVAL"].should.equal "BUKKIT" - end - - specify "rackup --warn" do - run_rackup %{--warn} - response["test.$VERBOSE"].should.be true - end - - specify "rackup --include" do - run_rackup %{--include /foo/bar} - response["test.$LOAD_PATH"].should.include "/foo/bar" - end - - specify "rackup --require" do - run_rackup %{--require ping} - response["test.Ping"].should.equal "constant" - end - - specify "rackup --server" do - run_rackup %{--server webrick} - response["SERVER_SOFTWARE"].should =~ /webrick/i - end - - specify "rackup --host" do - run_rackup %{--host 127.0.0.1}, :host => "127.0.0.1" - response["REMOTE_ADDR"].should.equal "127.0.0.1" - end - - specify "rackup --daemonize --pid" do - run_rackup "--daemonize --pid testing.pid" - status.should.be 200 - @rackup.should.be.eof? - Dir["#{root}/**/testing.pid"].should.not.be.empty? - end - - specify "rackup --pid" do - run_rackup %{--pid testing.pid} - status.should.be 200 - Dir["#{root}/**/testing.pid"].should.not.be.empty? - end - - specify "rackup --version" do - run_rackup %{--version}, :port => false - output.should =~ /Rack 1.1/ - end - - specify "rackup --env development includes lint" do - run_rackup - GET("/broken_lint") - status.should.be 500 - end - - specify "rackup --env deployment does not include lint" do - run_rackup %{--env deployment} - GET("/broken_lint") - status.should.be 200 - end - - specify "rackup --env none does not include lint" do - run_rackup %{--env none} - GET("/broken_lint") - status.should.be 200 - end - - specify "rackup --env deployment does log" do - run_rackup %{--env deployment} - log = File.read(response["test.stderr"]) - log.should.be.empty? - end - - specify "rackup --env none does not log" do - run_rackup %{--env none} - GET("/") - log = File.read(response["test.stderr"]) - log.should.be.empty? - end -end -rescue LoadError - $stderr.puts "Skipping rackup --server tests (mongrel is required). `gem install thin` and try again." -end
\ No newline at end of file diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/COPYING b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/COPYING index 83b390bcb13..83b390bcb13 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/COPYING +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/COPYING diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack.rb index 527f445e0aa..848eb12ef58 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack.rb @@ -20,7 +20,7 @@ module Rack # Return the Rack release as a dotted string. def self.release - "1.1.3" + "1.1.6" end autoload :Builder, "rack/builder" @@ -71,6 +71,18 @@ module Rack autoload :Params, "rack/auth/digest/params" autoload :Request, "rack/auth/digest/request" end + + # Not all of the following schemes are "standards", but they are used often. + @schemes = %w[basic digest bearer mac token oauth oauth2] + + def self.add_scheme scheme + @schemes << scheme + @schemes.uniq! + end + + def self.schemes + @schemes.dup + end end module Session diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/adapter/camping.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/adapter/camping.rb index 63bc787f545..63bc787f545 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/adapter/camping.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/adapter/camping.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/auth/abstract/handler.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/auth/abstract/handler.rb index 214df6299e1..214df6299e1 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/auth/abstract/handler.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/auth/abstract/handler.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/auth/abstract/request.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/auth/abstract/request.rb index 1d9ccec6859..c4bd105fe9a 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/auth/abstract/request.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/auth/abstract/request.rb @@ -15,7 +15,11 @@ module Rack end def scheme - @scheme ||= parts.first.downcase.to_sym + @scheme ||= + begin + s = parts.first.downcase + Rack::Auth.schemes.include?(s) ? s.to_sym : s + end end def params diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/auth/basic.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/auth/basic.rb index 9557224648c..9557224648c 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/auth/basic.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/auth/basic.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/auth/digest/md5.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/auth/digest/md5.rb index d277571c804..d277571c804 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/auth/digest/md5.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/auth/digest/md5.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/auth/digest/nonce.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/auth/digest/nonce.rb index dbe109f29ac..dbe109f29ac 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/auth/digest/nonce.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/auth/digest/nonce.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/auth/digest/params.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/auth/digest/params.rb index 730e2efdc80..730e2efdc80 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/auth/digest/params.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/auth/digest/params.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/auth/digest/request.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/auth/digest/request.rb index a8aa3bf996b..a8aa3bf996b 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/auth/digest/request.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/auth/digest/request.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/builder.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/builder.rb index 530f0aaf07e..530f0aaf07e 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/builder.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/builder.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/cascade.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/cascade.rb index 14c3e54d350..14c3e54d350 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/cascade.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/cascade.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/chunked.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/chunked.rb index dddf9694cb9..dddf9694cb9 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/chunked.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/chunked.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/commonlogger.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/commonlogger.rb index 1edc9b83607..1edc9b83607 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/commonlogger.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/commonlogger.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/conditionalget.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/conditionalget.rb index 046ebdb00ab..046ebdb00ab 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/conditionalget.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/conditionalget.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/config.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/config.rb index c6d446c0c85..c6d446c0c85 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/config.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/config.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/content_length.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/content_length.rb index 1e56d438531..1e56d438531 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/content_length.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/content_length.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/content_type.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/content_type.rb index 874c28cd7be..874c28cd7be 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/content_type.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/content_type.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/deflater.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/deflater.rb index ad0f53161b6..ad0f53161b6 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/deflater.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/deflater.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/directory.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/directory.rb index 927ac0c9fb8..927ac0c9fb8 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/directory.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/directory.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/etag.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/etag.rb index 06dbc6aa5f8..06dbc6aa5f8 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/etag.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/etag.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/file.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/file.rb index 14af7b3bd74..14af7b3bd74 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/file.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/file.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/handler.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/handler.rb index 3c09883ed5f..3c09883ed5f 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/handler.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/handler.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/handler/cgi.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/handler/cgi.rb index c6903f1558a..c6903f1558a 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/handler/cgi.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/handler/cgi.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/handler/evented_mongrel.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/handler/evented_mongrel.rb index 0f5cbf72939..0f5cbf72939 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/handler/evented_mongrel.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/handler/evented_mongrel.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/handler/fastcgi.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/handler/fastcgi.rb index b992a5f48cd..b992a5f48cd 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/handler/fastcgi.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/handler/fastcgi.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/handler/lsws.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/handler/lsws.rb index eabc0bc9b17..eabc0bc9b17 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/handler/lsws.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/handler/lsws.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/handler/mongrel.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/handler/mongrel.rb index b6b775ea811..b6b775ea811 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/handler/mongrel.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/handler/mongrel.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/handler/scgi.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/handler/scgi.rb index 79a6b2bd183..79a6b2bd183 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/handler/scgi.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/handler/scgi.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/handler/swiftiplied_mongrel.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/handler/swiftiplied_mongrel.rb index 4bafd0b9533..4bafd0b9533 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/handler/swiftiplied_mongrel.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/handler/swiftiplied_mongrel.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/handler/thin.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/handler/thin.rb index 3d4fedff75c..3d4fedff75c 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/handler/thin.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/handler/thin.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/handler/webrick.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/handler/webrick.rb index 8d7f5724aff..8d7f5724aff 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/handler/webrick.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/handler/webrick.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/head.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/head.rb index deab822a999..deab822a999 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/head.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/head.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/lint.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/lint.rb index 534375b9344..534375b9344 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/lint.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/lint.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/lobster.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/lobster.rb index f63f419a494..f63f419a494 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/lobster.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/lobster.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/lock.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/lock.rb index 93238528c44..93238528c44 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/lock.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/lock.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/logger.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/logger.rb index d67d8ce2d28..d67d8ce2d28 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/logger.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/logger.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/methodoverride.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/methodoverride.rb index 0eed29f4713..0eed29f4713 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/methodoverride.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/methodoverride.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/mime.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/mime.rb index 1414d19a510..1414d19a510 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/mime.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/mime.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/mock.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/mock.rb index 23ecba178db..23ecba178db 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/mock.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/mock.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/nulllogger.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/nulllogger.rb index 77fb637deea..77fb637deea 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/nulllogger.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/nulllogger.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/recursive.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/recursive.rb index bf8b9659255..bf8b9659255 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/recursive.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/recursive.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/reloader.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/reloader.rb index a06de23abe8..a06de23abe8 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/reloader.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/reloader.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/request.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/request.rb index b3de1ce4685..b3de1ce4685 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/request.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/request.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/response.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/response.rb index a7f9bf2b7d8..a7f9bf2b7d8 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/response.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/response.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/rewindable_input.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/rewindable_input.rb index accd96becf9..accd96becf9 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/rewindable_input.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/rewindable_input.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/runtime.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/runtime.rb index 1bd411fd1dc..1bd411fd1dc 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/runtime.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/runtime.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/sendfile.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/sendfile.rb index 4fa829462bc..4fa829462bc 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/sendfile.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/sendfile.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/server.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/server.rb index 4afe513faaa..4afe513faaa 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/server.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/server.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/session/abstract/id.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/session/abstract/id.rb index 987467050a6..987467050a6 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/session/abstract/id.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/session/abstract/id.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/session/cookie.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/session/cookie.rb index 240e6c8dbe5..63c426f0c9a 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/session/cookie.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/session/cookie.rb @@ -27,6 +27,15 @@ module Rack @app = app @key = options[:key] || "rack.session" @secret = options[:secret] + warn <<-MSG unless @secret + SECURITY WARNING: No secret option provided to Rack::Session::Cookie. + This poses a security threat. It is strongly recommended that you + provide a secret to prevent exploits that may be possible from crafted + cookies. This will not be supported in future versions of Rack, and + future versions will even invalidate your existing user cookies. + + Called from: #{caller[0]}. + MSG @default_options = {:domain => nil, :path => "/", :expire_after => nil}.merge(options) @@ -46,7 +55,7 @@ module Rack if @secret && session_data session_data, digest = session_data.split("--") - session_data = nil unless digest == generate_hmac(session_data) + session_data = nil unless Utils.secure_compare(digest, generate_hmac(session_data)) end begin diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/session/memcache.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/session/memcache.rb index 44629da3588..44629da3588 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/session/memcache.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/session/memcache.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/session/pool.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/session/pool.rb index b3f8bd726a1..b3f8bd726a1 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/session/pool.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/session/pool.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/showexceptions.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/showexceptions.rb index 697bc41fdb1..697bc41fdb1 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/showexceptions.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/showexceptions.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/showstatus.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/showstatus.rb index 28258c7c892..28258c7c892 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/showstatus.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/showstatus.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/static.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/static.rb index 168e8f83b2c..168e8f83b2c 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/static.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/static.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/urlmap.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/urlmap.rb index b699d35b943..b699d35b943 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/urlmap.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/urlmap.rb diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/utils.rb b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/utils.rb index fc6e8a2b1ee..b4a5ab41657 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/lib/rack/utils.rb +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/lib/rack/utils.rb @@ -285,6 +285,18 @@ module Rack end module_function :bytesize + # Constant time string comparison. + def secure_compare(a, b) + return false unless bytesize(a) == bytesize(b) + + l = a.unpack("C*") + + r, i = 0, -1 + b.each_byte { |v| r |= v ^ l[i+=1] } + r == 0 + end + module_function :secure_compare + # Context allows the use of a compatible middleware at different points # in a request handling stack. A compatible middleware must define # #context which should take the arguments env and app. The first of which diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/rack.gemspec b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/rack.gemspec index 1f04bcc7c54..d7d0b0c57ed 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.3/rack.gemspec +++ b/sonar-server/src/main/webapp/WEB-INF/gems/gems/rack-1.1.6/rack.gemspec @@ -3,7 +3,7 @@ require 'rack' # For Rack.release Gem::Specification.new do |s| s.name = "rack" - s.version = Rack.release + s.version = "1.1.6" s.platform = Gem::Platform::RUBY s.summary = "a modular Ruby webserver interface" diff --git a/sonar-server/src/main/webapp/WEB-INF/gems/specifications/rack-1.1.3.gemspec b/sonar-server/src/main/webapp/WEB-INF/gems/specifications/rack-1.1.6.gemspec index 2941436e72e..7802c71dfe9 100755..100644 --- a/sonar-server/src/main/webapp/WEB-INF/gems/specifications/rack-1.1.3.gemspec +++ b/sonar-server/src/main/webapp/WEB-INF/gems/specifications/rack-1.1.6.gemspec @@ -2,11 +2,11 @@ Gem::Specification.new do |s| s.name = "rack" - s.version = "1.1.3" + s.version = "1.1.6" s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version= s.authors = ["Christian Neukirchen"] - s.date = "2011-12-28" + s.date = "2013-02-08" s.description = "Rack provides minimal, modular and adaptable interface for developing\nweb applications in Ruby. By wrapping HTTP requests and responses in\nthe simplest way possible, it unifies and distills the API for web\nservers, web frameworks, and software in between (the so-called\nmiddleware) into a single method call.\n\nAlso see http://rack.rubyforge.org.\n" s.email = "chneukirchen@gmail.com" s.executables = ["rackup"] @@ -15,7 +15,7 @@ Gem::Specification.new do |s| s.homepage = "http://rack.rubyforge.org" s.require_paths = ["lib"] s.rubyforge_project = "rack" - s.rubygems_version = "1.8.15" + s.rubygems_version = "2.0.5" s.summary = "a modular Ruby webserver interface" if s.respond_to? :specification_version then |
