RubyGems - mongrel - Versions diffs - 0.3.13 → 0.3.13.1 - Mend

mongrel 0.3.13 → 0.3.13.1

Files changed (179) hide show

data/doc/rdoc/classes/Mongrel/HttpParser.src/M000052.html CHANGED

@@ -5,55 +5,25 @@
 <html>
 <head>
-  <title>execute (Mongrel::HttpParser)</title>
+  <title>finish (Mongrel::HttpParser)</title>
   <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
   <link rel="stylesheet" href="../../.././rdoc-style.css" type="text/css" media="screen" />
 </head>
 <body class="standalone-code">
   <pre>/**
  * call-seq:
- *    parser.execute(req_hash, data, start) -&gt; Integer
+ *    parser.finish -&gt; true/false
  *
- * Takes a Hash and a String of data, parses the String of data filling in the Hash
- * returning an Integer to indicate how much of the data has been read.  No matter
- * what the return value, you should call HttpParser#finished? and HttpParser#error?
- * to figure out if it's done parsing or there was an error.
- *
- * This function now throws an exception when there is a parsing error.  This makes
- * the logic for working with the parser much easier.  You can still test for an
- * error, but now you need to wrap the parser with an exception handling block.
- *
- * The third argument allows for parsing a partial request and then continuing
- * the parsing from that position.  It needs all of the original data as well
- * so you have to append to the data buffer as you read.
+ * Finishes a parser early which could put in a &quot;good&quot; or bad state.
+ * You should call reset after finish it or bad things will happen.
  */
-VALUE HttpParser_execute(VALUE self, VALUE req_hash, VALUE data, VALUE start)
+VALUE HttpParser_finish(VALUE self)
 {
   http_parser *http = NULL;
-  int from = 0;
-  char *dptr = NULL;
-  long dlen = 0;
   DATA_GET(self, http_parser, http);
-  from = FIX2INT(start);
-  dptr = RSTRING(data)-&gt;ptr;
-  dlen = RSTRING(data)-&gt;len;
+  http_parser_finish(http);
-  if(from &gt;= dlen) {
-    rb_raise(eHttpParserError, &quot;Requested start is after data buffer end.&quot;);
-  } else {
-    http-&gt;data = (void *)req_hash;
-    http_parser_execute(http, dptr, dlen, from);
-    VALIDATE_MAX_LENGTH(http_parser_nread(http), HEADER);
-    if(http_parser_has_error(http)) {
-      rb_raise(eHttpParserError, &quot;Invalid HTTP format, parsing fails.&quot;);
-    } else {
-      return INT2FIX(http_parser_nread(http));
-    }
-  }
+  return http_parser_is_finished(http) ? Qtrue : Qfalse;
 }</pre>
 </body>
 </html>

data/doc/rdoc/classes/Mongrel/HttpParser.src/M000053.html CHANGED

@@ -5,23 +5,55 @@
 <html>
 <head>
-  <title>error? (Mongrel::HttpParser)</title>
+  <title>execute (Mongrel::HttpParser)</title>
   <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
   <link rel="stylesheet" href="../../.././rdoc-style.css" type="text/css" media="screen" />
 </head>
 <body class="standalone-code">
   <pre>/**
  * call-seq:
- *    parser.error? -&gt; true/false
+ *    parser.execute(req_hash, data, start) -&gt; Integer
  *
- * Tells you whether the parser is in an error state.
+ * Takes a Hash and a String of data, parses the String of data filling in the Hash
+ * returning an Integer to indicate how much of the data has been read.  No matter
+ * what the return value, you should call HttpParser#finished? and HttpParser#error?
+ * to figure out if it's done parsing or there was an error.
+ *
+ * This function now throws an exception when there is a parsing error.  This makes
+ * the logic for working with the parser much easier.  You can still test for an
+ * error, but now you need to wrap the parser with an exception handling block.
+ *
+ * The third argument allows for parsing a partial request and then continuing
+ * the parsing from that position.  It needs all of the original data as well
+ * so you have to append to the data buffer as you read.
  */
