olag 0.1.10 → 0.1.12

data/ChangeLog

@@ -1,5 +1,10 @@
+2011-08-25	Oren Ben-Kiki <github-oren@ben-kiki.org>
+
+	* Additional utilities.
+
 2011-07-24	Oren Ben-Kiki <github-oren@ben-kiki.org>
 
+	* Append rather than replace gem spec file members.
 	* Allow in_path error blocks to return a value.
 
 2011-04-22	Oren Ben-Kiki <github-oren@ben-kiki.org>

data/codnar.html

@@ -1994,7 +1994,7 @@ number of Git commits by running <tt>rake version</tt>.
 </tr>
 </table>
 <pre class='ruby code syntax'>
-  <span class="Type">VERSION</span> = <span class="Special">&quot;</span><span class="Constant">0.1.10</span><span class="Special">&quot;</span>
+  <span class="Type">VERSION</span> = <span class="Special">&quot;</span><span class="Constant">0.1.12</span><span class="Special">&quot;</span>
 
 end
 </pre>
@@ -2740,6 +2740,7 @@ Test collecting errors.
 <span class="PreProc">class</span> <span class="Type">TestCollectErrors</span> &lt; <span class="Type">Test</span>::<span class="Type">Unit</span>::<span class="Type">TestCase</span>
 
   <span class="PreProc">include</span> <span class="Type">Test</span>::<span class="Type">WithErrors</span>
+  <span class="PreProc">include</span> <span class="Type">Test</span>::<span class="Type">WithFakeFS</span>
 
   <span class="PreProc">def</span> <span class="Identifier">test_one_error</span>
     <span class="Identifier">@errors</span> &lt;&lt; <span class="Special">&quot;</span><span class="Constant">Oops</span><span class="Special">&quot;</span>
@@ -2748,22 +2749,38 @@ Test collecting errors.
 
   <span class="PreProc">def</span> <span class="Identifier">test_path_error</span>
     <span class="Identifier">@errors</span>.in_path(<span class="Special">&quot;</span><span class="Constant">foo</span><span class="Special">&quot;</span>) <span class="Statement">do</span>
-      <span class="Identifier">@errors</span> &lt;&lt; <span class="Special">&quot;</span><span class="Constant">Eeek</span><span class="Special">&quot;</span>
+      <span class="Identifier">@errors</span> &lt;&lt; <span class="Special">&quot;</span><span class="Constant">Oops</span><span class="Special">&quot;</span>
       <span class="Special">&quot;</span><span class="Constant">result</span><span class="Special">&quot;</span>
     <span class="Statement">end</span>.should == <span class="Special">&quot;</span><span class="Constant">result</span><span class="Special">&quot;</span>
