codnar 0.1.64 → 0.1.66

data/ChangeLog

@@ -1,5 +1,10 @@
+2011-08-25	Oren Ben-Kiki <github-oren@ben-kiki.org>
+
+	* Use OLAG's additional utilities.
+
 2011-04-22	Oren Ben-Kiki <github-oren@ben-kiki.org>
 
+	* Fix homepage specification.
 	* Olag 0.1.7 and issue fixes.
 
 2011-04-19	Oren Ben-Kiki <github-oren@ben-kiki.org>

data/codnar.html

@@ -686,7 +686,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.64</span><span class="Special">&quot;</span>
+  <span class="Type">VERSION</span> = <span class="Special">&quot;</span><span class="Constant">0.1.66</span><span class="Special">&quot;</span>
 
 end
 </pre>
@@ -763,7 +763,7 @@ Test scanning classified lines.
   <span class="PreProc">include</span> <span class="Type">Test</span>::<span class="Type">WithFakeFS</span>
 
   <span class="PreProc">def</span> <span class="Identifier">test_scan_lines</span>
-    <span class="Type">File</span>.open(<span class="Special">&quot;</span><span class="Constant">comments</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">w</span><span class="Special">&quot;</span>) { |<span class="Identifier">file</span>| file.write(<span class="Type">INPUT</span>) }
+    write_fake_file(<span class="Special">&quot;</span><span class="Constant">comments</span><span class="Special">&quot;</span>, <span class="Type">INPUT</span>)
     scanner = <span class="Type">Codnar</span>::<span class="Type">Scanner</span>.new(<span class="Identifier">@errors</span>, <span class="Type">SYNTAX</span>)
     scanner.lines(<span class="Special">&quot;</span><span class="Constant">comments</span><span class="Special">&quot;</span>).should == <span class="Type">LINES</span>
     <span class="Identifier">@errors</span>.should == <span class="Type">ERRORS</span>
@@ -1001,7 +1001,7 @@ follows:
       <span class="Identifier">@path</span> = path
       <span class="Identifier">@lines</span> = []
       <span class="Identifier">@state</span> = <span class="Identifier">@syntax</span>.start_state
-      <span class="Identifier">@errors</span>.in_path(path) { scan_path }
+      <span class="Identifier">@errors</span>.in_file_lines(path) { |<span class="Identifier">line</span>| scan_line(line.chomp) }
       <span class="Statement">return</span> <span class="Identifier">@lines</span>
     <span class="PreProc">end</span>
 
@@ -1318,52 +1318,6 @@ state transitions to each line:
 <div class="chunk html">
 <pre class='ruby code syntax'>
 
-</pre>
-<table class='layout'>
-<tr>
-<td class='indentation'>
-<pre></pre>
-</td>
-<td class='html'>
-<div class='rdoc comment markup'>
-<p>
-Scan a disk file.
-</p>
-</div>
-</td>
-</tr>
-</table>
-<pre class='ruby code syntax'>
-<span class="PreProc">def</span> <span class="Identifier">scan_path</span>
-  <span class="Type">File</span>.open(<span class="Identifier">@path</span>, <span class="Special">&quot;</span><span class="Constant">r</span><span class="Special">&quot;</span>) <span class="Statement">do</span> |<span class="Identifier">file</span>|
-    scan_file(file)
-  <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>
-Scan an opened file.
-</p>
-</div>
-</td>
-</tr>
-</table>
-<pre class='ruby code syntax'>
-<span class="PreProc">def</span> <span class="Identifier">scan_file</span>(file)
-  <span class="Identifier">@line_number</span> = <span class="Constant">0</span>
-  file.read.each_line <span class="Statement">do</span> |<span class="Identifier">line</span>|
-    <span class="Identifier">@errors</span>.at_line(<span class="Identifier">@line_number</span> += <span class="Constant">1</span>)
-    scan_line(line.chomp)
-  <span class="Statement">end</span>
-<span class="PreProc">end</span>
-
 </pre>
 <table class='layout'>
 <tr>
@@ -1435,7 +1389,7 @@ Handle a file line, only if it matches the pattern.
   <span class="Identifier">@lines</span> &lt;&lt; <span class="Type">Scanner</span>.extracted_groups(match, pattern.groups).update({
     <span class="Special">&quot;</span><span class="Constant">line</span><span class="Special">&quot;</span> =&gt; line,
     <span class="Special">&quot;</span><span class="Constant">kind</span><span class="Special">&quot;</span> =&gt; transition.kind,
-    <span class="Special">&quot;</span><span class="Constant">number</span><span class="Special">&quot;</span> =&gt; <span class="Identifier">@line_number</span>
+    <span class="Special">&quot;</span><span class="Constant">number</span><span class="Special">&quot;</span> =&gt; <span class="Identifier">@errors</span>.line_number
   })
   <span class="Identifier">@state</span> = transition.next_state
   <span class="Statement">return</span> <span class="Constant">true</span>
@@ -1490,7 +1444,7 @@ Handle a file line that couldn’t be classified.
     <span class="Special">&quot;</span><span class="Constant">payload</span><span class="Special">&quot;</span> =&gt; line.unindent,
     <span class="Special">&quot;</span><span class="Constant">kind</span><span class="Special">&quot;</span> =&gt; <span class="Special">&quot;</span><span class="Constant">error</span><span class="Special">&quot;</span>,
     <span class="Special">&quot;</span><span class="Constant">state</span><span class="Special">&quot;</span> =&gt; state_name,
-    <span class="Special">&quot;</span><span class="Constant">number</span><span class="Special">&quot;</span> =&gt; <span class="Identifier">@line_number</span>
+    <span class="Special">&quot;</span><span class="Constant">number</span><span class="Special">&quot;</span> =&gt; <span class="Identifier">@errors</span>.line_number
   }
   <span class="Identifier">@errors</span> &lt;&lt; <span class="Special">&quot;</span><span class="Constant">State: </span><span class="Special">#{</span>state_name<span class="Special">}</span><span class="Constant"> failed to classify line: </span><span class="Special">#{</span><span class="Identifier">@lines</span>.last.payload<span class="Special">}</span><span class="Special">&quot;</span>
 <span class="PreProc">end</span>