-VALUE HttpParser_has_error(VALUE self)
+VALUE HttpParser_execute(VALUE self, VALUE req_hash, VALUE data, VALUE start)
 {
   http_parser *http = NULL;
+  int from = 0;
+  char *dptr = NULL;
+  long dlen = 0;
   DATA_GET(self, http_parser, http);
+  from = FIX2INT(start);
+  dptr = RSTRING(data)-&gt;ptr;
+  dlen = RSTRING(data)-&gt;len;
-  return http_parser_has_error(http) ? Qtrue : Qfalse;
+  if(from &gt;= dlen) {
+    rb_raise(eHttpParserError, &quot;Requested start is after data buffer end.&quot;);
+  } else {
+    http-&gt;data = (void *)req_hash;
+    http_parser_execute(http, dptr, dlen, from);
+    VALIDATE_MAX_LENGTH(http_parser_nread(http), HEADER);
+    if(http_parser_has_error(http)) {
+      rb_raise(eHttpParserError, &quot;Invalid HTTP format, parsing fails.&quot;);
+    } else {
+      return INT2FIX(http_parser_nread(http));
+    }
+  }
 }</pre>
 </body>
 </html>

data/doc/rdoc/classes/Mongrel/HttpParser.src/M000054.html CHANGED

@@ -5,23 +5,23 @@
 <html>
 <head>
-  <title>finished? (Mongrel::HttpParser)</title>
+  <title>error? (Mongrel::HttpParser)</title>
   <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
   <link rel="stylesheet" href="../../.././rdoc-style.css" type="text/css" media="screen" />
 </head>
 <body class="standalone-code">
   <pre>/**
  * call-seq:
- *    parser.finished? -&gt; true/false
+ *    parser.error? -&gt; true/false
  *
- * Tells you whether the parser is finished or not and in a good state.
+ * Tells you whether the parser is in an error state.
  */
-VALUE HttpParser_is_finished(VALUE self)
+VALUE HttpParser_has_error(VALUE self)
 {
   http_parser *http = NULL;
   DATA_GET(self, http_parser, http);
-  return http_parser_is_finished(http) ? Qtrue : Qfalse;
+  return http_parser_has_error(http) ? Qtrue : Qfalse;
 }</pre>
 </body>
 </html>

data/doc/rdoc/classes/Mongrel/HttpParser.src/M000055.html CHANGED

@@ -5,24 +5,23 @@
 <html>
 <head>
-  <title>nread (Mongrel::HttpParser)</title>
+  <title>finished? (Mongrel::HttpParser)</title>
   <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
   <link rel="stylesheet" href="../../.././rdoc-style.css" type="text/css" media="screen" />
 </head>
 <body class="standalone-code">
   <pre>/**
  * call-seq:
- *    parser.nread -&gt; Integer
+ *    parser.finished? -&gt; true/false
  *
- * Returns the amount of data processed so far during this processing cycle.  It is
- * set to 0 on initialize or reset calls and is incremented each time execute is called.
+ * Tells you whether the parser is finished or not and in a good state.
  */
-VALUE HttpParser_nread(VALUE self)
+VALUE HttpParser_is_finished(VALUE self)
 {
   http_parser *http = NULL;
   DATA_GET(self, http_parser, http);
-  return INT2FIX(http-&gt;nread);
+  return http_parser_is_finished(http) ? Qtrue : Qfalse;
 }</pre>
 </body>
 </html>

data/doc/rdoc/classes/Mongrel/HttpParser.src/{M000049.html → M000056.html} RENAMED

@@ -5,24 +5,24 @@
 <html>
 <head>
-  <title>new (Mongrel::HttpParser)</title>
+  <title>nread (Mongrel::HttpParser)</title>
   <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
   <link rel="stylesheet" href="../../.././rdoc-style.css" type="text/css" media="screen" />
 </head>
 <body class="standalone-code">
   <pre>/**
  * call-seq:
- *    parser.new -&gt; parser
+ *    parser.nread -&gt; Integer
  *
- * Creates a new parser.
+ * Returns the amount of data processed so far during this processing cycle.  It is
+ * set to 0 on initialize or reset calls and is incremented each time execute is called.
  */