-    <span class="Identifier">@errors</span> &lt;&lt; <span class="Special">&quot;</span><span class="Constant">Oops</span><span class="Special">&quot;</span>
-    <span class="Identifier">@errors</span>.should == [ <span class="Special">&quot;</span><span class="Special">#{</span><span class="Identifier">$0</span><span class="Special">}</span><span class="Constant">: Eeek in file: foo</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Special">#{</span><span class="Identifier">$0</span><span class="Special">}</span><span class="Constant">: Oops</span><span class="Special">&quot;</span> ]
+    <span class="Identifier">@errors</span>.should == [ <span class="Special">&quot;</span><span class="Special">#{</span><span class="Identifier">$0</span><span class="Special">}</span><span class="Constant">: Oops in file: foo</span><span class="Special">&quot;</span> ]
   <span class="PreProc">end</span>
 
   <span class="PreProc">def</span> <span class="Identifier">test_line_error</span>
     <span class="Identifier">@errors</span>.in_path(<span class="Special">&quot;</span><span class="Constant">foo</span><span class="Special">&quot;</span>) <span class="Statement">do</span>
       <span class="Identifier">@errors</span>.at_line(<span class="Constant">1</span>)
-      <span class="Identifier">@errors</span> &lt;&lt; <span class="Special">&quot;</span><span class="Constant">Eeek</span><span class="Special">&quot;</span>
+      <span class="Identifier">@errors</span> &lt;&lt; <span class="Special">&quot;</span><span class="Constant">Oops</span><span class="Special">&quot;</span>
     <span class="Statement">end</span>
-    <span class="Identifier">@errors</span> &lt;&lt; <span class="Special">&quot;</span><span class="Constant">Oops</span><span class="Special">&quot;</span>
-    <span class="Identifier">@errors</span>.should == [ <span class="Special">&quot;</span><span class="Special">#{</span><span class="Identifier">$0</span><span class="Special">}</span><span class="Constant">: Eeek in file: foo at line: 1</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Special">#{</span><span class="Identifier">$0</span><span class="Special">}</span><span class="Constant">: Oops</span><span class="Special">&quot;</span> ]
+    <span class="Identifier">@errors</span>.should == [ <span class="Special">&quot;</span><span class="Special">#{</span><span class="Identifier">$0</span><span class="Special">}</span><span class="Constant">: Oops in file: foo at line: 1</span><span class="Special">&quot;</span> ]
+  <span class="PreProc">end</span>
+
+  <span class="PreProc">def</span> <span class="Identifier">test_file_error</span>
+    write_fake_file(<span class="Special">&quot;</span><span class="Constant">foo</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">bar</span><span class="Special">\n</span><span class="Special">&quot;</span>)
+    <span class="Identifier">@errors</span>.in_file(<span class="Special">&quot;</span><span class="Constant">foo</span><span class="Special">&quot;</span>) <span class="Statement">do</span>
+      <span class="Identifier">@errors</span> &lt;&lt; <span class="Special">&quot;</span><span class="Constant">Oops</span><span class="Special">&quot;</span>
+      <span class="Special">&quot;</span><span class="Constant">result</span><span class="Special">&quot;</span>
+    <span class="Statement">end</span>.should == <span class="Special">&quot;</span><span class="Constant">result</span><span class="Special">&quot;</span>
+    <span class="Identifier">@errors</span>.should == [ <span class="Special">&quot;</span><span class="Special">#{</span><span class="Identifier">$0</span><span class="Special">}</span><span class="Constant">: Oops in file: foo</span><span class="Special">&quot;</span> ]
+  <span class="PreProc">end</span>
+
+  <span class="PreProc">def</span> <span class="Identifier">test_file_lines_error</span>
+    write_fake_file(<span class="Special">&quot;</span><span class="Constant">foo</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">bar</span><span class="Special">\n</span><span class="Constant">baz</span><span class="Special">\n</span><span class="Special">&quot;</span>)
+    <span class="Identifier">@errors</span>.in_file_lines(<span class="Special">&quot;</span><span class="Constant">foo</span><span class="Special">&quot;</span>) <span class="Statement">do</span> |<span class="Identifier">line</span>|
+      <span class="Identifier">@errors</span> &lt;&lt; <span class="Special">&quot;</span><span class="Constant">Oops</span><span class="Special">&quot;</span> <span class="Statement">if</span> line == <span class="Special">&quot;</span><span class="Constant">baz</span><span class="Special">\n</span><span class="Special">&quot;</span>
+    <span class="Statement">end</span>
+    <span class="Identifier">@errors</span>.should == [ <span class="Special">&quot;</span><span class="Special">#{</span><span class="Identifier">$0</span><span class="Special">}</span><span class="Constant">: Oops in file: foo at line: 2</span><span class="Special">&quot;</span> ]
   <span class="PreProc">end</span>
 
+
 <span class="PreProc">end</span>
 </pre>
 </div>
@@ -2888,6 +2905,42 @@ Collect a list of errors.
 <pre class='ruby code syntax'>
   <span class="PreProc">class</span> <span class="Type">Errors</span> &lt; <span class="Type">Array</span>
 
+</pre>
+    <table class='layout'>
+<tr>
+<td class='indentation'>
+<pre>    </pre>
+</td>
+<td class='html'>
+<div class='rdoc comment markup'>
+<p>
+The current path we are reporting errors for, if any.
+</p>
+</div>
+</td>
+</tr>
+</table>
+<pre class='ruby code syntax'>
+    <span class="Statement">attr_reader</span> <span class="Constant">:path</span>
+
+</pre>
+    <table class='layout'>
+<tr>
+<td class='indentation'>
+<pre>    </pre>
+</td>
+<td class='html'>
+<div class='rdoc comment markup'>
+<p>
+The current line number we are reporting errors for, if any.
+</p>
+</div>
+</td>
+</tr>
+</table>
+<pre class='ruby code syntax'>
+    <span class="Statement">attr_reader</span> <span class="Constant">:line_number</span>
+
 </pre>
     <table class='layout'>
 <tr>
@@ -2906,7 +2959,7 @@ Create an empty errors collection.
 <pre class='ruby code syntax'>
     <span class="PreProc">def</span> <span class="Identifier">initialize</span>
       <span class="Identifier">@path</span> = <span class="Constant">nil</span>
-      <span class="Identifier">@line</span> = <span class="Constant">nil</span>
+      <span class="Identifier">@line_number</span> = <span class="Constant">nil</span>
     <span class="PreProc">end</span>
 
 </pre>
@@ -2926,13 +2979,61 @@ Associate all errors collected by a block with a specific disk file.
 </table>
 <pre class='ruby code syntax'>
     <span class="PreProc">def</span> <span class="Identifier">in_path</span>(path, &amp;block)
-      prev_path, prev_line = <span class="Identifier">@path</span>, <span class="Identifier">@line</span>
-      <span class="Identifier">@path</span>, <span class="Identifier">@line</span> = path, <span class="Constant">nil</span>
-      result = block.call
-      <span class="Identifier">@path</span>, <span class="Identifier">@line</span> = prev_path, prev_line
+      prev_path, prev_line_number = <span class="Identifier">@path</span>, <span class="Identifier">@line_number</span>
+      <span class="Identifier">@path</span>, <span class="Identifier">@line_number</span> = path, <span class="Constant">nil</span>
+      result = block.call(path)
+      <span class="Identifier">@path</span>, <span class="Identifier">@line_number</span> = prev_path, prev_line_number
       <span class="Statement">return</span> result
     <span class="PreProc">end</span>
 
+</pre>
+    <table class='layout'>
+<tr>
+<td class='indentation'>
+<pre>    </pre>
+</td>
+<td class='html'>
+<div class='rdoc comment markup'>
+<p>
+Associate all errors collected by a block with a disk file that is opened
+and passed to the block.
+</p>
+</div>
+</td>
+</tr>
+</table>
+<pre class='ruby code syntax'>
+    <span class="PreProc">def</span> <span class="Identifier">in_file</span>(path, mode = <span class="Special">&quot;</span><span class="Constant">r</span><span class="Special">&quot;</span>, &amp;block)
+      <span class="Statement">return</span> in_path(path) { <span class="Type">File</span>.open(path, mode, &amp;block) }
+    <span class="PreProc">end</span>
+
+</pre>
+    <table class='layout'>
+<tr>
+<td class='indentation'>
+<pre>    </pre>
+</td>
+<td class='html'>
+<div class='rdoc comment markup'>
+<p>
+Associate all errors collected by a block with a line read from a disk file
+that is opened and passed to the block.
+</p>
+</div>
+</td>
+</tr>
+</table>
+<pre class='ruby code syntax'>
+    <span class="PreProc">def</span> <span class="Identifier">in_file_lines</span>(path, &amp;block)
+      in_file(path) <span class="Statement">do</span> |<span class="Identifier">file</span>|
+        <span class="Identifier">@line_number</span> = <span class="Constant">0</span>
+        file.each_line <span class="Statement">do</span> |<span class="Identifier">line</span>|
+          <span class="Identifier">@line_number</span> += <span class="Constant">1</span>
+          block.call(line)
+        <span class="Statement">end</span>
+      <span class="Statement">end</span>
+    <span class="PreProc">end</span>
+
 </pre>
     <table class='layout'>
 <tr>
@@ -2949,8 +3050,8 @@ Set the line number for any errors collected from here on.
 </tr>
 </table>
 <pre class='ruby code syntax'>
-    <span class="PreProc">def</span> <span class="Identifier">at_line</span>(line)
-      <span class="Identifier">@line</span> = line
+    <span class="PreProc">def</span> <span class="Identifier">at_line</span>(line_number)
+      <span class="Identifier">@line_number</span> = line_number
     <span class="PreProc">end</span>
 
 </pre>
@@ -2995,8 +3096,8 @@ Annotate an error message with the context (current file and line).
 <pre class='ruby code syntax'>
     <span class="PreProc">def</span> <span class="Identifier">annotate_error_message</span>(message)
       <span class="Statement">return</span> <span class="Special">&quot;</span><span class="Special">#{</span><span class="Identifier">$0</span><span class="Special">}</span><span class="Constant">: </span><span class="Special">#{</span>message<span class="Special">}</span><span class="Special">&quot;</span> <span class="Statement">unless</span> <span class="Identifier">@path</span>
-      <span class="Statement">return</span> <span class="Special">&quot;</span><span class="Special">#{</span><span class="Identifier">$0</span><span class="Special">}</span><span class="Constant">: </span><span class="Special">#{</span>message<span class="Special">}</span><span class="Constant"> in file: </span><span class="Special">#{</span><span class="Identifier">@path</span><span class="Special">}</span><span class="Special">&quot;</span> <span class="Statement">unless</span> <span class="Identifier">@line</span>
-      <span class="Statement">return</span> <span class="Special">&quot;</span><span class="Special">#{</span><span class="Identifier">$0</span><span class="Special">}</span><span class="Constant">: </span><span class="Special">#{</span>message<span class="Special">}</span><span class="Constant"> in file: </span><span class="Special">#{</span><span class="Identifier">@path</span><span class="Special">}</span><span class="Constant"> at line: </span><span class="Special">#{</span><span class="Identifier">@line</span><span class="Special">}</span><span class="Special">&quot;</span>
+      <span class="Statement">return</span> <span class="Special">&quot;</span><span class="Special">#{</span><span class="Identifier">$0</span><span class="Special">}</span><span class="Constant">: </span><span class="Special">#{</span>message<span class="Special">}</span><span class="Constant"> in file: </span><span class="Special">#{</span><span class="Identifier">@path</span><span class="Special">}</span><span class="Special">&quot;</span> <span class="Statement">unless</span> <span class="Identifier">@line_number</span>
+      <span class="Statement">return</span> <span class="Special">&quot;</span><span class="Special">#{</span><span class="Identifier">$0</span><span class="Special">}</span><span class="Constant">: </span><span class="Special">#{</span>message<span class="Special">}</span><span class="Constant"> in file: </span><span class="Special">#{</span><span class="Identifier">@path</span><span class="Special">}</span><span class="Constant"> at line: </span><span class="Special">#{</span><span class="Identifier">@line_number</span><span class="Special">}</span><span class="Special">&quot;</span>
     <span class="PreProc">end</span>
 
   end
@@ -3024,6 +3125,7 @@ when running applications inside unit tests):
 </div>
 <div class="chunk html">
 <pre class='ruby code syntax'>
+<span class="PreProc">require</span> <span class="Special">&quot;</span><span class="Constant">fileutils</span><span class="Special">&quot;</span>
 <span class="PreProc">require</span> <span class="Special">&quot;</span><span class="Constant">fakefs/safe</span><span class="Special">&quot;</span>
 
 <span class="PreProc">module</span> <span class="Type">Test</span>
@@ -3046,6 +3148,31 @@ Mix-in for tests that use the FakeFS fake file system.
 <pre class='ruby code syntax'>
   <span class="PreProc">module</span> <span class="Type">WithFakeFS</span>
 
+</pre>
+    <table class='layout'>
+<tr>
+<td class='indentation'>
+<pre>    </pre>
+</td>
+<td class='html'>
+<div class='rdoc comment markup'>
+<p>
+Create and write into a file on the fake file system.
+</p>
+</div>
+</td>
+</tr>
+</table>
+<pre class='ruby code syntax'>
+    <span class="PreProc">def</span> <span class="Identifier">write_fake_file</span>(path, content = <span class="Constant">nil</span>, &amp;block)
+      directory = <span class="Type">File</span>.dirname(path)
+      <span class="Type">FileUtils</span>.mkdir_p(directory) <span class="Statement">unless</span> <span class="Type">File</span>.exists?(directory)
+      <span class="Type">File</span>.open(path, <span class="Special">&quot;</span><span class="Constant">w</span><span class="Special">&quot;</span>) <span class="Statement">do</span> |<span class="Identifier">file</span>|
+        file.write(content) <span class="Statement">unless</span> content.nil?
+        block.call(file) <span class="Statement">unless</span> block.nil?
+      <span class="Statement">end</span>
+    <span class="PreProc">end</span>
+
 </pre>
     <table class='layout'>
 <tr>
@@ -3485,6 +3612,27 @@ Run the error application.
     <span class="Statement">super</span> { <span class="Identifier">@errors</span> &lt;&lt; <span class="Special">&quot;</span><span class="Constant">Oops!</span><span class="Special">&quot;</span> }
   <span class="PreProc">end</span>
 
+</pre>
+  <table class='layout'>
+<tr>
+<td class='indentation'>
+<pre>  </pre>
+</td>
+<td class='html'>
+<div class='rdoc comment markup'>
+<p>
+Test minimal number of arguments.
+</p>
+</div>
+</td>
+</tr>
+</table>
+<pre class='ruby code syntax'>
+  <span class="PreProc">def</span> <span class="Identifier">parse_arguments</span>
+    expect_at_least(<span class="Constant">2</span>, <span class="Special">&quot;</span><span class="Constant">fake arguments</span><span class="Special">&quot;</span>)
+    expect_at_most(<span class="Constant">3</span>, <span class="Special">&quot;</span><span class="Constant">fake arguments</span><span class="Special">&quot;</span>)
+  <span class="PreProc">end</span>
+
 end
 
 </pre>
@@ -3511,9 +3659,19 @@ Test running a Olag Application.
     <span class="Type">Olag</span>::<span class="Type">Application</span>.with_argv([]) { <span class="Type">Olag</span>::<span class="Type">Application</span>.new(<span class="Constant">true</span>).run }.should == <span class="Constant">0</span>
   <span class="PreProc">end</span>
 
+  <span class="PreProc">def</span> <span class="Identifier">test_inexact_arguments</span>
+    <span class="Type">Olag</span>::<span class="Type">Application</span>.with_argv(<span class="Special">%w(</span><span class="Constant">-e stderr foo</span><span class="Special">)</span>) { <span class="Type">Olag</span>::<span class="Type">Application</span>.new(<span class="Constant">true</span>).run }.should == <span class="Constant">1</span>
+    <span class="Type">File</span>.read(<span class="Special">&quot;</span><span class="Constant">stderr</span><span class="Special">&quot;</span>).should.include?(<span class="Special">&quot;</span><span class="Constant">Expects no arguments</span><span class="Special">&quot;</span>)
+  <span class="PreProc">end</span>
+
+  <span class="PreProc">def</span> <span class="Identifier">test_missing_arguments</span>
+    <span class="Type">Olag</span>::<span class="Type">Application</span>.with_argv(<span class="Special">%w(</span><span class="Constant">-e stderr foo</span><span class="Special">)</span>) { <span class="Type">ErrorApplication</span>.new(<span class="Constant">true</span>).run }.should == <span class="Constant">1</span>
+    <span class="Type">File</span>.read(<span class="Special">&quot;</span><span class="Constant">stderr</span><span class="Special">&quot;</span>).should.include?(<span class="Special">&quot;</span><span class="Constant">Expects at least 2 fake arguments</span><span class="Special">&quot;</span>)
+  <span class="PreProc">end</span>
+
   <span class="PreProc">def</span> <span class="Identifier">test_extra_arguments</span>
-    <span class="Type">Olag</span>::<span class="Type">Application</span>.with_argv(<span class="Special">%w(</span><span class="Constant">-e stderr dummy</span><span class="Special">)</span>) { <span class="Type">Olag</span>::<span class="Type">Application</span>.new(<span class="Constant">true</span>).run }.should == <span class="Constant">1</span>
-    <span class="Type">File</span>.read(<span class="Special">&quot;</span><span class="Constant">stderr</span><span class="Special">&quot;</span>).should.include?(<span class="Special">&quot;</span><span class="Constant">Expects no command line file arguments</span><span class="Special">&quot;</span>)
+    <span class="Type">Olag</span>::<span class="Type">Application</span>.with_argv(<span class="Special">%w(</span><span class="Constant">-e stderr foo bar baz bad</span><span class="Special">)</span>) { <span class="Type">ErrorApplication</span>.new(<span class="Constant">true</span>).run }.should == <span class="Constant">1</span>
+    <span class="Type">File</span>.read(<span class="Special">&quot;</span><span class="Constant">stderr</span><span class="Special">&quot;</span>).should.include?(<span class="Special">&quot;</span><span class="Constant">Expects at most 3 fake arguments</span><span class="Special">&quot;</span>)
   <span class="PreProc">end</span>
 
   <span class="PreProc">def</span> <span class="Identifier">test_print_version</span>
@@ -3527,7 +3685,7 @@ Test running a Olag Application.
   <span class="PreProc">end</span>
 
   <span class="PreProc">def</span> <span class="Identifier">test_print_errors</span>
-    <span class="Type">Olag</span>::<span class="Type">Application</span>.with_argv(<span class="Special">%w(</span><span class="Constant">-e stderr</span><span class="Special">)</span>) { <span class="Type">ErrorApplication</span>.new(<span class="Constant">true</span>).run }.should == <span class="Constant">1</span>
+    <span class="Type">Olag</span>::<span class="Type">Application</span>.with_argv(<span class="Special">%w(</span><span class="Constant">-e stderr foo bar</span><span class="Special">)</span>) { <span class="Type">ErrorApplication</span>.new(<span class="Constant">true</span>).run }.should == <span class="Constant">1</span>
     <span class="Type">File</span>.read(<span class="Special">&quot;</span><span class="Constant">stderr</span><span class="Special">&quot;</span>).should.include?(<span class="Special">&quot;</span><span class="Constant">Oops!</span><span class="Special">&quot;</span>)
   <span class="PreProc">end</span>
 
@@ -3671,6 +3829,90 @@ Parse the command line options of the program.
       parse_arguments
     <span class="PreProc">end</span>
 
+</pre>
+    <table class='layout'>
+<tr>
+<td class='indentation'>
+<pre>    </pre>
+</td>
+<td class='html'>
+<div class='rdoc comment markup'>
+<p>
+Expect a limited number of remaining arguments (verified by the block).
+</p>
+</div>
+</td>
+</tr>
+</table>
+<pre class='ruby code syntax'>
+    <span class="PreProc">def</span> <span class="Identifier">expect_limited_arguments</span>(message_prefix, arguments_limit, argument_type, &amp;block)
+      <span class="Statement">if</span> !<span class="Statement">yield</span>(<span class="Identifier">ARGV</span>.size)
+        <span class="Identifier">$stderr</span>.puts(<span class="Special">&quot;</span><span class="Special">#{</span><span class="Identifier">$0</span><span class="Special">}</span><span class="Constant">: </span><span class="Special">#{</span>message_prefix<span class="Special">}</span><span class="Constant"> </span><span class="Special">#{</span>arguments_limit<span class="Special">}</span><span class="Constant"> </span><span class="Special">#{</span>argument_type<span class="Special">}</span><span class="Constant">.</span><span class="Special">&quot;</span>)
+        <span class="Statement">exit</span>(<span class="Constant">1</span>)
+      <span class="Statement">end</span>
+    <span class="PreProc">end</span>
+
+</pre>
+    <table class='layout'>
+<tr>
+<td class='indentation'>
+<pre>    </pre>
+</td>
+<td class='html'>
+<div class='rdoc comment markup'>
+<p>
+Ensure we have got at least a certain number of command line arguments.
+</p>
+</div>
+</td>
+</tr>
+</table>
+<pre class='ruby code syntax'>
+    <span class="PreProc">def</span> <span class="Identifier">expect_at_least</span>(minimal_arguments, argument_type)
+      expect_limited_arguments(<span class="Special">&quot;</span><span class="Constant">Expects at least</span><span class="Special">&quot;</span>, minimal_arguments, argument_type) { |<span class="Identifier">remaining_arguments</span>| remaining_arguments &gt;= minimal_arguments }
+    <span class="PreProc">end</span>
+
+</pre>
+    <table class='layout'>
+<tr>
+<td class='indentation'>
+<pre>    </pre>
+</td>
+<td class='html'>
+<div class='rdoc comment markup'>
+<p>
+Ensure we have got at least a certain number of command line arguments.
+</p>
+</div>
+</td>
+</tr>
+</table>
+<pre class='ruby code syntax'>
+    <span class="PreProc">def</span> <span class="Identifier">expect_at_most</span>(maximal_arguments, argument_type)
+      expect_limited_arguments(<span class="Special">&quot;</span><span class="Constant">Expects at most</span><span class="Special">&quot;</span>, maximal_arguments, argument_type) { |<span class="Identifier">remaining_arguments</span>| remaining_arguments &lt;= maximal_arguments }
+    <span class="PreProc">end</span>
+
+</pre>
+    <table class='layout'>
+<tr>
+<td class='indentation'>
+<pre>    </pre>
+</td>
+<td class='html'>
+<div class='rdoc comment markup'>
+<p>
+Ensure we have got an exact number of command line arguments.
+</p>
+</div>
+</td>
+</tr>
+</table>
+<pre class='ruby code syntax'>
+    <span class="PreProc">def</span> <span class="Identifier">expect_exactly</span>(exact_arguments, argument_type)
+      arguments_limit = exact_arguments == <span class="Constant">0</span> ? <span class="Special">'</span><span class="Constant">no</span><span class="Special">'</span> : exact_arguments
+      expect_limited_arguments(<span class="Special">&quot;</span><span class="Constant">Expects</span><span class="Special">&quot;</span>, arguments_limit, argument_type) { |<span class="Identifier">remaining_arguments</span>| remaining_arguments == exact_arguments }
+    <span class="PreProc">end</span>
+
 </pre>
     <table class='layout'>
 <tr>
@@ -3690,9 +3932,7 @@ are no such arguments.
 </table>
 <pre class='ruby code syntax'>
     <span class="PreProc">def</span> <span class="Identifier">parse_arguments</span>
-      <span class="Statement">return</span> <span class="Statement">if</span> <span class="Identifier">ARGV</span>.size == <span class="Constant">0</span>
-      <span class="Identifier">$stderr</span>.puts(<span class="Special">&quot;</span><span class="Special">#{</span><span class="Identifier">$0</span><span class="Special">}</span><span class="Constant">: Expects no command line file arguments.</span><span class="Special">&quot;</span>)
-      <span class="Statement">exit</span>(<span class="Constant">1</span>)
+      expect_exactly(<span class="Constant">0</span>, <span class="Special">&quot;</span><span class="Constant">arguments</span><span class="Special">&quot;</span>)
     <span class="PreProc">end</span>
 
 </pre>

data/lib/olag/application.rb

@@ -46,13 +46,35 @@ module Olag
       parse_arguments
     end
 
+    # Expect a limited number of remaining arguments (verified by the block).
+    def expect_limited_arguments(message_prefix, arguments_limit, argument_type, &block)
+      if !yield(ARGV.size)
+        $stderr.puts("#{$0}: #{message_prefix} #{arguments_limit} #{argument_type}.")
+        exit(1)
+      end
+    end
+
+    # Ensure we have got at least a certain number of command line arguments.
+    def expect_at_least(minimal_arguments, argument_type)
+      expect_limited_arguments("Expects at least", minimal_arguments, argument_type) { |remaining_arguments| remaining_arguments >= minimal_arguments }
+    end
+
+    # Ensure we have got at least a certain number of command line arguments.
+    def expect_at_most(maximal_arguments, argument_type)
+      expect_limited_arguments("Expects at most", maximal_arguments, argument_type) { |remaining_arguments| remaining_arguments <= maximal_arguments }
+    end
+
+    # Ensure we have got an exact number of command line arguments.
+    def expect_exactly(exact_arguments, argument_type)
+      arguments_limit = exact_arguments == 0 ? 'no' : exact_arguments
+      expect_limited_arguments("Expects", arguments_limit, argument_type) { |remaining_arguments| remaining_arguments == exact_arguments }
+    end
+
     # Parse remaining command-line file arguments. This is expected to be
     # overriden by the concrete application sub-class. By default assumes there
     # are no such arguments.
     def parse_arguments
-      return if ARGV.size == 0
-      $stderr.puts("#{$0}: Expects no command line file arguments.")
-      exit(1)
+      expect_exactly(0, "arguments")
     end
 
     # Define application flags. This is expected to be overriden by the

data/lib/olag/errors.rb

@@ -3,24 +3,48 @@ module Olag
   # Collect a list of errors.
   class Errors < Array
 
+    # The current path we are reporting errors for, if any.
+    attr_reader :path
+
+    # The current line number we are reporting errors for, if any.
+    attr_reader :line_number
+
     # Create an empty errors collection.
     def initialize
       @path = nil
-      @line = nil
+      @line_number = nil
     end
 
     # Associate all errors collected by a block with a specific disk file.
     def in_path(path, &block)
-      prev_path, prev_line = @path, @line
-      @path, @line = path, nil
-      result = block.call
-      @path, @line = prev_path, prev_line
+      prev_path, prev_line_number = @path, @line_number
+      @path, @line_number = path, nil
+      result = block.call(path)
+      @path, @line_number = prev_path, prev_line_number
       return result
     end
 
+    # Associate all errors collected by a block with a disk file that is opened
+    # and passed to the block.
+    def in_file(path, mode = "r", &block)
+      return in_path(path) { File.open(path, mode, &block) }
+    end
+
+    # Associate all errors collected by a block with a line read from a disk
+    # file that is opened and passed to the block.
+    def in_file_lines(path, &block)
+      in_file(path) do |file|
+        @line_number = 0
+        file.each_line do |line|
+          @line_number += 1
+          block.call(line)
+        end
+      end
+    end
+
     # Set the line number for any errors collected from here on.
-    def at_line(line)
-      @line = line
+    def at_line(line_number)
+      @line_number = line_number
     end
 
     # Add a single error to the collection, with automatic context annotation
@@ -35,8 +59,8 @@ module Olag
     # Annotate an error message with the context (current file and line).
     def annotate_error_message(message)
       return "#{$0}: #{message}" unless @path
-      return "#{$0}: #{message} in file: #{@path}" unless @line
-      return "#{$0}: #{message} in file: #{@path} at line: #{@line}"
+      return "#{$0}: #{message} in file: #{@path}" unless @line_number
+      return "#{$0}: #{message} in file: #{@path} at line: #{@line_number}"
     end
 
   end

data/lib/olag/test/with_fakefs.rb

@@ -1,3 +1,4 @@
+require "fileutils"
 require "fakefs/safe"
 
 module Test
@@ -5,6 +6,16 @@ module Test
   # Mix-in for tests that use the FakeFS fake file system.
   module WithFakeFS
 
+    # Create and write into a file on the fake file system.
+    def write_fake_file(path, content = nil, &block)
+      directory = File.dirname(path)
+      FileUtils.mkdir_p(directory) unless File.exists?(directory)
+      File.open(path, "w") do |file|
+        file.write(content) unless content.nil?
+        block.call(file) unless block.nil?
+      end
+    end
+
     # Aliasing methods needs to be deferred to when the module is included and
     # be executed in the context of the class.
     def self.included(base)

data/lib/olag/version.rb

@@ -3,6 +3,6 @@ module Olag
 
   # This version number. The third number is automatically updated to track the
   # number of Git commits by running <tt>rake version</tt>.
-  VERSION = "0.1.10"
+  VERSION = "0.1.12"
 
 end

data/test/collect_errors.rb

@@ -6,6 +6,7 @@ require "test/spec"
 class TestCollectErrors < Test::Unit::TestCase
 
   include Test::WithErrors
+  include Test::WithFakeFS
 
   def test_one_error
     @errors << "Oops"
@@ -14,20 +15,36 @@ class TestCollectErrors < Test::Unit::TestCase
 
   def test_path_error
     @errors.in_path("foo") do
-      @errors << "Eeek"
+      @errors << "Oops"
       "result"
     end.should == "result"
-    @errors << "Oops"
-    @errors.should == [ "#{$0}: Eeek in file: foo", "#{$0}: Oops" ]
+    @errors.should == [ "#{$0}: Oops in file: foo" ]
   end
 
   def test_line_error
     @errors.in_path("foo") do
       @errors.at_line(1)
-      @errors << "Eeek"
+      @errors << "Oops"
     end
-    @errors << "Oops"
-    @errors.should == [ "#{$0}: Eeek in file: foo at line: 1", "#{$0}: Oops" ]
+    @errors.should == [ "#{$0}: Oops in file: foo at line: 1" ]
+  end
+
+  def test_file_error
+    write_fake_file("foo", "bar\n")
+    @errors.in_file("foo") do
+      @errors << "Oops"
+      "result"
+    end.should == "result"
+    @errors.should == [ "#{$0}: Oops in file: foo" ]
   end
 
+  def test_file_lines_error
+    write_fake_file("foo", "bar\nbaz\n")
+    @errors.in_file_lines("foo") do |line|
+      @errors << "Oops" if line == "baz\n"
+    end
+    @errors.should == [ "#{$0}: Oops in file: foo at line: 2" ]
+  end
+
+
 end

data/test/run_application.rb

@@ -10,6 +10,12 @@ class ErrorApplication < Olag::Application
     super { @errors << "Oops!" }
   end
 
+  # Test minimal number of arguments.
+  def parse_arguments
+    expect_at_least(2, "fake arguments")
+    expect_at_most(3, "fake arguments")
+  end
+
 end
 
 # Test running a Olag Application.
@@ -21,9 +27,19 @@ class TestRunApplication < Test::Unit::TestCase
     Olag::Application.with_argv([]) { Olag::Application.new(true).run }.should == 0
   end
 
+  def test_inexact_arguments
+    Olag::Application.with_argv(%w(-e stderr foo)) { Olag::Application.new(true).run }.should == 1
+    File.read("stderr").should.include?("Expects no arguments")
+  end
+
+  def test_missing_arguments
+    Olag::Application.with_argv(%w(-e stderr foo)) { ErrorApplication.new(true).run }.should == 1
+    File.read("stderr").should.include?("Expects at least 2 fake arguments")
+  end
+
   def test_extra_arguments
-    Olag::Application.with_argv(%w(-e stderr dummy)) { Olag::Application.new(true).run }.should == 1
-    File.read("stderr").should.include?("Expects no command line file arguments")
+    Olag::Application.with_argv(%w(-e stderr foo bar baz bad)) { ErrorApplication.new(true).run }.should == 1
+    File.read("stderr").should.include?("Expects at most 3 fake arguments")
   end
 
   def test_print_version
@@ -37,7 +53,7 @@ class TestRunApplication < Test::Unit::TestCase
   end
 
   def test_print_errors
-    Olag::Application.with_argv(%w(-e stderr)) { ErrorApplication.new(true).run }.should == 1
+    Olag::Application.with_argv(%w(-e stderr foo bar)) { ErrorApplication.new(true).run }.should == 1
     File.read("stderr").should.include?("Oops!")
   end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: olag
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 3
   prerelease: 
   segments: 
   - 0
   - 1
-  - 10
-  version: 0.1.10
+  - 12
+  version: 0.1.12
 platform: ruby
 authors: 
 - Oren Ben-Kiki
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-24 00:00:00 Z
+date: 2011-08-25 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: Saikuro
@@ -202,7 +202,7 @@ licenses: []
 post_install_message: 
 rdoc_options: 
 - --title
-- Olag 0.1.10
+- Olag 0.1.12
 - --main
 - README.rdoc
 - --line-numbers