@@ -4368,7 +4322,7 @@ Test “splitting” documentation files.
   <span class="PreProc">include</span> <span class="Type">Test</span>::<span class="Type">WithFakeFS</span>
 
   <span class="PreProc">def</span> <span class="Identifier">test_split_raw</span>
-    <span class="Type">File</span>.open(<span class="Special">&quot;</span><span class="Constant">raw.html</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">w</span><span class="Special">&quot;</span>) { |<span class="Identifier">file</span>| file.write(<span class="Special">&quot;</span><span class="Constant">&lt;foo&gt;</span><span class="Special">\n</span><span class="Constant">bar</span><span class="Special">\n</span><span class="Constant">&lt;/foo&gt;</span><span class="Special">\n</span><span class="Special">&quot;</span>) }
+    write_fake_file(<span class="Special">&quot;</span><span class="Constant">raw.html</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">&lt;foo&gt;</span><span class="Special">\n</span><span class="Constant">bar</span><span class="Special">\n</span><span class="Constant">&lt;/foo&gt;</span><span class="Special">\n</span><span class="Special">&quot;</span>)
     splitter = <span class="Type">Codnar</span>::<span class="Type">Splitter</span>.new(<span class="Identifier">@errors</span>, configuration(<span class="Special">&quot;</span><span class="Constant">html</span><span class="Special">&quot;</span>))
     chunks = splitter.chunks(<span class="Special">&quot;</span><span class="Constant">raw.html</span><span class="Special">&quot;</span>)
     <span class="Identifier">@errors</span>.should == []
@@ -4382,7 +4336,7 @@ Test “splitting” documentation files.
   <span class="PreProc">end</span>
 
   <span class="PreProc">def</span> <span class="Identifier">test_split_markdown</span>
-    <span class="Type">File</span>.open(<span class="Special">&quot;</span><span class="Constant">markdown.md</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">w</span><span class="Special">&quot;</span>) { |<span class="Identifier">file</span>| file.write(<span class="Special">&quot;</span><span class="Constant">*foo*</span><span class="Special">\n</span><span class="Constant">bar</span><span class="Special">\n</span><span class="Special">&quot;</span>) }
+    write_fake_file(<span class="Special">&quot;</span><span class="Constant">markdown.md</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">*foo*</span><span class="Special">\n</span><span class="Constant">bar</span><span class="Special">\n</span><span class="Special">&quot;</span>)
     splitter = <span class="Type">Codnar</span>::<span class="Type">Splitter</span>.new(<span class="Identifier">@errors</span>, configuration(<span class="Special">&quot;</span><span class="Constant">markdown</span><span class="Special">&quot;</span>))
     chunks = splitter.chunks(<span class="Special">&quot;</span><span class="Constant">markdown.md</span><span class="Special">&quot;</span>)
     <span class="Identifier">@errors</span>.should == []
@@ -4396,7 +4350,7 @@ Test “splitting” documentation files.
   <span class="PreProc">end</span>
 
   <span class="PreProc">def</span> <span class="Identifier">test_split_rdoc</span>
-    <span class="Type">File</span>.open(<span class="Special">&quot;</span><span class="Constant">rdoc.rdoc</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">w</span><span class="Special">&quot;</span>) { |<span class="Identifier">file</span>| file.write(<span class="Special">&quot;</span><span class="Constant">*foo*</span><span class="Special">\n</span><span class="Constant">bar</span><span class="Special">\n</span><span class="Special">&quot;</span>) }
+    write_fake_file(<span class="Special">&quot;</span><span class="Constant">rdoc.rdoc</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">*foo*</span><span class="Special">\n</span><span class="Constant">bar</span><span class="Special">\n</span><span class="Special">&quot;</span>)
     splitter = <span class="Type">Codnar</span>::<span class="Type">Splitter</span>.new(<span class="Identifier">@errors</span>, configuration(<span class="Special">&quot;</span><span class="Constant">rdoc</span><span class="Special">&quot;</span>))
     chunks = splitter.chunks(<span class="Special">&quot;</span><span class="Constant">rdoc.rdoc</span><span class="Special">&quot;</span>)
     <span class="Identifier">@errors</span>.should == []
@@ -4410,7 +4364,7 @@ Test “splitting” documentation files.
   <span class="PreProc">end</span>
 
   <span class="PreProc">def</span> <span class="Identifier">test_split_unknown_kind</span>
-    <span class="Type">File</span>.open(<span class="Special">&quot;</span><span class="Constant">unknown.kind</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">w</span><span class="Special">&quot;</span>) { |<span class="Identifier">file</span>| file.write(<span class="Special">&quot;</span><span class="Constant">foo</span><span class="Special">\n</span><span class="Constant">bar</span><span class="Special">\n</span><span class="Special">&quot;</span>) }
+    write_fake_file(<span class="Special">&quot;</span><span class="Constant">unknown.kind</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">foo</span><span class="Special">\n</span><span class="Constant">bar</span><span class="Special">\n</span><span class="Special">&quot;</span>)
     splitter = <span class="Type">Codnar</span>::<span class="Type">Splitter</span>.new(<span class="Identifier">@errors</span>, configuration(<span class="Special">&quot;</span><span class="Constant">unknown-kind</span><span class="Special">&quot;</span>))
     chunks = splitter.chunks(<span class="Special">&quot;</span><span class="Constant">unknown.kind</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">: No formatter specified for lines of kind: unknown-kind</span><span class="Special">&quot;</span> ]
@@ -7123,10 +7077,9 @@ Test reading chunks from files.
   <span class="PreProc">end</span>
 
   <span class="PreProc">def</span> <span class="Identifier">test_read_invalid_chunks</span>
-    file_path = <span class="Constant">nil</span>
-    <span class="Type">File</span>.open(<span class="Special">&quot;</span><span class="Constant">foo.chunks</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">w</span><span class="Special">&quot;</span>) { |<span class="Identifier">file</span>| file_path = <span class="Type">File</span>.expand_path(file.path) }
+    write_fake_file(<span class="Special">&quot;</span><span class="Constant">foo.chunks</span><span class="Special">&quot;</span>)
     reader = <span class="Type">Codnar</span>::<span class="Type">Reader</span>.new(<span class="Identifier">@errors</span>, <span class="Type">Dir</span>.glob(<span class="Special">&quot;</span><span class="Constant">./**/*.chunks</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">: Invalid chunks data in file: </span><span class="Special">#{</span>file_path<span class="Special">}</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">: Invalid chunks data in file: </span><span class="Special">#{</span><span class="Type">File</span>.expand_path(<span class="Special">&quot;</span><span class="Constant">foo.chunks</span><span class="Special">&quot;</span>)<span class="Special">}</span><span class="Special">&quot;</span> ]
   <span class="PreProc">end</span>
 
   <span class="PreProc">def</span> <span class="Identifier">test_read_unused_chunks</span>
@@ -7627,7 +7580,7 @@ Test the built-in weave configurations.
 <span class="Constant">        &lt;embed src=&quot;path&quot; type=&quot;x-codnar/file&quot;/&gt;</span>
 <span class="Constant">      </span><span class="Special">EOF</span>
     })
-    <span class="Type">File</span>.open(<span class="Special">&quot;</span><span class="Constant">path</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">w</span><span class="Special">&quot;</span>) { |<span class="Identifier">file</span>| file.puts(<span class="Special">&quot;</span><span class="Constant">&lt;h2&gt;File&lt;/h2&gt;</span><span class="Special">&quot;</span>) }
+    write_fake_file(<span class="Special">&quot;</span><span class="Constant">path</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">&lt;h2&gt;File&lt;/h2&gt;</span><span class="Special">\n</span><span class="Special">&quot;</span>)
     html = <span class="Type">Codnar</span>::<span class="Type">Weaver</span>.new(<span class="Identifier">@errors</span>, [ <span class="Special">&quot;</span><span class="Constant">chunks</span><span class="Special">&quot;</span> ], <span class="Type">Codnar</span>::<span class="Type">Configuration</span>::<span class="Type">WEAVE_INCLUDE</span>).weave(<span class="Special">&quot;</span><span class="Constant">include</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">top</span><span class="Special">&quot;</span>)
     <span class="Identifier">@errors</span>.should == []
     html.should == &lt;&lt;-<span class="Special">EOF</span>.unindent
@@ -8526,7 +8479,7 @@ Test running a Codnar Application.
     }
 
     <span class="PreProc">def</span> <span class="Identifier">test_merge_configurations</span>
-      <span class="Type">File</span>.open(<span class="Special">&quot;</span><span class="Constant">user_configuration.yaml</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">w</span><span class="Special">&quot;</span>) { |<span class="Identifier">file</span>| file.print(<span class="Type">USER_CONFIGURATION</span>.to_yaml) }
+      write_fake_file(<span class="Special">&quot;</span><span class="Constant">user_configuration.yaml</span><span class="Special">&quot;</span>, <span class="Type">USER_CONFIGURATION</span>.to_yaml)
       <span class="Type">Codnar</span>::<span class="Type">Application</span>.with_argv(<span class="Special">%w(</span><span class="Constant">-o stdout -c split_pre_documentation -c user_configuration.yaml -p</span><span class="Special">)</span>) { <span class="Type">Codnar</span>::<span class="Type">Application</span>.new(<span class="Constant">true</span>).run }.should == <span class="Constant">0</span>
       <span class="Type">YAML</span>.load_file(<span class="Special">&quot;</span><span class="Constant">stdout</span><span class="Special">&quot;</span>).should == <span class="Type">Codnar</span>::<span class="Type">Configuration</span>::<span class="Type">SPLIT_PRE_DOCUMENTATION</span>.deep_merge(<span class="Type">USER_CONFIGURATION</span>)
     <span class="PreProc">end</span>
@@ -8540,7 +8493,7 @@ Test running a Codnar Application.
     <span class="PreProc">def</span> <span class="Identifier">test_require_module</span>
       <span class="Type">FakeFS</span>.deactivate! <span class="Comment"># The additional_module is read by Ruby and is not affected by FakeFS.</span>
       directory = create_tempdir
-      <span class="Type">File</span>.open(directory + <span class="Special">&quot;</span><span class="Constant">/additional_module.rb</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">w</span><span class="Special">&quot;</span>) { |<span class="Identifier">file</span>| file.puts(<span class="Special">&quot;</span><span class="Constant">puts 'HERE'</span><span class="Special">&quot;</span>) }
+      write_fake_file(directory + <span class="Special">&quot;</span><span class="Constant">/additional_module.rb</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">puts 'HERE'</span><span class="Special">\n</span><span class="Special">&quot;</span>)
       <span class="Type">Application</span>.with_argv([<span class="Special">&quot;</span><span class="Constant">-o</span><span class="Special">&quot;</span>, stdout = directory + <span class="Special">&quot;</span><span class="Constant">/stdout</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">-I</span><span class="Special">&quot;</span>, directory, <span class="Special">&quot;</span><span class="Constant">-r</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">additional_module</span><span class="Special">&quot;</span> ]) { <span class="Type">Codnar</span>::<span class="Type">Application</span>.new(<span class="Constant">true</span>).run }.should == <span class="Constant">0</span>
       <span class="Type">File</span>.read(stdout).should == <span class="Special">&quot;</span><span class="Constant">HERE</span><span class="Special">\n</span><span class="Special">&quot;</span>
     <span class="PreProc">end</span>
@@ -8875,7 +8828,7 @@ Test running the Split Codnar Application.
   <span class="PreProc">end</span>
 
   <span class="PreProc">def</span> <span class="Identifier">test_run_split</span>
-    <span class="Type">File</span>.open(<span class="Special">&quot;</span><span class="Constant">input</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">w</span><span class="Special">&quot;</span>) { |<span class="Identifier">file</span>| file.puts(<span class="Special">&quot;</span><span class="Constant">&lt;foo&gt;</span><span class="Special">&quot;</span>) }
+    write_fake_file(<span class="Special">&quot;</span><span class="Constant">input</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">&lt;foo&gt;</span><span class="Special">\n</span><span class="Special">&quot;</span>)
     <span class="Type">Codnar</span>::<span class="Type">Application</span>.with_argv(<span class="Special">%w(</span><span class="Constant">-o stdout input</span><span class="Special">)</span>) { <span class="Type">Codnar</span>::<span class="Type">Split</span>.new(<span class="Constant">true</span>).run }.should == <span class="Constant">0</span>
     <span class="Type">YAML</span>.load_file(<span class="Special">&quot;</span><span class="Constant">stdout</span><span class="Special">&quot;</span>).should == [ {
       <span class="Special">&quot;</span><span class="Constant">name</span><span class="Special">&quot;</span> =&gt; <span class="Special">&quot;</span><span class="Constant">input</span><span class="Special">&quot;</span>,
@@ -8886,16 +8839,6 @@ Test running the Split Codnar Application.
     } ]
   <span class="PreProc">end</span>
 
-  <span class="PreProc">def</span> <span class="Identifier">test_run_split_no_file</span>
-    <span class="Type">Codnar</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">Codnar</span>::<span class="Type">Split</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 == <span class="Special">&quot;</span><span class="Special">#{</span><span class="Identifier">$0</span><span class="Special">}</span><span class="Constant">: No input file to split</span><span class="Special">\n</span><span class="Special">&quot;</span>
-  <span class="PreProc">end</span>
-
-  <span class="PreProc">def</span> <span class="Identifier">test_run_split_many_file</span>
-    <span class="Type">Codnar</span>::<span class="Type">Application</span>.with_argv(<span class="Special">%w(</span><span class="Constant">-e stderr one two</span><span class="Special">)</span>) { <span class="Type">Codnar</span>::<span class="Type">Split</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 == <span class="Special">&quot;</span><span class="Special">#{</span><span class="Identifier">$0</span><span class="Special">}</span><span class="Constant">: Too many input files to split</span><span class="Special">\n</span><span class="Special">&quot;</span>
-  <span class="PreProc">end</span>
-
 <span class="PreProc">end</span>
 </pre>
 </div>
@@ -8994,12 +8937,7 @@ Parse remaining command-line file arguments.
 </table>
 <pre class='ruby code syntax'>
     <span class="PreProc">def</span> <span class="Identifier">parse_arguments</span>
-      <span class="Statement">case</span> <span class="Identifier">ARGV</span>.size
-      <span class="Statement">when</span> <span class="Constant">1</span> <span class="Statement">then</span> <span class="Statement">return</span>
-      <span class="Statement">when</span> <span class="Constant">0</span> <span class="Statement">then</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">: No input file to split</span><span class="Special">&quot;</span>)
-      <span class="Statement">else</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">: Too many input files to split</span><span class="Special">&quot;</span>)
-      <span class="Statement">end</span>
-      <span class="Statement">exit</span>(<span class="Constant">1</span>)
+      expect_exactly(<span class="Constant">1</span>, <span class="Special">&quot;</span><span class="Constant">files to split</span><span class="Special">&quot;</span>)
     <span class="PreProc">end</span>
 
 </pre>
@@ -9158,30 +9096,25 @@ Test running the Weave Codnar Application.
   } ]
 
   <span class="PreProc">def</span> <span class="Identifier">test_run_weave</span>
-    <span class="Type">File</span>.open(<span class="Special">&quot;</span><span class="Constant">root</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">w</span><span class="Special">&quot;</span>) { |<span class="Identifier">file</span>| file.write(<span class="Type">ROOT_CHUNKS</span>.to_yaml) }
-    <span class="Type">File</span>.open(<span class="Special">&quot;</span><span class="Constant">included</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">w</span><span class="Special">&quot;</span>) { |<span class="Identifier">file</span>| file.write(<span class="Type">INCLUDED_CHUNKS</span>.to_yaml) }
+    write_fake_file(<span class="Special">&quot;</span><span class="Constant">root</span><span class="Special">&quot;</span>, <span class="Type">ROOT_CHUNKS</span>.to_yaml)
+    write_fake_file(<span class="Special">&quot;</span><span class="Constant">included</span><span class="Special">&quot;</span>, <span class="Type">INCLUDED_CHUNKS</span>.to_yaml)
     <span class="Type">Codnar</span>::<span class="Type">Application</span>.with_argv(<span class="Special">%w(</span><span class="Constant">-o stdout root included</span><span class="Special">)</span>) { <span class="Type">Codnar</span>::<span class="Type">Weave</span>.new(<span class="Constant">true</span>).run }.should == <span class="Constant">0</span>
     <span class="Type">File</span>.read(<span class="Special">&quot;</span><span class="Constant">stdout</span><span class="Special">&quot;</span>).should == <span class="Special">&quot;</span><span class="Constant">Root</span><span class="Special">\n</span><span class="Constant">Included</span><span class="Special">\n</span><span class="Special">&quot;</span>
   <span class="PreProc">end</span>
 
   <span class="PreProc">def</span> <span class="Identifier">test_run_weave_missing_chunk</span>
-    <span class="Type">File</span>.open(<span class="Special">&quot;</span><span class="Constant">root</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">w</span><span class="Special">&quot;</span>) { |<span class="Identifier">file</span>| file.write(<span class="Type">ROOT_CHUNKS</span>.to_yaml) }
+    write_fake_file(<span class="Special">&quot;</span><span class="Constant">root</span><span class="Special">&quot;</span>, <span class="Type">ROOT_CHUNKS</span>.to_yaml)
     <span class="Type">Codnar</span>::<span class="Type">Application</span>.with_argv(<span class="Special">%w(</span><span class="Constant">-e stderr -o stdout root</span><span class="Special">)</span>) { <span class="Type">Codnar</span>::<span class="Type">Weave</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 == <span class="Special">&quot;</span><span class="Special">#{</span><span class="Identifier">$0</span><span class="Special">}</span><span class="Constant">: Missing chunk: included in file: root</span><span class="Special">\n</span><span class="Special">&quot;</span>
   <span class="PreProc">end</span>
 
   <span class="PreProc">def</span> <span class="Identifier">test_run_weave_unused_chunk</span>
-    <span class="Type">File</span>.open(<span class="Special">&quot;</span><span class="Constant">root</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">w</span><span class="Special">&quot;</span>) { |<span class="Identifier">file</span>| file.write(<span class="Type">ROOT_CHUNKS</span>.to_yaml) }
-    <span class="Type">File</span>.open(<span class="Special">&quot;</span><span class="Constant">included</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">w</span><span class="Special">&quot;</span>) { |<span class="Identifier">file</span>| file.write(<span class="Type">INCLUDED_CHUNKS</span>.to_yaml) }
+    write_fake_file(<span class="Special">&quot;</span><span class="Constant">root</span><span class="Special">&quot;</span>, <span class="Type">ROOT_CHUNKS</span>.to_yaml)
+    write_fake_file(<span class="Special">&quot;</span><span class="Constant">included</span><span class="Special">&quot;</span>, <span class="Type">INCLUDED_CHUNKS</span>.to_yaml)
     <span class="Type">Codnar</span>::<span class="Type">Application</span>.with_argv(<span class="Special">%w(</span><span class="Constant">-e stderr -o stdout included root</span><span class="Special">)</span>) { <span class="Type">Codnar</span>::<span class="Type">Weave</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 == <span class="Special">&quot;</span><span class="Special">#{</span><span class="Identifier">$0</span><span class="Special">}</span><span class="Constant">: Unused chunk: root in file: root at line: 1</span><span class="Special">\n</span><span class="Special">&quot;</span>
   <span class="PreProc">end</span>
 
-  <span class="PreProc">def</span> <span class="Identifier">test_run_weave_no_chunks</span>
-    <span class="Type">Codnar</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">Codnar</span>::<span class="Type">Weave</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 == <span class="Special">&quot;</span><span class="Special">#{</span><span class="Identifier">$0</span><span class="Special">}</span><span class="Constant">: No chunk files to weave</span><span class="Special">\n</span><span class="Special">&quot;</span>
-  <span class="PreProc">end</span>
-
   <span class="Type">FILE_CHUNKS</span> = [ {
     <span class="Special">&quot;</span><span class="Constant">name</span><span class="Special">&quot;</span> =&gt; <span class="Special">&quot;</span><span class="Constant">root</span><span class="Special">&quot;</span>,
     <span class="Special">&quot;</span><span class="Constant">locations</span><span class="Special">&quot;</span> =&gt; [ { <span class="Special">&quot;</span><span class="Constant">file</span><span class="Special">&quot;</span> =&gt; <span class="Special">&quot;</span><span class="Constant">root</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">line</span><span class="Special">&quot;</span> =&gt; <span class="Constant">1</span> } ],
@@ -9189,7 +9122,7 @@ Test running the Weave Codnar Application.
   } ]
 
   <span class="PreProc">def</span> <span class="Identifier">test_run_weave_missing_file</span>
-    <span class="Type">File</span>.open(<span class="Special">&quot;</span><span class="Constant">root</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">w</span><span class="Special">&quot;</span>) { |<span class="Identifier">file</span>| file.write(<span class="Type">FILE_CHUNKS</span>.to_yaml) }
+    write_fake_file(<span class="Special">&quot;</span><span class="Constant">root</span><span class="Special">&quot;</span>, <span class="Type">FILE_CHUNKS</span>.to_yaml)
     <span class="Type">Codnar</span>::<span class="Type">Application</span>.with_argv(<span class="Special">%w(</span><span class="Constant">-e stderr -o stdout root</span><span class="Special">)</span>) { <span class="Type">Codnar</span>::<span class="Type">Weave</span>.new(<span class="Constant">true</span>).run }.should == <span class="Constant">1</span>
     double_message = <span class="Special">&quot;</span><span class="Constant">No such file or directory - </span><span class="Special">&quot;</span> * <span class="Constant">2</span> <span class="Comment"># Something weird in Ruby Exception.to_s</span>
     <span class="Type">File</span>.read(<span class="Special">&quot;</span><span class="Constant">stdout</span><span class="Special">&quot;</span>).should == <span class="Special">&quot;</span><span class="Constant">Root</span><span class="Special">\n</span><span class="Constant">FILE: included.file EXCEPTION: </span><span class="Special">#{</span>double_message<span class="Special">}</span><span class="Special">\n</span><span class="Special">&quot;</span>
@@ -9198,8 +9131,8 @@ Test running the Weave Codnar Application.
   <span class="PreProc">end</span>
 
   <span class="PreProc">def</span> <span class="Identifier">test_run_weave_existing_file</span>
-    <span class="Type">File</span>.open(<span class="Special">&quot;</span><span class="Constant">root</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">w</span><span class="Special">&quot;</span>) { |<span class="Identifier">file</span>| file.write(<span class="Type">FILE_CHUNKS</span>.to_yaml) }
-    <span class="Type">File</span>.open(<span class="Special">&quot;</span><span class="Constant">included.file</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">w</span><span class="Special">&quot;</span>) { |<span class="Identifier">file</span>| file.write(<span class="Special">&quot;</span><span class="Constant">included file</span><span class="Special">\n</span><span class="Special">&quot;</span>) }
+    write_fake_file(<span class="Special">&quot;</span><span class="Constant">root</span><span class="Special">&quot;</span>, <span class="Type">FILE_CHUNKS</span>.to_yaml)
+    write_fake_file(<span class="Special">&quot;</span><span class="Constant">included.file</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">included file</span><span class="Special">\n</span><span class="Special">&quot;</span>)
     <span class="Type">Codnar</span>::<span class="Type">Application</span>.with_argv(<span class="Special">%w(</span><span class="Constant">-e stderr -o stdout root</span><span class="Special">)</span>) { <span class="Type">Codnar</span>::<span class="Type">Weave</span>.new(<span class="Constant">true</span>).run }.should == <span class="Constant">0</span>
     <span class="Type">File</span>.read(<span class="Special">&quot;</span><span class="Constant">stdout</span><span class="Special">&quot;</span>).should == <span class="Special">&quot;</span><span class="Constant">Root</span><span class="Special">\n</span><span class="Constant">included file</span><span class="Special">\n</span><span class="Special">&quot;</span>
   <span class="PreProc">end</span>
@@ -9303,9 +9236,7 @@ Parse remaining command-line file 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 &gt; <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">: No chunk files to weave</span><span class="Special">&quot;</span>)
-      <span class="Statement">exit</span>(<span class="Constant">1</span>)
+      expect_at_least(<span class="Constant">1</span>, <span class="Special">&quot;</span><span class="Constant">chunk files to weave</span><span class="Special">&quot;</span>)
     <span class="PreProc">end</span>
 
 </pre>
@@ -9457,7 +9388,7 @@ Test rake tasks.
 <span class="Statement">protected</span>
 
   <span class="PreProc">def</span> <span class="Identifier">run_rake</span>
-    <span class="Type">File</span>.open(<span class="Special">&quot;</span><span class="Constant">foo</span><span class="Special">&quot;</span>, <span class="Special">&quot;</span><span class="Constant">w</span><span class="Special">&quot;</span>) { |<span class="Identifier">file</span>| file.puts(<span class="Special">&quot;</span><span class="Constant">foo</span><span class="Special">&quot;</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">foo</span><span class="Special">\n</span><span class="Special">&quot;</span>)
     <span class="Type">Codnar</span>::<span class="Type">Rake</span>::<span class="Type">SplitTask</span>.new([ <span class="Special">&quot;</span><span class="Constant">foo</span><span class="Special">&quot;</span> ], [])
     <span class="Type">Codnar</span>::<span class="Type">Rake</span>::<span class="Type">WeaveTask</span>.new(<span class="Special">&quot;</span><span class="Constant">foo</span><span class="Special">&quot;</span>, [])
     <span class="Identifier">@rake</span>[<span class="Special">&quot;</span><span class="Constant">codnar</span><span class="Special">&quot;</span>].invoke

data/lib/codnar/scanner.rb

@@ -77,7 +77,7 @@ module Codnar
       @path = path
       @lines = []
       @state = @syntax.start_state
-      @errors.in_path(path) { scan_path }
+      @errors.in_file_lines(path) { |line| scan_line(line.chomp) }
       return @lines
     end
 
@@ -144,22 +144,6 @@ module Codnar
 
     # {{{ Scanner file processing
 
-    # Scan a disk file.
-    def scan_path
-      File.open(@path, "r") do |file|
-        scan_file(file)
-      end
-    end
-
-    # Scan an opened file.
-    def scan_file(file)
-      @line_number = 0
-      file.read.each_line do |line|
-        @errors.at_line(@line_number += 1)
-        scan_line(line.chomp)
-      end
-    end
-
     # Scan the next file line.
     def scan_line(line)
       @state.transitions.each do |transition|
@@ -179,7 +163,7 @@ module Codnar
       @lines << Scanner.extracted_groups(match, pattern.groups).update({
         "line" => line,
         "kind" => transition.kind,
-        "number" => @line_number
+        "number" => @errors.line_number
       })
       @state = transition.next_state
       return true
@@ -204,7 +188,7 @@ module Codnar
         "payload" => line.unindent,
         "kind" => "error",
         "state" => state_name,
-        "number" => @line_number
+        "number" => @errors.line_number
       }
       @errors << "State: #{state_name} failed to classify line: #{@lines.last.payload}"
     end

data/lib/codnar/split.rb

@@ -19,12 +19,7 @@ module Codnar
 
     # Parse remaining command-line file arguments.
     def parse_arguments
-      case ARGV.size
-      when 1 then return
-      when 0 then $stderr.puts("#{$0}: No input file to split")
-      else $stderr.puts("#{$0}: Too many input files to split")
-      end
-      exit(1)
+      expect_exactly(1, "files to split")
     end
 
     # Return the banner line of the help message.

data/lib/codnar/version.rb

@@ -3,6 +3,6 @@ module Codnar
 
   # 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.64"
+  VERSION = "0.1.66"
 
 end

data/lib/codnar/weave.rb

@@ -20,9 +20,7 @@ module Codnar
 
     # Parse remaining command-line file arguments.
     def parse_arguments
-      return if ARGV.size > 0
-      $stderr.puts("#{$0}: No chunk files to weave")
-      exit(1)
+      expect_at_least(1, "chunk files to weave")
     end
 
     # Return the banner line of the help message.

data/test/rake_tasks.rb

@@ -16,7 +16,7 @@ class TestRakeTasks < Test::Unit::TestCase
 protected
 
   def run_rake
-    File.open("foo", "w") { |file| file.puts("foo") }
+    write_fake_file("foo", "foo\n")
     Codnar::Rake::SplitTask.new([ "foo" ], [])
     Codnar::Rake::WeaveTask.new("foo", [])
     @rake["codnar"].invoke

data/test/read_chunks.rb

@@ -19,10 +19,9 @@ class TestReadChunks < Test::Unit::TestCase
   end
 
   def test_read_invalid_chunks
-    file_path = nil
-    File.open("foo.chunks", "w") { |file| file_path = File.expand_path(file.path) }
+    write_fake_file("foo.chunks")
     reader = Codnar::Reader.new(@errors, Dir.glob("./**/*.chunks"))
-    @errors.should == [ "#{$0}: Invalid chunks data in file: #{file_path}" ]
+    @errors.should == [ "#{$0}: Invalid chunks data in file: #{File.expand_path("foo.chunks")}" ]
   end
 
   def test_read_unused_chunks

data/test/run_application.rb

@@ -27,7 +27,7 @@ module Codnar
     }
 
     def test_merge_configurations
-      File.open("user_configuration.yaml", "w") { |file| file.print(USER_CONFIGURATION.to_yaml) }
+      write_fake_file("user_configuration.yaml", USER_CONFIGURATION.to_yaml)
       Codnar::Application.with_argv(%w(-o stdout -c split_pre_documentation -c user_configuration.yaml -p)) { Codnar::Application.new(true).run }.should == 0
       YAML.load_file("stdout").should == Codnar::Configuration::SPLIT_PRE_DOCUMENTATION.deep_merge(USER_CONFIGURATION)
     end
@@ -41,7 +41,7 @@ module Codnar
     def test_require_module
       FakeFS.deactivate! # The additional_module is read by Ruby and is not affected by FakeFS.
       directory = create_tempdir
-      File.open(directory + "/additional_module.rb", "w") { |file| file.puts("puts 'HERE'") }
+      write_fake_file(directory + "/additional_module.rb", "puts 'HERE'\n")
       Application.with_argv(["-o", stdout = directory + "/stdout", "-I", directory, "-r", "additional_module" ]) { Codnar::Application.new(true).run }.should == 0
       File.read(stdout).should == "HERE\n"
     end

data/test/run_split.rb

@@ -14,7 +14,7 @@ class TestRunSplit < Test::Unit::TestCase
   end
 
   def test_run_split
-    File.open("input", "w") { |file| file.puts("<foo>") }
+    write_fake_file("input", "<foo>\n")
     Codnar::Application.with_argv(%w(-o stdout input)) { Codnar::Split.new(true).run }.should == 0
     YAML.load_file("stdout").should == [ {
       "name" => "input",
@@ -25,14 +25,4 @@ class TestRunSplit < Test::Unit::TestCase
     } ]
   end
 
-  def test_run_split_no_file
-    Codnar::Application.with_argv(%w(-e stderr)) { Codnar::Split.new(true).run }.should == 1
-    File.read("stderr").should == "#{$0}: No input file to split\n"
-  end
-
-  def test_run_split_many_file
-    Codnar::Application.with_argv(%w(-e stderr one two)) { Codnar::Split.new(true).run }.should == 1
-    File.read("stderr").should == "#{$0}: Too many input files to split\n"
-  end
-
 end

data/test/run_weave.rb

@@ -26,30 +26,25 @@ class TestRunWeave < Test::Unit::TestCase
   } ]
 
   def test_run_weave
-    File.open("root", "w") { |file| file.write(ROOT_CHUNKS.to_yaml) }
-    File.open("included", "w") { |file| file.write(INCLUDED_CHUNKS.to_yaml) }
+    write_fake_file("root", ROOT_CHUNKS.to_yaml)
+    write_fake_file("included", INCLUDED_CHUNKS.to_yaml)
     Codnar::Application.with_argv(%w(-o stdout root included)) { Codnar::Weave.new(true).run }.should == 0
     File.read("stdout").should == "Root\nIncluded\n"
   end
 
   def test_run_weave_missing_chunk
-    File.open("root", "w") { |file| file.write(ROOT_CHUNKS.to_yaml) }
+    write_fake_file("root", ROOT_CHUNKS.to_yaml)
     Codnar::Application.with_argv(%w(-e stderr -o stdout root)) { Codnar::Weave.new(true).run }.should == 1
     File.read("stderr").should == "#{$0}: Missing chunk: included in file: root\n"
   end
 
   def test_run_weave_unused_chunk
-    File.open("root", "w") { |file| file.write(ROOT_CHUNKS.to_yaml) }
-    File.open("included", "w") { |file| file.write(INCLUDED_CHUNKS.to_yaml) }
+    write_fake_file("root", ROOT_CHUNKS.to_yaml)
+    write_fake_file("included", INCLUDED_CHUNKS.to_yaml)
     Codnar::Application.with_argv(%w(-e stderr -o stdout included root)) { Codnar::Weave.new(true).run }.should == 1
     File.read("stderr").should == "#{$0}: Unused chunk: root in file: root at line: 1\n"
   end
 
-  def test_run_weave_no_chunks
-    Codnar::Application.with_argv(%w(-e stderr)) { Codnar::Weave.new(true).run }.should == 1
-    File.read("stderr").should == "#{$0}: No chunk files to weave\n"
-  end
-
   FILE_CHUNKS = [ {
     "name" => "root",
     "locations" => [ { "file" => "root", "line" => 1 } ],
@@ -57,7 +52,7 @@ class TestRunWeave < Test::Unit::TestCase
   } ]
 
   def test_run_weave_missing_file
-    File.open("root", "w") { |file| file.write(FILE_CHUNKS.to_yaml) }
+    write_fake_file("root", FILE_CHUNKS.to_yaml)
     Codnar::Application.with_argv(%w(-e stderr -o stdout root)) { Codnar::Weave.new(true).run }.should == 1
     double_message = "No such file or directory - " * 2 # Something weird in Ruby Exception.to_s
     File.read("stdout").should == "Root\nFILE: included.file EXCEPTION: #{double_message}\n"
@@ -66,8 +61,8 @@ class TestRunWeave < Test::Unit::TestCase
   end
 
   def test_run_weave_existing_file
-    File.open("root", "w") { |file| file.write(FILE_CHUNKS.to_yaml) }
-    File.open("included.file", "w") { |file| file.write("included file\n") }
+    write_fake_file("root", FILE_CHUNKS.to_yaml)
+    write_fake_file("included.file", "included file\n")
     Codnar::Application.with_argv(%w(-e stderr -o stdout root)) { Codnar::Weave.new(true).run }.should == 0
     File.read("stdout").should == "Root\nincluded file\n"
   end

data/test/scan_lines.rb

@@ -9,7 +9,7 @@ class TestScanLines < Test::Unit::TestCase
   include Test::WithFakeFS
 
   def test_scan_lines
-    File.open("comments", "w") { |file| file.write(INPUT) }
+    write_fake_file("comments", INPUT)
     scanner = Codnar::Scanner.new(@errors, SYNTAX)
     scanner.lines("comments").should == LINES
     @errors.should == ERRORS

data/test/split_documentation.rb

@@ -9,7 +9,7 @@ class TestSplitDocumentation < Test::Unit::TestCase
   include Test::WithFakeFS
 
   def test_split_raw
-    File.open("raw.html", "w") { |file| file.write("<foo>\nbar\n</foo>\n") }
+    write_fake_file("raw.html", "<foo>\nbar\n</foo>\n")
     splitter = Codnar::Splitter.new(@errors, configuration("html"))
     chunks = splitter.chunks("raw.html")
     @errors.should == []
@@ -23,7 +23,7 @@ class TestSplitDocumentation < Test::Unit::TestCase
   end
 
   def test_split_markdown
-    File.open("markdown.md", "w") { |file| file.write("*foo*\nbar\n") }
+    write_fake_file("markdown.md", "*foo*\nbar\n")
     splitter = Codnar::Splitter.new(@errors, configuration("markdown"))
     chunks = splitter.chunks("markdown.md")
     @errors.should == []
@@ -37,7 +37,7 @@ class TestSplitDocumentation < Test::Unit::TestCase
   end
 
   def test_split_rdoc
-    File.open("rdoc.rdoc", "w") { |file| file.write("*foo*\nbar\n") }
+    write_fake_file("rdoc.rdoc", "*foo*\nbar\n")
     splitter = Codnar::Splitter.new(@errors, configuration("rdoc"))
     chunks = splitter.chunks("rdoc.rdoc")
     @errors.should == []
@@ -51,7 +51,7 @@ class TestSplitDocumentation < Test::Unit::TestCase
   end
 
   def test_split_unknown_kind
-    File.open("unknown.kind", "w") { |file| file.write("foo\nbar\n") }
+    write_fake_file("unknown.kind", "foo\nbar\n")
     splitter = Codnar::Splitter.new(@errors, configuration("unknown-kind"))
     chunks = splitter.chunks("unknown.kind")
     @errors.should == [ "#{$0}: No formatter specified for lines of kind: unknown-kind" ]

data/test/weave_configurations.rb

@@ -16,7 +16,7 @@ class TestWeaveConfigurations < Test::Unit::TestCase
         <embed src="path" type="x-codnar/file"/>
       EOF
     })
-    File.open("path", "w") { |file| file.puts("<h2>File</h2>") }
+    write_fake_file("path", "<h2>File</h2>\n")
     html = Codnar::Weaver.new(@errors, [ "chunks" ], Codnar::Configuration::WEAVE_INCLUDE).weave("include", "top")
     @errors.should == []
     html.should == <<-EOF.unindent

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: codnar
 version: !ruby/object:Gem::Version 
-  hash: 155
+  hash: 159
   prerelease: 
   segments: 
   - 0
   - 1
-  - 64
-  version: 0.1.64
+  - 66
+  version: 0.1.66
 platform: ruby
 authors: 
 - Oren Ben-Kiki
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-22 00:00:00 Z
+date: 2011-08-25 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: andand
@@ -296,7 +296,7 @@ licenses: []
 post_install_message: 
 rdoc_options: 
 - --title
-- Code Narrator 0.1.64
+- Code Narrator 0.1.66
 - --main
 - README.rdoc
 - --line-numbers