-VALUE HttpParser_init(VALUE self)
+VALUE HttpParser_nread(VALUE self)
 {
   http_parser *http = NULL;
   DATA_GET(self, http_parser, http);
-  http_parser_init(http);
-  return self;
+  return INT2FIX(http-&gt;nread);
 }</pre>
 </body>
 </html>

data/doc/rdoc/classes/Mongrel/HttpRequest.html CHANGED

@@ -102,10 +102,10 @@ uses a StringIO object. To be safe, you should assume it works like a file.
       <h3 class="section-bar">Methods</h3>
       <div class="name-list">
-      <a href="#M000131">escape</a>&nbsp;&nbsp;
-      <a href="#M000130">new</a>&nbsp;&nbsp;
-      <a href="#M000133">query_parse</a>&nbsp;&nbsp;
-      <a href="#M000132">unescape</a>&nbsp;&nbsp;
+      <a href="#M000136">escape</a>&nbsp;&nbsp;
+      <a href="#M000135">new</a>&nbsp;&nbsp;
+      <a href="#M000138">query_parse</a>&nbsp;&nbsp;
+      <a href="#M000137">unescape</a>&nbsp;&nbsp;
       </div>
     </div>
@@ -145,12 +145,12 @@ uses a StringIO object. To be safe, you should assume it works like a file.
     <div id="methods">
       <h3 class="section-bar">Public Class methods</h3>
-      <div id="method-M000131" class="method-detail">
-        <a name="M000131"></a>
+      <div id="method-M000136" class="method-detail">
+        <a name="M000136"></a>
         <div class="method-heading">
-          <a href="HttpRequest.src/M000131.html" target="Code" class="method-signature"
-            onclick="popupCode('HttpRequest.src/M000131.html');return false;">
+          <a href="HttpRequest.src/M000136.html" target="Code" class="method-signature"
+            onclick="popupCode('HttpRequest.src/M000136.html');return false;">
           <span class="method-name">escape</span><span class="method-args">(s)</span>
           </a>
         </div>
@@ -164,12 +164,12 @@ faster. Use this rather than the cgi.rb version since it&#8217;s faster.
         </div>
       </div>
-      <div id="method-M000130" class="method-detail">
-        <a name="M000130"></a>
+      <div id="method-M000135" class="method-detail">
+        <a name="M000135"></a>
         <div class="method-heading">
-          <a href="HttpRequest.src/M000130.html" target="Code" class="method-signature"
-            onclick="popupCode('HttpRequest.src/M000130.html');return false;">
+          <a href="HttpRequest.src/M000135.html" target="Code" class="method-signature"
+            onclick="popupCode('HttpRequest.src/M000135.html');return false;">
           <span class="method-name">new</span><span class="method-args">(params, initial_body, socket)</span>
           </a>
         </div>
@@ -186,12 +186,12 @@ TODO: Implement tempfile removal when the request is done.
         </div>
       </div>
-      <div id="method-M000133" class="method-detail">
-        <a name="M000133"></a>
+      <div id="method-M000138" class="method-detail">
+        <a name="M000138"></a>
         <div class="method-heading">
-          <a href="HttpRequest.src/M000133.html" target="Code" class="method-signature"
-            onclick="popupCode('HttpRequest.src/M000133.html');return false;">
+          <a href="HttpRequest.src/M000138.html" target="Code" class="method-signature"
+            onclick="popupCode('HttpRequest.src/M000138.html');return false;">
           <span class="method-name">query_parse</span><span class="method-args">(qs, d = '&amp;;')</span>
           </a>
         </div>
