olag 0.1.16 → 0.1.17

data/ChangeLog

@@ -1,3 +1,7 @@
+2012-01-15	Oren Ben-Kiki <github-oren@ben-kiki.org>
+
+	* Add WithTempdir mix-in module.
+
 2012-01-07	Oren Ben-Kiki <github-oren@ben-kiki.org>
 
 	* Improve HAskell configuration comment.

data/codnar.html

@@ -2025,7 +2025,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.16</span><span class="Special">&quot;</span>
+  <span class="Type">VERSION</span> = <span class="Special">&quot;</span><span class="Constant">0.1.17</span><span class="Special">&quot;</span>
 
 end
 </pre>
@@ -2725,6 +2725,274 @@ end
 </div>
 </div>
 </p>
+<h3>Sorting Hash tables YAML keys</h3>
+<p>
+In order to get deterministic test results, and for general
+hukman-friendlyness, it is often desirable to sort hash table keys when dumping
+it to YAML. In Ruby 1.8.x, this isn't the default. It is possible to introduce
+this behavior using the following hack:
+</p>
+<p>
+<div class="named_with_containers chunk">
+<div class="chunk name">
+<a name="lib-olag-hash-sorted-yaml-rb">
+<span>lib/olag/hash_sorted_yaml.rb</span>
+</a>
+</div>
+<div class="chunk html">
+<pre class='ruby code syntax'>
+<span class="PreProc">require</span> <span class="Special">&quot;</span><span class="Constant">yaml</span><span class="Special">&quot;</span>
+
+<span class="Statement">if</span> <span class="Identifier">RUBY_VERSION</span>.include?(<span class="Special">&quot;</span><span class="Constant">1.8</span><span class="Special">&quot;</span>)
+
+</pre>
+  <table class='layout'>
+<tr>
+<td class='indentation'>
+<pre>  </pre>
+</td>
+<td class='html'>
+<div class='rdoc comment markup'>
+<p>
+Modify the hash class to emit YAML sorted keys. This is an ugly hack,
+specifically for Ruby 1.8.*.
+</p>
+</div>
+</td>
+</tr>
+</table>
+<pre class='ruby code syntax'>
+  <span class="PreProc">class</span> <span class="Type">Hash</span>
+
+</pre>
+    <table class='layout'>
+<tr>
+<td class='indentation'>
+<pre>    </pre>
+</td>
+<td class='html'>
+<div class='rdoc comment markup'>
+<p>
+Provide access to the old, unsorted implementation.
+</p>
+</div>
+</td>
+</tr>
+</table>
+<pre class='ruby code syntax'>
+    <span class="PreProc">alias</span> <span class="Constant">:unsorted_to_yaml</span> <span class="Constant">:to_yaml</span>
+
+</pre>
+    <table class='layout'>
+<tr>
+<td class='indentation'>
+<pre>    </pre>
+</td>
+<td class='html'>
+<div class='rdoc comment markup'>
+<p>
+Return the hash in YAML format with sorted keys.
+</p>
+</div>
+</td>
+</tr>
+</table>
+<pre class='ruby code syntax'>
+    <span class="PreProc">def</span> <span class="Identifier">to_yaml</span>(opts = {})
+      <span class="Type">YAML</span>::quick_emit(<span class="Constant">self</span>, opts) <span class="Statement">do</span> |<span class="Identifier">out</span>|
+        out.map(taguri, to_yaml_style) <span class="Statement">do</span> |<span class="Identifier">map</span>|
+          to_yaml_sorted_keys.each <span class="Statement">do</span> |<span class="Identifier">key</span>|
+            map.add(key, fetch(key))
+          <span class="Statement">end</span>
+        <span class="Statement">end</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>
+Return the hash keys, sorted for emitting into YAML.
+</p>
+</div>
+</td>
+</tr>
+</table>
+<pre class='ruby code syntax'>
+    <span class="PreProc">def</span> <span class="Identifier">to_yaml_sorted_keys</span>
+      <span class="Statement">begin</span>
+        <span class="Statement">return</span> keys.sort
+      <span class="Statement">rescue</span>
+        <span class="Statement">return</span> to_yaml_lexicographically_sorted_keys
+      <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>
+Return the hash keys, sorted lexicographically for emitting into YAML.
+</p>
+</div>
+</td>
+</tr>
+</table>
+<pre class='ruby code syntax'>
+    <span class="PreProc">def</span> <span class="Identifier">to_yaml_lexicographically_sorted_keys</span>
+      <span class="Statement">begin</span>
+        <span class="Statement">return</span> keys.sort_by {|<span class="Identifier">key</span>| key.to_s}
+      <span class="Statement">rescue</span>
+        <span class="Statement">return</span> keys
+      <span class="Statement">end</span>
+    <span class="PreProc">end</span>
+
+  end
+
+end
+</pre>
+</div>
+</div>
+</p>
+<p>
+Here is a simple test demonstrating using it:
+</p>
+<p>
+<div class="named_with_containers chunk">
+<div class="chunk name">
+<a name="test-sorted-keys-rb">
+<span>test/sorted_keys.rb</span>
+</a>
+</div>
+<div class="chunk html">
+<pre class='ruby code syntax'>
+<span class="PreProc">require</span> <span class="Special">&quot;</span><span class="Constant">olag/hash_sorted_yaml</span><span class="Special">&quot;</span>
+<span class="PreProc">require</span> <span class="Special">&quot;</span><span class="Constant">test/spec</span><span class="Special">&quot;</span>
+
+</pre>
+<table class='layout'>
+<tr>
+<td class='indentation'>
+<pre></pre>
+</td>
+<td class='html'>
+<div class='rdoc comment markup'>
+<p>
+An uncomparable class. Keys of this class will cause the Hash to be emitted
+in string sort order.
+</p>
+</div>
+</td>
+</tr>
+</table>
+<pre class='ruby code syntax'>
+<span class="PreProc">class</span> <span class="Type">Uncomparable</span>
+
+  <span class="PreProc">def</span> <span class="Identifier">initialize</span>(value)
+    <span class="Identifier">@value</span> = value
+  <span class="PreProc">end</span>
+
+  <span class="PreProc">def</span> <span class="Identifier">to_yaml</span>(opts = {})
+    <span class="Statement">return</span> <span class="Identifier">@value</span>.to_yaml(opts)
+  <span class="PreProc">end</span>
+
+  <span class="PreProc">def</span> <span class="Identifier">to_s</span>
+    <span class="Statement">return</span> <span class="Identifier">@value</span>.to_s
+  <span class="PreProc">end</span>
+
+  <span class="Special">%w(</span><span class="Constant">&lt;=&gt; &lt; &lt;= &gt;= &gt;</span><span class="Special">)</span>.each <span class="Statement">do</span> |<span class="Identifier">operator</span>|
+    define_method(operator) { <span class="Statement">raise</span> <span class="Special">&quot;</span><span class="Constant">Prevent operator: </span><span class="Special">#{</span>operator<span class="Special">}</span><span class="Special">&quot;</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>
+An uncomparable class that can’t be converted to a string. Keys of this
+class will cause the Hash to be emitted in unsorted order.
+</p>
+</div>
+</td>
+</tr>
+</table>
+<pre class='ruby code syntax'>
+<span class="PreProc">class</span> <span class="Type">Unsortable</span> &lt; <span class="Type">Uncomparable</span>
+
+  <span class="PreProc">def</span> <span class="Identifier">to_s</span>
+    <span class="Statement">raise</span> <span class="Special">&quot;</span><span class="Constant">Prevent conversion to string as well.</span><span class="Special">&quot;</span>
+  <span class="PreProc">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>
+Test sorting keys of YAML generated from Hash tables.
+</p>
+</div>
+</td>
+</tr>
+</table>
+<pre class='ruby code syntax'>
+<span class="PreProc">class</span> <span class="Type">TestSortedKeys</span> &lt; ::<span class="Type">Test</span>::<span class="Type">Unit</span>::<span class="Type">TestCase</span>
+
+  <span class="Type">SORTED_NUMERICALLY</span> = &lt;&lt;-<span class="Special">EOF</span>.unindent
+<span class="Constant">    ---</span>
+<span class="Constant">    2: 2</span>
+<span class="Constant">    4: 4</span>
+<span class="Constant">    11: 1</span>
+<span class="Constant">    33: 3</span>
+<span class="Constant">  </span><span class="Special">EOF</span>
+
+  <span class="Type">SORTED_LEXICOGRAPHICALLY</span> = &lt;&lt;-<span class="Special">EOF</span>.unindent
+<span class="Constant">    ---</span>
+<span class="Constant">    11: 1</span>
+<span class="Constant">    2: 2</span>
+<span class="Constant">    33: 3</span>
+<span class="Constant">    4: 4</span>
+<span class="Constant">  </span><span class="Special">EOF</span>
+
+  <span class="PreProc">def</span> <span class="Identifier">test_sortable_keys</span>
+    { <span class="Constant">2</span> =&gt; <span class="Constant">2</span>, <span class="Constant">4</span> =&gt; <span class="Constant">4</span>, <span class="Constant">11</span> =&gt; <span class="Constant">1</span>, <span class="Constant">33</span> =&gt; <span class="Constant">3</span> }.to_yaml.gsub(<span class="Special">/</span><span class="Constant"> </span><span class="Special">+</span><span class="Special">$</span><span class="Special">/</span>, <span class="Special">&quot;&quot;</span>).should == <span class="Type">SORTED_NUMERICALLY</span>
+  <span class="PreProc">end</span>
+
+  <span class="PreProc">def</span> <span class="Identifier">test_uncomparable_keys</span>
+    { <span class="Type">Uncomparable</span>.new(<span class="Constant">11</span>) =&gt; <span class="Constant">1</span>, <span class="Constant">2</span> =&gt; <span class="Constant">2</span>, <span class="Constant">33</span> =&gt; <span class="Constant">3</span>, <span class="Constant">4</span> =&gt; <span class="Constant">4</span> }.to_yaml.gsub(<span class="Special">/</span><span class="Constant"> </span><span class="Special">+</span><span class="Special">$</span><span class="Special">/</span>, <span class="Special">&quot;&quot;</span>).should == <span class="Type">SORTED_LEXICOGRAPHICALLY</span>
+  <span class="PreProc">end</span>
+
+  <span class="PreProc">def</span> <span class="Identifier">test_unsortable_keys</span>
+    yaml_should_not = { <span class="Type">Unsortable</span>.new(<span class="Constant">11</span>) =&gt; <span class="Constant">1</span>, <span class="Constant">2</span> =&gt; <span class="Constant">2</span>, <span class="Constant">33</span> =&gt; <span class="Constant">3</span>, <span class="Constant">4</span> =&gt; <span class="Constant">4</span> }.to_yaml.gsub(<span class="Special">/</span><span class="Constant"> </span><span class="Special">+</span><span class="Special">$</span><span class="Special">/</span>, <span class="Special">&quot;&quot;</span>).should.not
+    yaml_should_not == <span class="Type">SORTED_NUMERICALLY</span>
+    yaml_should_not == <span class="Type">SORTED_LEXICOGRAPHICALLY</span>
+  <span class="PreProc">end</span>
+
+<span class="PreProc">end</span>
+</pre>
+</div>
+</div>
+</p>
 <h3>Collecting errors</h3>
 <p>
 In library code, it is bad practice to terminate the program on an error.

data/doc/system.markdown

@@ -197,6 +197,19 @@ And here is the implementation:
 
 [[lib/olag/hash_struct.rb|named_chunk_with_containers]]
 
+### Sorting Hash tables YAML keys ###
+
+In order to get deterministic test results, and for general
+hukman-friendlyness, it is often desirable to sort hash table keys when dumping
+it to YAML. In Ruby 1.8.x, this isn't the default. It is possible to introduce
+this behavior using the following hack:
+
+[[lib/olag/hash_sorted_yaml.rb|named_chunk_with_containers]]
+
+Here is a simple test demonstrating using it:
+
+[[test/sorted_keys.rb|named_chunk_with_containers]]
+
 ### Collecting errors ###
 
 In library code, it is bad practice to terminate the program on an error.

data/lib/olag/hash_sorted_yaml.rb

@@ -0,0 +1,43 @@
+require "yaml"
+
+if RUBY_VERSION.include?("1.8")
+
+  # Modify the hash class to emit YAML sorted keys. This is an ugly hack,
+  # specifically for Ruby 1.8.*.
+  class Hash
+
+    # Provide access to the old, unsorted implementation.
+    alias :unsorted_to_yaml :to_yaml
+
+    # Return the hash in YAML format with sorted keys.
+    def to_yaml(opts = {})
+      YAML::quick_emit(self, opts) do |out|
+        out.map(taguri, to_yaml_style) do |map|
+          to_yaml_sorted_keys.each do |key|
+            map.add(key, fetch(key))
+          end
+        end
+      end
+    end
+
+    # Return the hash keys, sorted for emitting into YAML.
+    def to_yaml_sorted_keys
+      begin
+        return keys.sort
+      rescue
+        return to_yaml_lexicographically_sorted_keys
+      end
+    end
+
+    # Return the hash keys, sorted lexicographically for emitting into YAML.
+    def to_yaml_lexicographically_sorted_keys
+      begin
+        return keys.sort_by {|key| key.to_s}
+      rescue
+        return keys
+      end
+    end
+
+  end
+
+end

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.16"
+  VERSION = "0.1.17"
 
 end

data/test/sorted_keys.rb

@@ -0,0 +1,69 @@
+require "olag/hash_sorted_yaml"
+require "test/spec"
+
+# An uncomparable class. Keys of this class will cause the Hash to be emitted
+# in string sort order.
+class Uncomparable
+
+  def initialize(value)
+    @value = value
+  end
+
+  def to_yaml(opts = {})
+    return @value.to_yaml(opts)
+  end
+
+  def to_s
+    return @value.to_s
+  end
+
+  %w(<=> < <= >= >).each do |operator|
+    define_method(operator) { raise "Prevent operator: #{operator}" }
+  end
+
+end
+
+# An uncomparable class that can't be converted to a string. Keys of this class
+# will cause the Hash to be emitted in unsorted order.
+class Unsortable < Uncomparable
+
+  def to_s
+    raise "Prevent conversion to string as well."
+  end
+
+end
+
+# Test sorting keys of YAML generated from Hash tables.
+class TestSortedKeys < ::Test::Unit::TestCase
+
+  SORTED_NUMERICALLY = <<-EOF.unindent
+    ---
+    2: 2
+    4: 4
+    11: 1
+    33: 3
+  EOF
+
+  SORTED_LEXICOGRAPHICALLY = <<-EOF.unindent
+    ---
+    11: 1
+    2: 2
+    33: 3
+    4: 4
+  EOF
+
+  def test_sortable_keys
+    { 2 => 2, 4 => 4, 11 => 1, 33 => 3 }.to_yaml.gsub(/ +$/, "").should == SORTED_NUMERICALLY
+  end
+
+  def test_uncomparable_keys
+    { Uncomparable.new(11) => 1, 2 => 2, 33 => 3, 4 => 4 }.to_yaml.gsub(/ +$/, "").should == SORTED_LEXICOGRAPHICALLY
+  end
+
+  def test_unsortable_keys
+    yaml_should_not = { Unsortable.new(11) => 1, 2 => 2, 33 => 3, 4 => 4 }.to_yaml.gsub(/ +$/, "").should.not
+    yaml_should_not == SORTED_NUMERICALLY
+    yaml_should_not == SORTED_LEXICOGRAPHICALLY
+  end
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: olag
 version: !ruby/object:Gem::Version 
-  hash: 59
+  hash: 57
   prerelease: 
   segments: 
   - 0
   - 1
-  - 16
-  version: 0.1.16
+  - 17
+  version: 0.1.17
 platform: ruby
 authors: 
 - Oren Ben-Kiki
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-15 00:00:00 Z
+date: 2012-01-17 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: Saikuro
@@ -174,6 +174,7 @@ files:
 - lib/olag/errors.rb
 - lib/olag/gem_specification.rb
 - lib/olag/globals.rb
+- lib/olag/hash_sorted_yaml.rb
 - lib/olag/hash_struct.rb
 - lib/olag/rake.rb
 - lib/olag/string_unindent.rb
@@ -193,6 +194,7 @@ files:
 - test/collect_errors.rb
 - test/missing_keys.rb
 - test/run_application.rb
+- test/sorted_keys.rb
 - test/unindent_text.rb
 - README.rdoc
 - LICENSE
@@ -203,7 +205,7 @@ licenses: []
 post_install_message: 
 rdoc_options: 
 - --title
-- Olag 0.1.16
+- Olag 0.1.17
 - --main
 - README.rdoc
 - --line-numbers
@@ -241,4 +243,5 @@ test_files:
 - test/collect_errors.rb
 - test/missing_keys.rb
 - test/run_application.rb
+- test/sorted_keys.rb
 - test/unindent_text.rb