@@ -206,12 +206,12 @@ changing the characters used in the second parameter (which defaults to
         </div>
       </div>
-      <div id="method-M000132" class="method-detail">
-        <a name="M000132"></a>
+      <div id="method-M000137" class="method-detail">
+        <a name="M000137"></a>
         <div class="method-heading">
-          <a href="HttpRequest.src/M000132.html" target="Code" class="method-signature"
-            onclick="popupCode('HttpRequest.src/M000132.html');return false;">
+          <a href="HttpRequest.src/M000137.html" target="Code" class="method-signature"
+            onclick="popupCode('HttpRequest.src/M000137.html');return false;">
           <span class="method-name">unescape</span><span class="method-args">(s)</span>
           </a>
         </div>

data/doc/rdoc/classes/Mongrel/HttpRequest.src/{M000130.html → M000135.html} RENAMED

@@ -10,43 +10,43 @@
   <link rel="stylesheet" href="../../.././rdoc-style.css" type="text/css" media="screen" />
 </head>
 <body class="standalone-code">
-  <pre>     <span class="ruby-comment cmt"># File lib/mongrel.rb, line 194</span>
-194:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">initialize</span>(<span class="ruby-identifier">params</span>, <span class="ruby-identifier">initial_body</span>, <span class="ruby-identifier">socket</span>)
-195:       <span class="ruby-ivar">@params</span> = <span class="ruby-identifier">params</span>
-196:       <span class="ruby-ivar">@socket</span> = <span class="ruby-identifier">socket</span>
-197:
-198:       <span class="ruby-identifier">clen</span> = <span class="ruby-identifier">params</span>[<span class="ruby-constant">Const</span><span class="ruby-operator">::</span><span class="ruby-constant">CONTENT_LENGTH</span>].<span class="ruby-identifier">to_i</span> <span class="ruby-operator">-</span> <span class="ruby-identifier">initial_body</span>.<span class="ruby-identifier">length</span>
-199:
-200:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">clen</span> <span class="ruby-operator">&gt;</span> <span class="ruby-constant">Const</span><span class="ruby-operator">::</span><span class="ruby-constant">MAX_BODY</span>
-201:         <span class="ruby-ivar">@body</span> = <span class="ruby-constant">Tempfile</span>.<span class="ruby-identifier">new</span>(<span class="ruby-constant">Const</span><span class="ruby-operator">::</span><span class="ruby-constant">MONGREL_TMP_BASE</span>)
-202:         <span class="ruby-ivar">@body</span>.<span class="ruby-identifier">binmode</span>
-203:       <span class="ruby-keyword kw">else</span>
-204:         <span class="ruby-ivar">@body</span> = <span class="ruby-constant">StringIO</span>.<span class="ruby-identifier">new</span>
-205:       <span class="ruby-keyword kw">end</span>
-206:
-207:       <span class="ruby-keyword kw">begin</span>
-208:         <span class="ruby-ivar">@body</span>.<span class="ruby-identifier">write</span>(<span class="ruby-identifier">initial_body</span>)
-209:
-210:         <span class="ruby-comment cmt"># write the odd sized chunk first</span>
-211:         <span class="ruby-identifier">clen</span> <span class="ruby-operator">-=</span> <span class="ruby-ivar">@body</span>.<span class="ruby-identifier">write</span>(<span class="ruby-ivar">@socket</span>.<span class="ruby-identifier">read</span>(<span class="ruby-identifier">clen</span> <span class="ruby-operator">%</span> <span class="ruby-constant">Const</span><span class="ruby-operator">::</span><span class="ruby-constant">CHUNK_SIZE</span>))
-212:
-213:         <span class="ruby-comment cmt"># then stream out nothing but perfectly sized chunks</span>
-214:         <span class="ruby-keyword kw">while</span> <span class="ruby-identifier">clen</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
-215:           <span class="ruby-identifier">data</span> = <span class="ruby-ivar">@socket</span>.<span class="ruby-identifier">read</span>(<span class="ruby-constant">Const</span><span class="ruby-operator">::</span><span class="ruby-constant">CHUNK_SIZE</span>)
-216:           <span class="ruby-comment cmt"># have to do it this way since @socket.eof? causes it to block</span>
-217:           <span class="ruby-identifier">raise</span> <span class="ruby-value str">&quot;Socket closed or read failure&quot;</span> <span class="ruby-keyword kw">if</span> <span class="ruby-keyword kw">not</span> <span class="ruby-identifier">data</span> <span class="ruby-keyword kw">or</span> <span class="ruby-identifier">data</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">!=</span> <span class="ruby-constant">Const</span><span class="ruby-operator">::</span><span class="ruby-constant">CHUNK_SIZE</span>
-218:           <span class="ruby-identifier">clen</span> <span class="ruby-operator">-=</span> <span class="ruby-ivar">@body</span>.<span class="ruby-identifier">write</span>(<span class="ruby-identifier">data</span>)
-219:           <span class="ruby-comment cmt"># ASSUME: we are writing to a disk and these writes always write the requested amount</span>
-220:         <span class="ruby-keyword kw">end</span>
-221:
-222:         <span class="ruby-comment cmt"># rewind to keep the world happy</span>
-223:         <span class="ruby-ivar">@body</span>.<span class="ruby-identifier">rewind</span>
-224:       <span class="ruby-keyword kw">rescue</span> <span class="ruby-constant">Object</span>
-225:         <span class="ruby-comment cmt"># any errors means we should delete the file, including if the file is dumped</span>
-226:         <span class="ruby-constant">STDERR</span>.<span class="ruby-identifier">puts</span> <span class="ruby-value str">&quot;Error reading request: #$!&quot;</span>
-227:         <span class="ruby-ivar">@body</span>.<span class="ruby-identifier">delete</span> <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@body</span>.<span class="ruby-identifier">class</span> <span class="ruby-operator">==</span> <span class="ruby-constant">Tempfile</span>
-228:         <span class="ruby-ivar">@body</span> = <span class="ruby-keyword kw">nil</span> <span class="ruby-comment cmt"># signals that there was a problem</span>
-229:       <span class="ruby-keyword kw">end</span>
-230:     <span class="ruby-keyword kw">end</span></pre>
+  <pre>     <span class="ruby-comment cmt"># File lib/mongrel.rb, line 195</span>
+195:     <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">initialize</span>(<span class="ruby-identifier">params</span>, <span class="ruby-identifier">initial_body</span>, <span class="ruby-identifier">socket</span>)
+196:       <span class="ruby-ivar">@params</span> = <span class="ruby-identifier">params</span>
+197:       <span class="ruby-ivar">@socket</span> = <span class="ruby-identifier">socket</span>
+198:
+199:       <span class="ruby-identifier">clen</span> = <span class="ruby-identifier">params</span>[<span class="ruby-constant">Const</span><span class="ruby-operator">::</span><span class="ruby-constant">CONTENT_LENGTH</span>].<span class="ruby-identifier">to_i</span> <span class="ruby-operator">-</span> <span class="ruby-identifier">initial_body</span>.<span class="ruby-identifier">length</span>
+200:
+201:       <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">clen</span> <span class="ruby-operator">&gt;</span> <span class="ruby-constant">Const</span><span class="ruby-operator">::</span><span class="ruby-constant">MAX_BODY</span>
+202:         <span class="ruby-ivar">@body</span> = <span class="ruby-constant">Tempfile</span>.<span class="ruby-identifier">new</span>(<span class="ruby-constant">Const</span><span class="ruby-operator">::</span><span class="ruby-constant">MONGREL_TMP_BASE</span>)
+203:         <span class="ruby-ivar">@body</span>.<span class="ruby-identifier">binmode</span>
+204:       <span class="ruby-keyword kw">else</span>
+205:         <span class="ruby-ivar">@body</span> = <span class="ruby-constant">StringIO</span>.<span class="ruby-identifier">new</span>
+206:       <span class="ruby-keyword kw">end</span>
+207:
+208:       <span class="ruby-keyword kw">begin</span>
+209:         <span class="ruby-ivar">@body</span>.<span class="ruby-identifier">write</span>(<span class="ruby-identifier">initial_body</span>)
+210:
+211:         <span class="ruby-comment cmt"># write the odd sized chunk first</span>
+212:         <span class="ruby-identifier">clen</span> <span class="ruby-operator">-=</span> <span class="ruby-ivar">@body</span>.<span class="ruby-identifier">write</span>(<span class="ruby-ivar">@socket</span>.<span class="ruby-identifier">read</span>(<span class="ruby-identifier">clen</span> <span class="ruby-operator">%</span> <span class="ruby-constant">Const</span><span class="ruby-operator">::</span><span class="ruby-constant">CHUNK_SIZE</span>))
+213:
+214:         <span class="ruby-comment cmt"># then stream out nothing but perfectly sized chunks</span>
+215:         <span class="ruby-keyword kw">while</span> <span class="ruby-identifier">clen</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
+216:           <span class="ruby-identifier">data</span> = <span class="ruby-ivar">@socket</span>.<span class="ruby-identifier">read</span>(<span class="ruby-constant">Const</span><span class="ruby-operator">::</span><span class="ruby-constant">CHUNK_SIZE</span>)
+217:           <span class="ruby-comment cmt"># have to do it this way since @socket.eof? causes it to block</span>
+218:           <span class="ruby-identifier">raise</span> <span class="ruby-value str">&quot;Socket closed or read failure&quot;</span> <span class="ruby-keyword kw">if</span> <span class="ruby-keyword kw">not</span> <span class="ruby-identifier">data</span> <span class="ruby-keyword kw">or</span> <span class="ruby-identifier">data</span>.<span class="ruby-identifier">length</span> <span class="ruby-operator">!=</span> <span class="ruby-constant">Const</span><span class="ruby-operator">::</span><span class="ruby-constant">CHUNK_SIZE</span>
+219:           <span class="ruby-identifier">clen</span> <span class="ruby-operator">-=</span> <span class="ruby-ivar">@body</span>.<span class="ruby-identifier">write</span>(<span class="ruby-identifier">data</span>)
+220:           <span class="ruby-comment cmt"># ASSUME: we are writing to a disk and these writes always write the requested amount</span>
+221:         <span class="ruby-keyword kw">end</span>
+222:
+223:         <span class="ruby-comment cmt"># rewind to keep the world happy</span>
+224:         <span class="ruby-ivar">@body</span>.<span class="ruby-identifier">rewind</span>
+225:       <span class="ruby-keyword kw">rescue</span> <span class="ruby-constant">Object</span>
+226:         <span class="ruby-comment cmt"># any errors means we should delete the file, including if the file is dumped</span>
+227:         <span class="ruby-constant">STDERR</span>.<span class="ruby-identifier">puts</span> <span class="ruby-value str">&quot;Error reading request: #$!&quot;</span>
+228:         <span class="ruby-ivar">@body</span>.<span class="ruby-identifier">delete</span> <span class="ruby-keyword kw">if</span> <span class="ruby-ivar">@body</span>.<span class="ruby-identifier">class</span> <span class="ruby-operator">==</span> <span class="ruby-constant">Tempfile</span>
+229:         <span class="ruby-ivar">@body</span> = <span class="ruby-keyword kw">nil</span> <span class="ruby-comment cmt"># signals that there was a problem</span>
+230:       <span class="ruby-keyword kw">end</span>
+231:     <span class="ruby-keyword kw">end</span></pre>
 </body>
 </html>

data/doc/rdoc/classes/Mongrel/HttpRequest.src/{M000131.html → M000136.html} RENAMED

@@ -10,11 +10,11 @@
   <link rel="stylesheet" href="../../.././rdoc-style.css" type="text/css" media="screen" />
 </head>
 <body class="standalone-code">
-  <pre>     <span class="ruby-comment cmt"># File lib/mongrel.rb, line 235</span>
-235:     <span class="ruby-keyword kw">def</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">escape</span>(<span class="ruby-identifier">s</span>)
-236:       <span class="ruby-identifier">s</span>.<span class="ruby-identifier">to_s</span>.<span class="ruby-identifier">gsub</span>(<span class="ruby-regexp re">/([^ a-zA-Z0-9_.-]+)/n</span>) {
-237:         <span class="ruby-value str">'%'</span><span class="ruby-operator">+</span><span class="ruby-identifier">$1</span>.<span class="ruby-identifier">unpack</span>(<span class="ruby-value str">'H2'</span><span class="ruby-operator">*</span><span class="ruby-identifier">$1</span>.<span class="ruby-identifier">size</span>).<span class="ruby-identifier">join</span>(<span class="ruby-value str">'%'</span>).<span class="ruby-identifier">upcase</span>
-238:       }.<span class="ruby-identifier">tr</span>(<span class="ruby-value str">' '</span>, <span class="ruby-value str">'+'</span>)
-239:     <span class="ruby-keyword kw">end</span></pre>
+  <pre>     <span class="ruby-comment cmt"># File lib/mongrel.rb, line 236</span>
+236:     <span class="ruby-keyword kw">def</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">escape</span>(<span class="ruby-identifier">s</span>)
+237:       <span class="ruby-identifier">s</span>.<span class="ruby-identifier">to_s</span>.<span class="ruby-identifier">gsub</span>(<span class="ruby-regexp re">/([^ a-zA-Z0-9_.-]+)/n</span>) {
+238:         <span class="ruby-value str">'%'</span><span class="ruby-operator">+</span><span class="ruby-identifier">$1</span>.<span class="ruby-identifier">unpack</span>(<span class="ruby-value str">'H2'</span><span class="ruby-operator">*</span><span class="ruby-identifier">$1</span>.<span class="ruby-identifier">size</span>).<span class="ruby-identifier">join</span>(<span class="ruby-value str">'%'</span>).<span class="ruby-identifier">upcase</span>
+239:       }.<span class="ruby-identifier">tr</span>(<span class="ruby-value str">' '</span>, <span class="ruby-value str">'+'</span>)
+240:     <span class="ruby-keyword kw">end</span></pre>
 </body>
 </html>

data/doc/rdoc/classes/Mongrel/HttpRequest.src/{M000132.html → M000137.html} RENAMED

@@ -10,11 +10,11 @@
   <link rel="stylesheet" href="../../.././rdoc-style.css" type="text/css" media="screen" />
 </head>
 <body class="standalone-code">
-  <pre>     <span class="ruby-comment cmt"># File lib/mongrel.rb, line 243</span>
-243:     <span class="ruby-keyword kw">def</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">unescape</span>(<span class="ruby-identifier">s</span>)
-244:       <span class="ruby-identifier">s</span>.<span class="ruby-identifier">tr</span>(<span class="ruby-value str">'+'</span>, <span class="ruby-value str">' '</span>).<span class="ruby-identifier">gsub</span>(<span class="ruby-regexp re">/((?:%[0-9a-fA-F]{2})+)/n</span>){
-245:         [<span class="ruby-identifier">$1</span>.<span class="ruby-identifier">delete</span>(<span class="ruby-value str">'%'</span>)].<span class="ruby-identifier">pack</span>(<span class="ruby-value str">'H*'</span>)
-246:       }
-247:     <span class="ruby-keyword kw">end</span></pre>
+  <pre>     <span class="ruby-comment cmt"># File lib/mongrel.rb, line 244</span>
+244:     <span class="ruby-keyword kw">def</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">unescape</span>(<span class="ruby-identifier">s</span>)
+245:       <span class="ruby-identifier">s</span>.<span class="ruby-identifier">tr</span>(<span class="ruby-value str">'+'</span>, <span class="ruby-value str">' '</span>).<span class="ruby-identifier">gsub</span>(<span class="ruby-regexp re">/((?:%[0-9a-fA-F]{2})+)/n</span>){
+246:         [<span class="ruby-identifier">$1</span>.<span class="ruby-identifier">delete</span>(<span class="ruby-value str">'%'</span>)].<span class="ruby-identifier">pack</span>(<span class="ruby-value str">'H*'</span>)
+247:       }
+248:     <span class="ruby-keyword kw">end</span></pre>
 </body>
 </html>

data/doc/rdoc/classes/Mongrel/HttpRequest.src/{M000133.html → M000138.html} RENAMED

@@ -10,23 +10,23 @@
   <link rel="stylesheet" href="../../.././rdoc-style.css" type="text/css" media="screen" />
 </head>
 <body class="standalone-code">
-  <pre>     <span class="ruby-comment cmt"># File lib/mongrel.rb, line 253</span>
-253:     <span class="ruby-keyword kw">def</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">query_parse</span>(<span class="ruby-identifier">qs</span>, <span class="ruby-identifier">d</span> = <span class="ruby-value str">'&amp;;'</span>)
-254:       <span class="ruby-identifier">params</span> = {}
-255:       (<span class="ruby-identifier">qs</span><span class="ruby-operator">||</span><span class="ruby-value str">''</span>).<span class="ruby-identifier">split</span>(<span class="ruby-node">/[#{d}] */n</span>).<span class="ruby-identifier">inject</span>(<span class="ruby-identifier">params</span>) { <span class="ruby-operator">|</span><span class="ruby-identifier">h</span>,<span class="ruby-identifier">p</span><span class="ruby-operator">|</span>
-256:         <span class="ruby-identifier">k</span>, <span class="ruby-identifier">v</span>=<span class="ruby-identifier">unescape</span>(<span class="ruby-identifier">p</span>).<span class="ruby-identifier">split</span>(<span class="ruby-value str">'='</span>,<span class="ruby-value">2</span>)
-257:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">cur</span> = <span class="ruby-identifier">params</span>[<span class="ruby-identifier">k</span>]
-258:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">cur</span>.<span class="ruby-identifier">class</span> <span class="ruby-operator">==</span> <span class="ruby-constant">Array</span>
-259:             <span class="ruby-identifier">params</span>[<span class="ruby-identifier">k</span>] <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">v</span>
-260:           <span class="ruby-keyword kw">else</span>
-261:             <span class="ruby-identifier">params</span>[<span class="ruby-identifier">k</span>] = [<span class="ruby-identifier">cur</span>, <span class="ruby-identifier">v</span>]
-262:           <span class="ruby-keyword kw">end</span>
-263:         <span class="ruby-keyword kw">else</span>
-264:           <span class="ruby-identifier">params</span>[<span class="ruby-identifier">k</span>] = <span class="ruby-identifier">v</span>
-265:         <span class="ruby-keyword kw">end</span>
-266:       }
-267:
-268:       <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">params</span>
-269:     <span class="ruby-keyword kw">end</span></pre>
+  <pre>     <span class="ruby-comment cmt"># File lib/mongrel.rb, line 254</span>
+254:     <span class="ruby-keyword kw">def</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">query_parse</span>(<span class="ruby-identifier">qs</span>, <span class="ruby-identifier">d</span> = <span class="ruby-value str">'&amp;;'</span>)
+255:       <span class="ruby-identifier">params</span> = {}
+256:       (<span class="ruby-identifier">qs</span><span class="ruby-operator">||</span><span class="ruby-value str">''</span>).<span class="ruby-identifier">split</span>(<span class="ruby-node">/[#{d}] */n</span>).<span class="ruby-identifier">inject</span>(<span class="ruby-identifier">params</span>) { <span class="ruby-operator">|</span><span class="ruby-identifier">h</span>,<span class="ruby-identifier">p</span><span class="ruby-operator">|</span>
+257:         <span class="ruby-identifier">k</span>, <span class="ruby-identifier">v</span>=<span class="ruby-identifier">unescape</span>(<span class="ruby-identifier">p</span>).<span class="ruby-identifier">split</span>(<span class="ruby-value str">'='</span>,<span class="ruby-value">2</span>)
+258:         <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">cur</span> = <span class="ruby-identifier">params</span>[<span class="ruby-identifier">k</span>]
+259:           <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">cur</span>.<span class="ruby-identifier">class</span> <span class="ruby-operator">==</span> <span class="ruby-constant">Array</span>
+260:             <span class="ruby-identifier">params</span>[<span class="ruby-identifier">k</span>] <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">v</span>
+261:           <span class="ruby-keyword kw">else</span>
+262:             <span class="ruby-identifier">params</span>[<span class="ruby-identifier">k</span>] = [<span class="ruby-identifier">cur</span>, <span class="ruby-identifier">v</span>]
+263:           <span class="ruby-keyword kw">end</span>
+264:         <span class="ruby-keyword kw">else</span>
+265:           <span class="ruby-identifier">params</span>[<span class="ruby-identifier">k</span>] = <span class="ruby-identifier">v</span>
+266:         <span class="ruby-keyword kw">end</span>
+267:       }
+268:
+269:       <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">params</span>
+270:     <span class="ruby-keyword kw">end</span></pre>
 </body>
 </html>