zucker 0.9

data/lib/zucker/1/descriptions/ivars.yaml

@@ -0,0 +1,22 @@
+ivars:
+  summary: This method lets you easily assign lots of instance variables.
+  why: |
+   Often, you have to write boilerplate code for assigning instance varialbles, for example this one:
+   ⇧def initialize(variable1, variable2)
+     @variable1, @variable2 = variable1, variable2
+   end⇧
+  methods:
+    instance_variables_from, ivars: |
+      def a_method(a = 1, b = 2)
+        instance_variables_from binding # assigns @a and @b
+
+        params = {:c => 3, :d => 4}
+        ivars params # # assigns @c and @d
+      end
+  package: default
+  versions:
+  - 1.9
+  - 1.8
+  authors:
+  - Jan Lelis
+

data/lib/zucker/1/descriptions/kernel.yaml

@@ -0,0 +1,13 @@
+kernel:
+  summary: Some useful general shortcut methods
+  why: Readability
+  methods:
+    activate_warnings!: "activate_warnings! # sets $VERBOSE to 1"
+    deactivate_warnings!: "deactivate_warnings! # sets $VERBOSE to 0"
+    library?: "library? # checks, if the current file is ran directly"
+    ignore_sigint!: "ignore_sigint! # blocks CTRL+C"
+  package: default
+  versions:
+  - 1.9
+  - 1.8
+

data/lib/zucker/1/descriptions/mcopy.yaml

@@ -0,0 +1,14 @@
+mcopy:
+  summary: Adds ⇧Object#mcopy⇧ to create a deep copy using ⇧Marshal⇧.
+  why: Every Ruby book describes, you can do ⇧Marshal.load Marshal.dump object⇧ to create a deep copy... But who needs this verbose syntax in everyday coding?
+  methods:
+    Object#mcopy: |
+      a = %w[hello world]
+      b = a.mcopy
+  package: default
+  versions:
+  - 1.9
+  - 1.8
+  authors:
+  - Jan Lelis
+

data/lib/zucker/1/descriptions/mm.yaml

@@ -0,0 +1,14 @@
+mm:
+  summary: ⇧mm⇧ displays an ordered public method list.
+  why: See some object's methods without those rarely used inherited methods
+  methods:
+    Object#method_list, Object#mm: "'test'.mm 2 # outputs the list (2 levels deep)"
+  package: debug
+  info:
+  - See http://rbjl.net/31-the-multi-mega-method-list for more information
+  versions:
+  - 1.9
+  - 1.8
+  authors:
+  - Jan Lelis (this implementation)
+

data/lib/zucker/1/descriptions/regexp2proc.yaml

@@ -0,0 +1,15 @@
+regexp2proc:
+  summary: Use &/regex/ to match it against strings
+  methods:
+    Regexp#to_proc: |
+      %w|just another string array|.map    &/[jy]/  # => ["j", nil, nil, "y"]
+      %w|just another string array|.select &/[jy]/  # => ["just", "array"]
+  package: default
+  info:
+  - "More about to_proc: http://rbjl.net/29-become-a-proc-star"
+  versions:
+  - 1.9
+  - 1.8
+  authors:
+  - Jan Lelis
+

data/lib/zucker/1/descriptions/sandbox.yaml

@@ -0,0 +1,16 @@
+sandbox:
+  summary: Creates a sandbox area.
+  why: Ruby comes with sandboxes, but they are hidden (--> integrated) in the ⇧$SAFE⇧ concept
+  methods:
+    sandbox: |
+      sandbox do
+        # dangerous commands throw SecurityErrors ($SAFE=4)
+      end
+      # everything's normal again
+  package: default
+  versions:
+  - 1.9
+  - 1.8
+  authors:
+  - Jan Lelis
+

data/lib/zucker/1/descriptions/square_brackets_for.yaml

@@ -0,0 +1,25 @@
+square_brackets_for:
+  summary: This helper methods defines ⇧[]⇧ and ⇧[]=⇧ for accesing an instance variable.
+  methods:
+    square_brackets_for: |
+      class Klass
+        def initialize
+          @var = {
+            :a_key => 1,
+            :another_one => 2,
+          }
+        end
+
+        square_brackets_for :var # creates [] and []=
+        # square_brackets_for :var, false # would create only []
+      end
+
+      a = Klass.new
+      a[:a_key] # => 1
+  package: default
+  versions:
+  - 1.9
+  - 1.8
+  authors:
+  - Jan Lelis
+

data/lib/zucker/1/descriptions/string.yaml

@@ -0,0 +1,15 @@
+string:
+  summary: ⇧String⇧ extensions.
+  why: Strings cannot be comfortable enough ;)
+  methods:
+    String#^: "'Yes vs No'^3 # => 'Yes'"
+    String#lchomp: "'   Yes'.lchomp  # => 'Yes'"
+    String#lchomp!: "# mutable lchomp version"
+    String#ords: "'Hallo'.ords # => [72, 97, 108, 108, 111]"
+  package: default
+  versions:
+  - 1.9
+  - 1.8
+  authors:
+  - Jan Lelis
+

data/lib/zucker/1/descriptions/unary.yaml

@@ -0,0 +1,15 @@
+unary:
+  summary: Easy conversion between strings and symbols.
+  why: Often, you do not care if you get a ⇧String⇧ or a ⇧Symbol⇧ as input - but you need one of both when analysing it.
+  methods:
+    String#+@: "+'was_string' # => 'was_string'"
+    String#-@: "-'was_string' # => :was_string"
+    Symbol#+@: "+:was_symbol  # => 'was_symbol'"
+    Symbol#-@: "-:was_symbol  # => :was_symbol"
+  package: default
+  info:
+  - Inspired by
+  versions:
+  - 1.9
+  - 1.8 (+:literal not possible)
+

data/lib/zucker/1/descriptions/union.yaml

@@ -0,0 +1,11 @@
+union:
+  summary: Easy creation of ⇧Regexp.union⇧s
+  methods:
+    Regexp#|, String#|: |
+      /Ruby\d/ | /test/i | "cheat"
+      # creates a Regexp similar to:
+      # /(Ruby\d|[tT][eE][sS][tT]|cheat)/
+  package: default
+  versions:
+  - 1.9
+

data/lib/zucker/1/documentation/meta.yaml

@@ -0,0 +1,4 @@
+version: 1
+release_date: 2010-08-05
+authors:
+- Jan Lelis

data/lib/zucker/1/documentation/zucker_doc.html

@@ -0,0 +1,1158 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+       "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <meta http-equiv="content-type" content="text/html;charset=UTF-8" />
+
+  <title>Ruby Zucker 1</title>
+  <script type="text/javascript">
+    var show = function(snippet){
+      document.getElementById( snippet ).style.display = 'block'
+      if( document.getElementById( 'show_'+snippet ) ){
+        document.getElementById( 'show_'+snippet ).style.display = 'none'
+      }
+    }
+  </script>
+  <style type="text/css">
+body{
+  background-color:#aaa;
+  color:#111;
+  font-family:sans-serif;
+}
+
+#world{
+  background:#fff;
+}
+
+h1, h2, h3, h4, h5, h6{
+  margin:0px;
+  padding:0px;
+}
+
+h1{
+  color:#222;
+  text-align:center;
+  padding:0.5em;
+}
+h2{
+  margin-left:0.5em;
+  margin-top:0.8em;
+  margin-bottom:0.5em;
+}
+
+th{
+  width:200px;
+  color:#444;
+}
+
+p{
+  margin:0px;
+  margin-bottom:0.5em;
+}
+
+p.text{
+  margin-left:1.5em;
+  margin-right:1em;
+}
+
+code{
+}
+
+.scode{
+  display:block;
+  margin:0.8em;
+#  margin-right:1.8em;
+  padding:0.5em;
+  border:1px solid black;
+  background:#eee;
+}
+
+#.cube_table{
+#  display:none;
+#}
+.cubes{
+  margin:0px;
+  margin-left:1.5em;
+  margin-right:1em;
+}
+
+a{
+  color:#111;
+}
+
+table{
+  margin:0.8em;
+  margin-top:0.2em;
+  padding:0.2em;
+  border:1px solid #111;
+  background:#eee;
+  overflow:auto;
+  display:block;
+}
+
+th{
+  text-align:left;
+  vertical-align:top;
+  padding-right:3em;
+}
+
+td{
+  width:100%;
+}
+
+li{
+  list-style:none;
+}
+
+
+#foot{
+  text-align:left;
+  padding:0.3em;
+  font-size:70%
+}
+#foot, #foot a{
+  color:#444;
+}
+#smile{
+  font-size:150%;
+  float:right;
+}
+#smile a{
+  text-decoration:none;
+}
+
+.small{
+  font-size:70%;
+}
+
+code, pre{
+  font-face:mono;
+  margin:0px;
+  padding:0px;
+}
+
+.source{
+  display:none;
+  border:1px solid #005;
+  background:#111;
+  padding:5px;
+  width:98%;
+
+  background-color: #232323;
+#  border: 1px solid black;
+  font-family: 'Courier New', 'Terminal', monospace;
+  color: #E6E0DB;
+  padding: 3px 5px;
+#  margin-right:1em;
+  overflow: auto;
+  font-size: 12px;
+}
+
+/*railscasts*/
+.source .an { color:#E7BE69 }                      /* html attribute */
+.source .c  { color:#BC9358; font-style: italic; } /* comment */
+.source .ch { color:#509E4F }                      /* escaped character */
+.source .cl { color:#FFF }                         /* class */
+.source .co { color:#FFF }                         /* constant */
+.source .fl { color:#A4C260 }                      /* float */
+.source .fu { color:#FFC56D }                      /* function */
+.source .gv { color:#D0CFFE }                      /* global variable */
+.source .i  { color:#A4C260 }                      /* integer */
+.source .il { background:#151515 }                 /* inline code */
+.source .iv { color:#D0CFFE }                      /* instance variable */
+.source .pp { color:#E7BE69 }                      /* doctype */
+.source .r  { color:#CB7832 }                      /* keyword */
+.source .rx { color:#A4C260 }                      /* regex */
+.source .s  { color:#A4C260 }                      /* string */
+.source .sy { color:#6C9CBD }                      /* symbol */
+.source .ta { color:#E7BE69 }                      /* html tag */
+.source .pc { color:#6C9CBD }                      /* boolean */
+
+  </style>
+</head>
+<body>
+  <div id="world">
+
+    <h1>Ruby Zucker 1</h1>
+      <h2>What is it?</h2>
+      <p class="text">Zucker is the German word for sugar (<a href="http://www.forvo.com/word/zucker/">pronunciation</a>). This gem adds syntactical sugar in the form of independent, lightweight scripts that make Ruby even more beautiful. Read <a href="http://rbjl.net/32-">this blog post</a> for a little introduction!</p>
+
+      <h2>Install</h2>
+      <p class="text">
+        <code class="scode">gem install zucker # might need sudo</code>
+      </p>
+
+      <h2>Usage / Organisation</h2>
+      <p class="text">The gem consists of many small snippets, called <em>cubes</em>, which are bundled in <em>packages</em>. Currently, there are two packages available: <strong>default</strong> and <strong>debug</strong>. You can use a package be requiring it in this way:
+      <code class="scode">require 'zucker/default'</code>
+      and
+      <code class="scode">require 'zucker/debug'</code>
+
+      Since there aren't any dependencies within the gem, you could also pick only the cubes you want:
+
+      <code class="scode">require 'zucker/1/egonil'</code>
+      </p>
+      <p class="text"><em>Please note:</em> To cherry-pick cubes, you have to allude to the gem version you want to use. Future releases of the gem will include all previous versions, so the behaviour of directly required cubes will never change (except for critical bugs).</p>
+
+      <h2 title="require 'zucker/all'">Cubes</h2>
+      <div class="cubes">
+         <h3 title="require 'zucker/1/class2proc'">class2proc</h3>
+         <table class="cube_table"
+                id="class2proc_cube"
+                title="require 'zucker/1/class2proc'"> <tr><th>Summary</th>    <td>Creates a new instance of the class.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Class#to_proc</h5><pre class="usage source" style="display:block">[ [<span class="i">1</span>,<span class="i">2</span>],[<span class="i">3</span>,<span class="i">5</span>,<span class="i">6</span>,<span class="i">7</span>,<span class="i">3</span>] ].map(&amp;<span class="co">Set</span>) <span class="c"># =&gt; [ Set[1,2], Set[5,6,7,3] ]</span></pre></td></tr><tr><th>Further information</th>    <td>Inspired by Ruby Facets<br/>More about to_proc: http://rbjl.net/29-become-a-proc-star</td></tr><tr><th>Specification</th>    <td> <span id="show_class2proc_specification">(<a href="javascript:show('class2proc_specification')">show</a>)</span>
+         <pre class="source" id="class2proc_specification">require <span class="s"><span class="dl">'</span><span class="k">class2proc</span><span class="dl">'</span></span>
+require <span class="s"><span class="dl">'</span><span class="k">set</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Class#to_proc</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should create new instances of the class</span><span class="dl">'</span></span> <span class="r">do</span>
+    [ [<span class="i">1</span>,<span class="i">2</span>],[<span class="i">3</span>,<span class="i">5</span>,<span class="i">6</span>,<span class="i">7</span>,<span class="i">3</span>] ].map(&amp;<span class="co">Set</span>).should == [ <span class="co">Set</span>[<span class="i">1</span>,<span class="i">2</span>], <span class="co">Set</span>[<span class="i">5</span>,<span class="i">6</span>,<span class="i">7</span>,<span class="i">3</span>] ]
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_class2proc_source">(<a href="javascript:show('class2proc_source')">show</a>)</span>
+         <pre class="source" id="class2proc_source"><span class="r">class</span> <span class="cl">Class</span>
+  <span class="r">def</span> <span class="fu">to_proc</span>
+    <span class="co">Proc</span>.new <span class="r">do</span> |*args|
+      <span class="pc">self</span>.new *args
+    <span class="r">end</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/iterate'">iterate</h3>
+         <table class="cube_table"
+                id="iterate_cube"
+                title="require 'zucker/1/iterate'"> <tr><th>Summary</th>    <td>Iterate over one or more collections.</td></tr><tr><th>Why?</th>    <td>It's like <code>.each</code> with two differences: It feels more like a control structure and you can easily iterate over multiple objects.</td></tr><tr><th>Methods/Usage</th>    <td><h5>iterate</h5><pre class="usage source" style="display:block">iterate [<span class="i">1</span>,<span class="i">2</span>], [<span class="i">3</span>,<span class="i">4</span>,<span class="i">5</span>] <span class="r">do</span> |e,f|
+  puts <span class="er">”</span><span class="c">#{e},#{f}”</span>
+<span class="r">end</span>
+<span class="c"># outputs</span>
+<span class="c">#  1,3</span>
+<span class="c">#  2,4</span>
+<span class="c">#  ,5</span>
+</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_iterate_specification">(<a href="javascript:show('iterate_specification')">show</a>)</span>
+         <pre class="source" id="iterate_specification">require <span class="s"><span class="dl">'</span><span class="k">iterate</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Object#iterate</span><span class="dl">'</span></span> <span class="r">do</span>
+  let <span class="sy">:a</span>   <span class="r">do</span> [<span class="i">1</span>, <span class="i">2</span>, <span class="i">3</span>]     <span class="r">end</span>
+  let <span class="sy">:b</span>   <span class="r">do</span> <span class="s"><span class="dl">%w|</span><span class="k">a b c d</span><span class="dl">|</span></span>   <span class="r">end</span>
+  let <span class="sy">:res</span> <span class="r">do</span> <span class="co">Hash</span>.new {[]} <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should behave like Enumerable#each for a single argument</span><span class="dl">'</span></span> <span class="r">do</span>
+    iterate a <span class="r">do</span> |ele|
+      res[<span class="sy">:iter</span>] &lt;&lt; ele
+    <span class="r">end</span>
+
+    a.each <span class="r">do</span> |ele|
+      res[<span class="sy">:each</span>] &lt;&lt; ele
+    <span class="r">end</span>
+
+    res[<span class="sy">:iter</span>].should == res[<span class="sy">:each</span>]
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should pass the right params to the block</span><span class="dl">'</span></span> <span class="r">do</span>
+    res = <span class="co">Hash</span>.new {[]} <span class="c"># TODO: why?</span>
+    res[<span class="sy">:iter_a_b</span>] = [] <span class="c"># ....</span>
+    res[<span class="sy">:iter_b_a</span>] = [] <span class="c"># ....</span>
+
+
+    iterate a, b <span class="r">do</span> |e,f|
+      res[<span class="sy">:iter_a_b</span>] &lt;&lt; [e, f]
+<span class="c">#      p res[:iter_a_b], e, f</span>
+    <span class="r">end</span>
+
+    res[<span class="sy">:iter_a_b</span>].should == [
+      [<span class="i">1</span>, <span class="s"><span class="dl">'</span><span class="k">a</span><span class="dl">'</span></span>],
+      [<span class="i">2</span>, <span class="s"><span class="dl">'</span><span class="k">b</span><span class="dl">'</span></span>],
+      [<span class="i">3</span>, <span class="s"><span class="dl">'</span><span class="k">c</span><span class="dl">'</span></span>],
+      [<span class="pc">nil</span>, <span class="s"><span class="dl">'</span><span class="k">d</span><span class="dl">'</span></span>],
+    ]
+
+    iterate b, a <span class="r">do</span> |e,f|
+      res[<span class="sy">:iter_b_a</span>] &lt;&lt; [e, f]
+    <span class="r">end</span>
+
+    res[<span class="sy">:iter_b_a</span>].should == [
+      [<span class="s"><span class="dl">'</span><span class="k">a</span><span class="dl">'</span></span>, <span class="i">1</span>],
+      [<span class="s"><span class="dl">'</span><span class="k">b</span><span class="dl">'</span></span>, <span class="i">2</span>],
+      [<span class="s"><span class="dl">'</span><span class="k">c</span><span class="dl">'</span></span>, <span class="i">3</span>],
+      [<span class="s"><span class="dl">'</span><span class="k">d</span><span class="dl">'</span></span>, <span class="pc">nil</span>],
+    ]
+
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should return enumerators if no block is applied</span><span class="dl">'</span></span> <span class="r">do</span>
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_iterate_source">(<a href="javascript:show('iterate_source')">show</a>)</span>
+         <pre class="source" id="iterate_source"><span class="r">def</span> <span class="fu">iterate</span>(*params)
+  <span class="c"># params.shift.zip(*params).each{ |*elements| yield *elements }</span>
+
+  first = params.shift
+  <span class="r">if</span> params.empty? <span class="c"># single param - like each</span>
+    <span class="r">if</span> block_given?
+      first.map{|e| <span class="r">yield</span> e }
+    <span class="r">else</span>
+      first.map
+    <span class="r">end</span>
+  <span class="r">else</span>
+    padded_first = <span class="co">Array</span>.new( [first, *params].max_by(&amp;<span class="sy">:size</span>).size ){|i| first[i] } <span class="c"># append nils</span>
+    obj = padded_first.zip *params
+    <span class="r">if</span> block_given?
+      obj.map{|es| <span class="r">yield</span> *es }
+    <span class="r">else</span>
+      obj.map.to_enum
+    <span class="r">end</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/unary'">unary</h3>
+         <table class="cube_table"
+                id="unary_cube"
+                title="require 'zucker/1/unary'"> <tr><th>Summary</th>    <td>Easy conversion between strings and symbols.</td></tr><tr><th>Why?</th>    <td>Often, you do not care if you get a <code>String</code> or a <code>Symbol</code> as input - but you need one of both when analysing it.</td></tr><tr><th>Methods/Usage</th>    <td><h5>String#+@</h5><pre class="usage source" style="display:block">+<span class="s"><span class="dl">'</span><span class="k">was_string</span><span class="dl">'</span></span> <span class="c"># =&gt; 'was_string'</span></pre><h5>String#-@</h5><pre class="usage source" style="display:block">-<span class="s"><span class="dl">'</span><span class="k">was_string</span><span class="dl">'</span></span> <span class="c"># =&gt; :was_string</span></pre><h5>Symbol#+@</h5><pre class="usage source" style="display:block">+<span class="sy">:was_symbol</span>  <span class="c"># =&gt; 'was_symbol'</span></pre><h5>Symbol#-@</h5><pre class="usage source" style="display:block">-<span class="sy">:was_symbol</span>  <span class="c"># =&gt; :was_symbol</span></pre></td></tr><tr><th>Further information</th>    <td>Inspired by</td></tr><tr><th>Specification</th>    <td> <span id="show_unary_specification">(<a href="javascript:show('unary_specification')">show</a>)</span>
+         <pre class="source" id="unary_specification">require <span class="s"><span class="dl">'</span><span class="k">unary</span><span class="dl">'</span></span>
+
+describe <span class="co">Symbol</span>, <span class="s"><span class="dl">'</span><span class="k">#+@</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should convert to_s</span><span class="dl">'</span></span> <span class="r">do</span>
+    +(<span class="sy">:matz</span>) == <span class="s"><span class="dl">'</span><span class="k">matz</span><span class="dl">'</span></span> <span class="c"># () 1.8 bug</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="co">Symbol</span>, <span class="s"><span class="dl">'</span><span class="k">#-@</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should do nothing</span><span class="dl">'</span></span> <span class="r">do</span>
+    -<span class="sy">:matz</span> == <span class="sy">:matz</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="co">String</span>, <span class="s"><span class="dl">'</span><span class="k">#+@</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should do nothing</span><span class="dl">'</span></span> <span class="r">do</span>
+    +<span class="s"><span class="dl">'</span><span class="k">matz</span><span class="dl">'</span></span> == <span class="s"><span class="dl">'</span><span class="k">matz</span><span class="dl">'</span></span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="co">String</span>, <span class="s"><span class="dl">'</span><span class="k">#-@</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should convert to_sym</span><span class="dl">'</span></span> <span class="r">do</span>
+    -<span class="s"><span class="dl">'</span><span class="k">matz</span><span class="dl">'</span></span> == <span class="sy">:matz</span>
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_unary_source">(<a href="javascript:show('unary_source')">show</a>)</span>
+         <pre class="source" id="unary_source"><span class="r">class</span> <span class="cl">String</span>
+  <span class="r">def</span> <span class="fu">+@</span>
+    <span class="pc">self</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">-@</span>
+    to_sym
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="r">class</span> <span class="cl">Symbol</span>
+  <span class="r">def</span> <span class="fu">+@</span>
+    to_s
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">-@</span>
+    <span class="pc">self</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8 (+:literal not possible)</td></tr></table> <h3 title="require 'zucker/1/ivars'">ivars</h3>
+         <table class="cube_table"
+                id="ivars_cube"
+                title="require 'zucker/1/ivars'"> <tr><th>Summary</th>    <td>This method lets you easily assign lots of instance variables.</td></tr><tr><th>Why?</th>    <td>Often, you have to write boilerplate code for assigning instance varialbles, for example this one:<br/><code>def initialize(variable1, variable2)<br/>  @variable1, @variable2 = variable1, variable2<br/>end</code><br/></td></tr><tr><th>Methods/Usage</th>    <td><h5>instance_variables_from, ivars</h5><pre class="usage source" style="display:block"><span class="r">def</span> <span class="fu">a_method</span>(a = <span class="i">1</span>, b = <span class="i">2</span>)
+  instance_variables_from binding <span class="c"># assigns @a and @b</span>
+
+  params = {<span class="sy">:c</span> =&gt; <span class="i">3</span>, <span class="sy">:d</span> =&gt; <span class="i">4</span>}
+  ivars params <span class="c"># # assigns @c and @d</span>
+<span class="r">end</span>
+</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_ivars_specification">(<a href="javascript:show('ivars_specification')">show</a>)</span>
+         <pre class="source" id="ivars_specification">require <span class="s"><span class="dl">'</span><span class="k">ivars</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">instance_variables_from</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should tansform the given parameter to instance variables</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="r">def</span> <span class="fu">a_method</span>(a = <span class="i">1</span>, b = <span class="i">2</span>)
+      instance_variables_from binding <span class="c"># assigns @a and @b</span>
+
+      params = {<span class="sy">:c</span> =&gt; <span class="i">3</span>, <span class="sy">:d</span> =&gt; <span class="i">4</span>}
+      ivars params <span class="c"># # assigns @c and @d</span>
+    <span class="r">end</span>
+
+    a_method
+    <span class="iv">@a</span>.should == <span class="i">1</span>
+    <span class="iv">@b</span>.should == <span class="i">2</span>
+    <span class="iv">@c</span>.should == <span class="i">3</span>
+    <span class="iv">@d</span>.should == <span class="i">4</span>
+
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_ivars_source">(<a href="javascript:show('ivars_source')">show</a>)</span>
+         <pre class="source" id="ivars_source"><span class="r">def</span> <span class="fu">instance_variables_from</span>(obj, *only)
+  iter =
+  <span class="r">if</span>    obj.is_a? <span class="co">Binding</span>
+    obj.eval(<span class="s"><span class="dl">'</span><span class="k">local_variables</span><span class="dl">'</span></span>).map{|e| [obj.eval(e), e] }
+  <span class="r">elsif</span> obj.is_a? <span class="co">Hash</span>
+    obj.map{|k,v| [v,k] }
+  <span class="r">else</span>
+<span class="c">#  elsif obj.is_a? Enumerable</span>
+    obj.each.with_index
+  <span class="r">end</span>
+
+  ret = []
+  iter.each{ |value, arg|
+    arg = arg.to_s
+    <span class="r">if</span> only.include?(arg) || only.include?(arg.to_sym) || only.empty?
+      arg = <span class="s"><span class="dl">'</span><span class="k">_</span><span class="dl">'</span></span> + arg  <span class="r">if</span> (<span class="i">48</span>..<span class="i">57</span>).member? arg.unpack(<span class="s"><span class="dl">'</span><span class="k">C</span><span class="dl">'</span></span>)[<span class="i">0</span>]  <span class="c"># 1.8+1.9</span>
+      ret &lt;&lt; ivar = <span class="sy"><span class="sy">:</span><span class="dl">&quot;</span><span class="k">@</span><span class="il"><span class="idl">#{</span>arg<span class="idl">}</span></span><span class="dl">&quot;</span></span>
+      <span class="pc">self</span>.instance_variable_set ivar, value
+    <span class="r">end</span>
+  }
+  ret
+<span class="r">end</span>
+<span class="r">alias</span> <span class="fu">ivars</span> <span class="fu">instance_variables_from</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/D'">D</h3>
+         <table class="cube_table"
+                id="D_cube"
+                title="require 'zucker/1/D'"> <tr><th>Summary</th>    <td>Easy debug printing with the <code>p</code> alternative <code>.D</code>. It outputs to stdout and returns <code>self</code>. Accepts a block.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Object#D</h5><pre class="usage source" style="display:block">some.<span class="co">D</span>.methods.<span class="co">D</span>.noone.<span class="co">D</span>.knows.<span class="co">D</span>
+<span class="c"># ...outputs 4 lines with the inspected object</span>
+<span class="c"># =&gt; (result)</span>
+
+<span class="i">21</span>+<span class="co">Math</span>.sin(<span class="i">42</span>).<span class="co">D</span>
+<span class="c"># outputs -0.916521547915634</span>
+<span class="c"># =&gt; 20.0834784520844</span>
+
+name = <span class="s"><span class="dl">'</span><span class="k">Earth</span><span class="dl">'</span></span>
+<span class="s"><span class="dl">'</span><span class="k">Hello </span><span class="dl">'</span></span> + name.<span class="co">D</span>{|e| <span class="s"><span class="dl">&quot;</span><span class="k">The length is: </span><span class="il"><span class="idl">#{</span>e.size<span class="idl">}</span></span><span class="dl">&quot;</span></span>}
+<span class="c"># outputs &quot;The length is: 5&quot;</span>
+<span class="c"># =&gt; 'Hello Earth'</span>
+</pre></td></tr><tr><th>Further information</th>    <td>This is inspired by the funny <code>.tap</code> method: http://moonbase.rydia.net/mental/blog/programming/eavesdropping-on-expressions</td></tr><tr><th>Specification</th>    <td> <span id="show_D_specification">(<a href="javascript:show('D_specification')">show</a>)</span>
+         <pre class="source" id="D_specification">require <span class="s"><span class="dl">'</span><span class="k">D</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Object#D</span><span class="dl">'</span></span> <span class="r">do</span>
+
+  let <span class="sy">:a</span> <span class="r">do</span>
+    [ <span class="i">1</span>, <span class="s"><span class="dl">&quot;</span><span class="k">1</span><span class="dl">&quot;</span></span>, <span class="i">2</span>..<span class="i">5</span>, [], {<span class="sy">:hallo</span> =&gt; <span class="sy">:du</span>}, <span class="pc">nil</span>, <span class="pc">true</span> ]
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should not change the object&quot;s value</span><span class="dl">'</span></span> <span class="r">do</span>
+    a.each{ |e|
+      (e.<span class="co">D</span>).should == e
+    }
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">&quot;</span><span class="k">should puts .inspect if no block is given (and not change the object's value)</span><span class="dl">&quot;</span></span> <span class="r">do</span>
+<span class="c">#    a.each{ |e|</span>
+<span class="c">#      (e.D).should == e</span>
+<span class="c">#    }</span>
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">&quot;</span><span class="k">should puts the block if it is given (and not change the object's value)</span><span class="dl">&quot;</span></span> <span class="r">do</span>
+    a.each{ |e|
+      (e.<span class="co">D</span>{|value| <span class="s"><span class="dl">&quot;</span><span class="k">This is a: </span><span class="il"><span class="idl">#{</span>value<span class="idl">}</span></span><span class="dl">&quot;</span></span>}).should == e
+    }
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_D_source">(<a href="javascript:show('D_source')">show</a>)</span>
+         <pre class="source" id="D_source"><span class="r">module</span> <span class="cl">Kernel</span>
+  <span class="r">def</span> <span class="fu">D</span>(*args, &amp;block)
+    <span class="r">if</span> args.empty?
+      tap{
+        <span class="r">if</span> block_given?
+          puts <span class="r">yield</span> <span class="pc">self</span>
+        <span class="r">else</span>
+          puts <span class="pc">self</span>.inspect
+        <span class="r">end</span>
+      }
+    <span class="r">else</span>
+      raise <span class="co">ArgumentError</span>, <span class="s"><span class="dl">&quot;</span><span class="k">.D - The parser thought that the code after .D are method arguments... Please don't put a space after D or use .D() or .D{} in this case!</span><span class="dl">&quot;</span></span>
+<span class="c">#      eval ...</span>
+    <span class="r">end</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/array'">array</h3>
+         <table class="cube_table"
+                id="array_cube"
+                title="require 'zucker/1/array'"> <tr><th>Summary</th>    <td>Methods one could miss for <code>Array</code></td></tr><tr><th>Why?</th>    <td><p><code>Array</code> has <code>&</code> and <code>|</code>, but why does it not have <code>^</code>?</p><p><code>sum</code> is an alias for <code>inject(:+)</code>, but it is just needed pretty often!</p></td></tr><tr><th>Methods/Usage</th>    <td><h5>Array#^</h5><pre class="usage source" style="display:block">[<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>] ^ [<span class="i">3</span>,<span class="i">4</span>,<span class="i">5</span>,<span class="i">6</span>]  <span class="c"># =&gt; [1,2,5,6]</span></pre><h5>Array#sum</h5><pre class="usage source" style="display:block">[<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>,<span class="i">5</span>].sum  <span class="c"># =&gt; 15</span></pre><h5>Array#chrs</h5><pre class="usage source" style="display:block">[<span class="i">72</span>, <span class="i">97</span>, <span class="i">108</span>, <span class="i">108</span>, <span class="i">111</span>].chrs  <span class="c"># =&gt; 'Hallo'</span></pre></td></tr><tr><th>Specification</th>    <td> <span id="show_array_specification">(<a href="javascript:show('array_specification')">show</a>)</span>
+         <pre class="source" id="array_specification">require <span class="s"><span class="dl">'</span><span class="k">array</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Array#^</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should do an exclusive or</span><span class="dl">'</span></span> <span class="r">do</span>
+    a = [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>]
+    b = [<span class="i">3</span>,<span class="i">4</span>,<span class="i">5</span>,<span class="i">6</span>]
+    (a^b).should == [<span class="i">1</span>,<span class="i">2</span>,<span class="i">5</span>,<span class="i">6</span>]
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Array#sum</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should sum the array</span><span class="dl">'</span></span> <span class="r">do</span>
+    [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>,<span class="i">5</span>].sum.should   == <span class="i">15</span>
+    <span class="s"><span class="dl">%w|</span><span class="k">More Ruby</span><span class="dl">|</span></span>.sum.should == <span class="s"><span class="dl">'</span><span class="k">MoreRuby</span><span class="dl">'</span></span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Array#chrs</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should convert the array to a string, using each element as ord value for the char</span><span class="dl">'</span></span> <span class="r">do</span>
+    [<span class="i">72</span>, <span class="i">97</span>, <span class="i">108</span>, <span class="i">108</span>, <span class="i">111</span>].chrs.should == <span class="s"><span class="dl">'</span><span class="k">Hallo</span><span class="dl">'</span></span>
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_array_source">(<a href="javascript:show('array_source')">show</a>)</span>
+         <pre class="source" id="array_source"><span class="r">class</span> <span class="cl">Array</span>
+  <span class="r">def</span> <span class="fu">^</span>(other) <span class="c"># TODO: more efficient</span>
+    (<span class="pc">self</span> - other) +
+    (other - <span class="pc">self</span>)
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">sum</span> <span class="c"># sry, you just need this one too often</span>
+    inject <span class="sy">:+</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">chrs</span>
+    <span class="pc">self</span>.pack <span class="s"><span class="dl">'</span><span class="k">C*</span><span class="dl">'</span></span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/array2proc'">array2proc</h3>
+         <table class="cube_table"
+                id="array2proc_cube"
+                title="require 'zucker/1/array2proc'"> <tr><th>Summary</th>    <td>Calls the method named by the first paramenter and passes the other elements as paramaters.</td></tr><tr><th>Why?</th>    <td>When using <code>Symbol#to_proc</code>, you often wish to pass parameters.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Array#to_proc</h5><pre class="usage source" style="display:block">[<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>].map( &amp;[<span class="sy">:to_s</span>, <span class="i">2</span>] )  <span class="c"># =&gt; [&quot;1&quot;, &quot;10&quot;, &quot;11&quot;, &quot;100&quot;]</span></pre></td></tr><tr><th>Further information</th>    <td>Inspired by http://www.sanityinc.com/articles/adding-array-to-proc-to-ruby<br/>More about to_proc: http://rbjl.net/29-become-a-proc-star</td></tr><tr><th>Specification</th>    <td> <span id="show_array2proc_specification">(<a href="javascript:show('array2proc_specification')">show</a>)</span>
+         <pre class="source" id="array2proc_specification">require <span class="s"><span class="dl">'</span><span class="k">array2proc</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Array#to_proc</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should call the method of the first symbol, using the remaining elements as paramaters</span><span class="dl">'</span></span> <span class="r">do</span>
+    [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>].map( &amp;[<span class="sy">:to_s</span>, <span class="i">2</span>] ).should == [<span class="s"><span class="dl">&quot;</span><span class="k">1</span><span class="dl">&quot;</span></span>, <span class="s"><span class="dl">&quot;</span><span class="k">10</span><span class="dl">&quot;</span></span>, <span class="s"><span class="dl">&quot;</span><span class="k">11</span><span class="dl">&quot;</span></span>, <span class="s"><span class="dl">&quot;</span><span class="k">100</span><span class="dl">&quot;</span></span>]
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_array2proc_source">(<a href="javascript:show('array2proc_source')">show</a>)</span>
+         <pre class="source" id="array2proc_source"><span class="r">class</span> <span class="cl">Array</span>
+  <span class="r">def</span> <span class="fu">to_proc</span>
+    <span class="co">Proc</span>.new{ |obj|
+      obj.send *<span class="pc">self</span>
+    }
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/square_brackets_for'">square_brackets_for</h3>
+         <table class="cube_table"
+                id="square_brackets_for_cube"
+                title="require 'zucker/1/square_brackets_for'"> <tr><th>Summary</th>    <td>This helper methods defines <code>[]</code> and <code>[]=</code> for accesing an instance variable.</td></tr><tr><th>Methods/Usage</th>    <td><h5>square_brackets_for</h5><pre class="usage source" style="display:block"><span class="r">class</span> <span class="cl">Klass</span>
+  <span class="r">def</span> <span class="fu">initialize</span>
+    <span class="iv">@var</span> = {
+      <span class="sy">:a_key</span> =&gt; <span class="i">1</span>,
+      <span class="sy">:another_one</span> =&gt; <span class="i">2</span>,
+    }
+  <span class="r">end</span>
+
+  square_brackets_for <span class="sy">:var</span> <span class="c"># creates [] and []=</span>
+  <span class="c"># square_brackets_for :var, false # would create only []</span>
+<span class="r">end</span>
+
+a = <span class="co">Klass</span>.new
+a[<span class="sy">:a_key</span>] <span class="c"># =&gt; 1</span>
+</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_square_brackets_for_specification">(<a href="javascript:show('square_brackets_for_specification')">show</a>)</span>
+         <pre class="source" id="square_brackets_for_specification">require <span class="s"><span class="dl">'</span><span class="k">square_brackets_for</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">square_brackets_for</span><span class="dl">'</span></span> <span class="r">do</span>
+
+  before <span class="r">do</span>
+    <span class="r">class</span> <span class="cl">Klass</span>
+      <span class="r">def</span> <span class="fu">initialize</span>
+        <span class="iv">@var</span> = {
+          <span class="sy">:a_key</span> =&gt; <span class="i">1</span>,
+          <span class="sy">:another_one</span> =&gt; <span class="i">2</span>,
+        }
+      <span class="r">end</span>
+
+      <span class="iv">@eigenvar</span> = {
+        <span class="sy">:a_key</span> =&gt; <span class="i">99</span>
+      }
+    <span class="r">end</span>
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should define a [] getter (not a setter) for an instance var, if the second parameter is false</span><span class="dl">'</span></span> <span class="r">do</span>
+
+    <span class="r">class</span> <span class="cl">Klass</span>
+      square_brackets_for <span class="sy">:var</span>, <span class="pc">nil</span>
+    <span class="r">end</span>
+
+    a = <span class="co">Klass</span>.new
+    a[<span class="sy">:a_key</span>].should == <span class="i">1</span>
+
+    proc <span class="r">do</span>
+      a[<span class="sy">:this_is</span>] = <span class="s"><span class="dl">'</span><span class="k">not possible</span><span class="dl">'</span></span>
+    <span class="r">end</span>.should raise_exception <span class="co">NoMethodError</span>
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should define [] and []= for accessing an instance variable</span><span class="dl">'</span></span> <span class="r">do</span>
+
+    <span class="r">class</span> <span class="cl">Klass</span>
+      square_brackets_for <span class="sy">:var</span>
+    <span class="r">end</span>
+
+    a = <span class="co">Klass</span>.new
+    a[<span class="sy">:a_key</span>].should == <span class="i">1</span>
+
+    a[<span class="sy">:this_is</span>] = <span class="s"><span class="dl">'</span><span class="k">useful</span><span class="dl">'</span></span>
+    a[<span class="sy">:this_is</span>].should == <span class="s"><span class="dl">'</span><span class="k">useful</span><span class="dl">'</span></span>
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should also work for class-instance variables</span><span class="dl">'</span></span> <span class="r">do</span>
+
+    <span class="r">class</span> <span class="cl">Klass</span>
+      <span class="r">class</span> &lt;&lt; <span class="cl">Klass</span>
+        square_brackets_for <span class="sy">:eigenvar</span>
+      <span class="r">end</span>
+    <span class="r">end</span>
+
+    <span class="co">Klass</span>[<span class="sy">:a_key</span>].should == <span class="i">99</span>
+  <span class="r">end</span>
+
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_square_brackets_for_source">(<a href="javascript:show('square_brackets_for_source')">show</a>)</span>
+         <pre class="source" id="square_brackets_for_source"><span class="r">def</span> <span class="fu">square_brackets_for</span>(ivar, assignment = <span class="pc">true</span>)
+<span class="c">#  undef []   if respond_to? :[]</span>
+<span class="c">#  undef []=  if respond_to? :[]=</span>
+
+<span class="c">#instance_eval do</span>
+  define_method <span class="sy">:[]</span> <span class="r">do</span> |key|
+    (instance_variable_get <span class="sy"><span class="sy">:</span><span class="dl">&quot;</span><span class="k">@</span><span class="il"><span class="idl">#{</span>ivar<span class="idl">}</span></span><span class="dl">&quot;</span></span>)[key]
+  <span class="r">end</span>
+
+  <span class="r">if</span> assignment
+    define_method <span class="sy">:[]=</span> <span class="r">do</span> |key, value|
+      (instance_variable_get <span class="sy"><span class="sy">:</span><span class="dl">&quot;</span><span class="k">@</span><span class="il"><span class="idl">#{</span>ivar<span class="idl">}</span></span><span class="dl">&quot;</span></span>)[key] = value
+    <span class="r">end</span>
+  <span class="r">end</span>
+<span class="c">#end</span>
+
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/mm'">mm</h3>
+         <table class="cube_table"
+                id="mm_cube"
+                title="require 'zucker/1/mm'"> <tr><th>Summary</th>    <td><code>mm</code> displays an ordered public method list.</td></tr><tr><th>Why?</th>    <td>See some object's methods without those rarely used inherited methods</td></tr><tr><th>Methods/Usage</th>    <td><h5>Object#method_list, Object#mm</h5><pre class="usage source" style="display:block"><span class="s"><span class="dl">'</span><span class="k">test</span><span class="dl">'</span></span>.mm <span class="i">2</span> <span class="c"># outputs the list (2 levels deep)</span></pre></td></tr><tr><th>Further information</th>    <td>See http://rbjl.net/31-the-multi-mega-method-list for more information</td></tr><tr><th>Specification</th>    <td> <span id="show_mm_specification">(<a href="javascript:show('mm_specification')">show</a>)</span>
+         <pre class="source" id="mm_specification">require <span class="s"><span class="dl">'</span><span class="k">mm</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Object#method_list</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should display an ordered method list</span><span class="dl">'</span></span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_mm_source">(<a href="javascript:show('mm_source')">show</a>)</span>
+         <pre class="source" id="mm_source"><span class="r">module</span> <span class="cl">Kernel</span>
+  <span class="r">def</span> <span class="fu">method_list</span>(levels = <span class="i">1</span>)
+    <span class="r">if</span> <span class="pc">self</span>.is_a? <span class="co">Module</span>
+      klass, method_function = <span class="pc">self</span>, <span class="sy">:public_methods</span>
+    <span class="r">else</span>
+      klass, method_function = <span class="pc">self</span>.class, <span class="sy">:public_instance_methods</span>
+
+      eigen = <span class="pc">self</span>.singleton_methods
+      <span class="r">if</span> !eigen.empty?
+        puts <span class="sy">:Eigenclass</span> <span class="c"># sorry for not being up to date, I just love the word</span>
+        p <span class="pc">self</span>.singleton_methods
+      <span class="r">end</span>
+    <span class="r">end</span>
+
+    levels.times{ |level|
+      <span class="r">if</span> cur = klass.ancestors[level]
+        p cur                               <span class="c"># put class name</span>
+        p cur.send method_function, <span class="pc">false</span>   <span class="c"># put methods of the class</span>
+      <span class="r">else</span>
+        <span class="r">break</span>
+      <span class="r">end</span>
+    }
+
+    <span class="pc">self</span> <span class="c"># or whatever</span>
+  <span class="r">end</span>
+
+  <span class="r">alias</span> <span class="fu">mm</span> <span class="fu">method_list</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/regexp2proc'">regexp2proc</h3>
+         <table class="cube_table"
+                id="regexp2proc_cube"
+                title="require 'zucker/1/regexp2proc'"> <tr><th>Summary</th>    <td>Use &/regex/ to match it against strings</td></tr><tr><th>Methods/Usage</th>    <td><h5>Regexp#to_proc</h5><pre class="usage source" style="display:block"><span class="s"><span class="dl">%w|</span><span class="k">just another string array</span><span class="dl">|</span></span>.map    &amp;<span class="rx"><span class="dl">/</span><span class="k">[jy]</span><span class="dl">/</span></span>  <span class="c"># =&gt; [&quot;j&quot;, nil, nil, &quot;y&quot;]</span>
+<span class="s"><span class="dl">%w|</span><span class="k">just another string array</span><span class="dl">|</span></span>.select &amp;<span class="rx"><span class="dl">/</span><span class="k">[jy]</span><span class="dl">/</span></span>  <span class="c"># =&gt; [&quot;just&quot;, &quot;array&quot;]</span>
+</pre></td></tr><tr><th>Further information</th>    <td>More about to_proc: http://rbjl.net/29-become-a-proc-star</td></tr><tr><th>Specification</th>    <td> <span id="show_regexp2proc_specification">(<a href="javascript:show('regexp2proc_specification')">show</a>)</span>
+         <pre class="source" id="regexp2proc_specification">require <span class="s"><span class="dl">'</span><span class="k">regexp2proc</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Regexp#to_proc</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should match the regex</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="s"><span class="dl">%w|</span><span class="k">just another string array</span><span class="dl">|</span></span>.map(     &amp;<span class="rx"><span class="dl">/</span><span class="k">[jy]</span><span class="dl">/</span></span>).should == [<span class="s"><span class="dl">&quot;</span><span class="k">j</span><span class="dl">&quot;</span></span>, <span class="pc">nil</span>, <span class="pc">nil</span>, <span class="s"><span class="dl">&quot;</span><span class="k">y</span><span class="dl">&quot;</span></span>]
+    <span class="s"><span class="dl">%w|</span><span class="k">just another string array</span><span class="dl">|</span></span>.select(  &amp;<span class="rx"><span class="dl">/</span><span class="k">[jy]</span><span class="dl">/</span></span>).should == [<span class="s"><span class="dl">&quot;</span><span class="k">just</span><span class="dl">&quot;</span></span>, <span class="s"><span class="dl">&quot;</span><span class="k">array</span><span class="dl">&quot;</span></span>]
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_regexp2proc_source">(<a href="javascript:show('regexp2proc_source')">show</a>)</span>
+         <pre class="source" id="regexp2proc_source"><span class="r">class</span> <span class="cl">Regexp</span>
+  <span class="r">def</span> <span class="fu">to_proc</span>
+    proc <span class="r">do</span> |e|
+      e.to_s[<span class="pc">self</span>]
+    <span class="r">end</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/mcopy'">mcopy</h3>
+         <table class="cube_table"
+                id="mcopy_cube"
+                title="require 'zucker/1/mcopy'"> <tr><th>Summary</th>    <td>Adds <code>Object#mcopy</code> to create a deep copy using <code>Marshal</code>.</td></tr><tr><th>Why?</th>    <td>Every Ruby book describes, you can do <code>Marshal.load Marshal.dump object</code> to create a deep copy... But who needs this verbose syntax in everyday coding?</td></tr><tr><th>Methods/Usage</th>    <td><h5>Object#mcopy</h5><pre class="usage source" style="display:block">a = <span class="s"><span class="dl">%w[</span><span class="k">hello world</span><span class="dl">]</span></span>
+b = a.mcopy
+</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_mcopy_specification">(<a href="javascript:show('mcopy_specification')">show</a>)</span>
+         <pre class="source" id="mcopy_specification">require <span class="s"><span class="dl">'</span><span class="k">mcopy</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Object#mcopy</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">create a (deep) copy via marshalling</span><span class="dl">'</span></span> <span class="r">do</span>
+    a = <span class="s"><span class="dl">%w[</span><span class="k">hello world</span><span class="dl">]</span></span>
+    b = a.mcopy
+    b.should == a
+
+    b[<span class="i">0</span>][<span class="i">1</span>,<span class="i">1</span>] = <span class="s"><span class="dl">'</span><span class="dl">'</span></span>
+    b.should_not == a
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_mcopy_source">(<a href="javascript:show('mcopy_source')">show</a>)</span>
+         <pre class="source" id="mcopy_source"><span class="r">class</span> <span class="cl">Object</span>
+  <span class="r">def</span> <span class="fu">mcopy</span>
+    <span class="co">Marshal</span>.load <span class="co">Marshal</span>.dump <span class="pc">self</span>
+  <span class="r">end</span>
+  <span class="c"># alias copy mcopy</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/hash2proc'">hash2proc</h3>
+         <table class="cube_table"
+                id="hash2proc_cube"
+                title="require 'zucker/1/hash2proc'"> <tr><th>Summary</th>    <td>Use a hash to apply procs to specific objects.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Hash#to_proc</h5><pre class="usage source" style="display:block">[<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>].map(&amp;{
+<span class="i">2</span> =&gt; lambda {|e| e + <span class="i">1000</span>},
+<span class="i">4</span> =&gt; <span class="sy">:to_s</span>,
+}) <span class="c"># =&gt; [1, 1002, 3, '4']</span></pre></td></tr><tr><th>Further information</th>    <td>More about to_proc: http://rbjl.net/29-become-a-proc-star</td></tr><tr><th>Specification</th>    <td> <span id="show_hash2proc_specification">(<a href="javascript:show('hash2proc_specification')">show</a>)</span>
+         <pre class="source" id="hash2proc_specification">require <span class="s"><span class="dl">'</span><span class="k">hash2proc</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Hash#to_proc</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should run the proc given in the value for a key in the hash</span><span class="dl">'</span></span> <span class="r">do</span>
+    [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>].map(&amp;{
+      <span class="i">4</span> =&gt; <span class="sy">:to_s</span>,
+      <span class="c"># 3 =&gt; [:to_s, 2]  # &quot;11&quot; =&gt;  if array2proc is used</span>
+      <span class="i">2</span> =&gt; lambda {|e| e + <span class="i">1000</span>}
+    }).should == [<span class="i">1</span>, <span class="i">1002</span>, <span class="i">3</span>, <span class="s"><span class="dl">&quot;</span><span class="k">4</span><span class="dl">&quot;</span></span>]
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_hash2proc_source">(<a href="javascript:show('hash2proc_source')">show</a>)</span>
+         <pre class="source" id="hash2proc_source"><span class="r">class</span> <span class="cl">Hash</span>
+  <span class="r">def</span> <span class="fu">to_proc</span>
+    <span class="co">Proc</span>.new{ |obj|
+      <span class="r">if</span> <span class="pc">self</span>.member? obj
+        <span class="pc">self</span>[obj].to_proc.call obj
+      <span class="r">else</span>
+        obj
+      <span class="r">end</span>
+    }
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/enumerable'">enumerable</h3>
+         <table class="cube_table"
+                id="enumerable_cube"
+                title="require 'zucker/1/enumerable'"> <tr><th>Summary</th>    <td><code>Enumerable</code> extensions.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Enumerable#mash</h5><pre class="usage source" style="display:block">[<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>].mash{|e| [e, e.to_s] } <span class="c"># =&gt; {1=&gt;'1',2=&gt;'2',3=&gt;'3'}</span></pre></td></tr><tr><th>Further information</th>    <td>Inspired by Ruby Facets' mash</td></tr><tr><th>Specification</th>    <td> <span id="show_enumerable_specification">(<a href="javascript:show('enumerable_specification')">show</a>)</span>
+         <pre class="source" id="enumerable_specification">require <span class="s"><span class="dl">'</span><span class="k">enumerable</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Enumerable#mash</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should &quot;map&quot; a hash</span><span class="dl">'</span></span> <span class="r">do</span>
+    [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>].mash{|e| [e, e.to_s] }.should == {<span class="i">1</span>=&gt;<span class="s"><span class="dl">'</span><span class="k">1</span><span class="dl">'</span></span>,<span class="i">2</span>=&gt;<span class="s"><span class="dl">'</span><span class="k">2</span><span class="dl">'</span></span>,<span class="i">3</span>=&gt;<span class="s"><span class="dl">'</span><span class="k">3</span><span class="dl">'</span></span>,}
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_enumerable_source">(<a href="javascript:show('enumerable_source')">show</a>)</span>
+         <pre class="source" id="enumerable_source"><span class="r">module</span> <span class="cl">Enumerable</span>
+  <span class="r">def</span> <span class="fu">mash</span>
+    ret = {}
+    each{ |kv|
+      ret.store *( <span class="r">yield</span>(kv)[<span class="i">0</span>,<span class="i">2</span>] )
+    }
+    ret
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/union'">union</h3>
+         <table class="cube_table"
+                id="union_cube"
+                title="require 'zucker/1/union'"> <tr><th>Summary</th>    <td>Easy creation of <code>Regexp.union</code>s</td></tr><tr><th>Methods/Usage</th>    <td><h5>Regexp#|, String#|</h5><pre class="usage source" style="display:block"><span class="rx"><span class="dl">/</span><span class="k">Ruby</span><span class="ch">\d</span><span class="dl">/</span></span> | <span class="rx"><span class="dl">/</span><span class="k">test</span><span class="dl">/</span><span class="mod">i</span></span> | <span class="s"><span class="dl">&quot;</span><span class="k">cheat</span><span class="dl">&quot;</span></span>
+<span class="c"># creates a Regexp similar to:</span>
+<span class="c"># /(Ruby\d|[tT][eE][sS][tT]|cheat)/</span>
+</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_union_specification">(<a href="javascript:show('union_specification')">show</a>)</span>
+         <pre class="source" id="union_specification">require <span class="s"><span class="dl">'</span><span class="k">union</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Regexp#|</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should create an Regexp.union of both operands</span><span class="dl">'</span></span> <span class="r">do</span>
+    (<span class="rx"><span class="dl">/</span><span class="k">hallo</span><span class="dl">/</span></span> | <span class="rx"><span class="dl">/</span><span class="ch">\d</span><span class="k">+</span><span class="dl">/</span></span> | <span class="rx"><span class="dl">/</span><span class="k">.</span><span class="dl">/</span></span>).should ==
+      <span class="co">Regexp</span>.union( <span class="co">Regexp</span>.union(<span class="rx"><span class="dl">/</span><span class="k">hallo</span><span class="dl">/</span></span>, <span class="rx"><span class="dl">/</span><span class="ch">\d</span><span class="k">+</span><span class="dl">/</span></span>), <span class="rx"><span class="dl">/</span><span class="k">.</span><span class="dl">/</span></span> )
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">String#|</span><span class="dl">'</span></span> <span class="r">do</span>
+  it_should_behave_like <span class="s"><span class="dl">'</span><span class="k">Regexp#|</span><span class="dl">'</span></span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_union_source">(<a href="javascript:show('union_source')">show</a>)</span>
+         <pre class="source" id="union_source"><span class="r">class</span> <span class="cl">Regexp</span>
+  <span class="r">def</span> <span class="fu">|</span>(arg)
+    <span class="co">Regexp</span>.union <span class="pc">self</span>, arg.is_a?(<span class="co">Regexp</span>) ? arg : arg.to_s
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="r">class</span> <span class="cl">String</span>
+  <span class="r">def</span> <span class="fu">|</span>(arg)
+    <span class="co">Regexp</span>.union <span class="pc">self</span>, arg.is_a?(<span class="co">Regexp</span>) ? arg : arg.to_s
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9</td></tr></table> <h3 title="require 'zucker/1/kernel'">kernel</h3>
+         <table class="cube_table"
+                id="kernel_cube"
+                title="require 'zucker/1/kernel'"> <tr><th>Summary</th>    <td>Some useful general shortcut methods</td></tr><tr><th>Why?</th>    <td>Readability</td></tr><tr><th>Methods/Usage</th>    <td><h5>activate_warnings!</h5><pre class="usage source" style="display:block">activate_warnings! <span class="c"># sets $VERBOSE to 1</span></pre><h5>deactivate_warnings!</h5><pre class="usage source" style="display:block">deactivate_warnings! <span class="c"># sets $VERBOSE to 0</span></pre><h5>library?</h5><pre class="usage source" style="display:block">library? <span class="c"># checks, if the current file is ran directly</span></pre><h5>ignore_sigint!</h5><pre class="usage source" style="display:block">ignore_sigint! <span class="c"># blocks CTRL+C</span></pre></td></tr><tr><th>Specification</th>    <td> <span id="show_kernel_specification">(<a href="javascript:show('kernel_specification')">show</a>)</span>
+         <pre class="source" id="kernel_specification">require <span class="s"><span class="dl">'</span><span class="k">kernel</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">activate_warnings!</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should set $VERBOSE to true</span><span class="dl">'</span></span> <span class="r">do</span>
+    activate_warnings!
+    <span class="gv">$VERBOSE</span>.should == <span class="pc">true</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">deactivate_warnings!</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should set $VERBOSE to false</span><span class="dl">'</span></span> <span class="r">do</span>
+    deactivate_warnings!
+    <span class="gv">$VERBOSE</span>.should == <span class="pc">false</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">warnings_activated?</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should return $VERBOSE</span><span class="dl">'</span></span> <span class="r">do</span>
+    warnings_activated?.should == <span class="gv">$VERBOSE</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">library?</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should return false if the file is invoked directly</span><span class="dl">'</span></span> <span class="r">do</span>
+    library?.should == ( <span class="pc">__FILE__</span> != <span class="gv">$PROGRAM_NAME</span> )
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">ignore_sigint!</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should catch ctrl+c signals</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="c"># ...</span>
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_kernel_source">(<a href="javascript:show('kernel_source')">show</a>)</span>
+         <pre class="source" id="kernel_source"><span class="r">def</span> <span class="fu">activate_warnings!</span>
+  <span class="gv">$VERBOSE</span> = <span class="pc">true</span>
+<span class="r">end</span>
+
+<span class="r">def</span> <span class="fu">deactivate_warnings!</span>
+  <span class="gv">$VERBOSE</span> = <span class="pc">false</span>
+<span class="r">end</span>
+
+<span class="r">def</span> <span class="fu">warnings_activated?</span>
+  <span class="gv">$VERBOSE</span>
+<span class="r">end</span>
+
+<span class="r">def</span> <span class="fu">library?</span>
+  <span class="pc">__FILE__</span> != <span class="gv">$PROGRAM_NAME</span>
+<span class="r">end</span>
+
+<span class="r">def</span> <span class="fu">ignore_sigint!</span> <span class="c"># ctrl+c</span>
+   <span class="co">Signal</span>.trap *<span class="s"><span class="dl">%w|</span><span class="k">SIGINT IGNORE</span><span class="dl">|</span></span>
+<span class="r">end</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/hash'">hash</h3>
+         <table class="cube_table"
+                id="hash_cube"
+                title="require 'zucker/1/hash'"> <tr><th>Summary</th>    <td>Some sugar for dealing with hashs.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Hash.zip</h5><pre class="usage source" style="display:block"><span class="co">Hash</span>.zip [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>], [<span class="i">4</span>,<span class="i">5</span>,<span class="i">6</span>] <span class="c"># =&gt; {1 =&gt; 4, 2 =&gt; 5, 3 =&gt; 6}</span></pre><h5>Hash#<<</h5><pre class="usage source" style="display:block">{<span class="i">1</span> =&gt; <span class="i">2</span>} &lt;&lt; [<span class="i">3</span>, <span class="i">4</span>] <span class="c"># =&gt; {1 =&gt; 2, 3 =&gt; 4}</span></pre></td></tr><tr><th>Further information</th>    <td>Some of the operators are inspired by Ruby Facets</td></tr><tr><th>Specification</th>    <td> <span id="show_hash_specification">(<a href="javascript:show('hash_specification')">show</a>)</span>
+         <pre class="source" id="hash_specification">require <span class="s"><span class="dl">'</span><span class="k">hash</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Hash.zip</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should zip together both given enumerables and take them as key=&gt;values for a new hash</span><span class="dl">'</span></span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Hash#&lt;&lt;</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should append new elements to the hash</span><span class="dl">'</span></span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_hash_source">(<a href="javascript:show('hash_source')">show</a>)</span>
+         <pre class="source" id="hash_source"><span class="r">class</span> <span class="cl">Hash</span>
+  <span class="r">def</span> <span class="pc">self</span>.<span class="fu">zip</span>(keys,values)
+    <span class="co">Hash</span>[ *[<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>].zip( [<span class="i">4</span>,<span class="i">5</span>,<span class="i">6</span>] ).flatten ]
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">&lt;&lt;</span>(other)
+    <span class="r">case</span>
+    <span class="r">when</span> other.is_a?(<span class="co">Hash</span>)
+      merge! other
+    <span class="r">when</span> other.respond_to?(<span class="sy">:to_splat</span>)
+      merge! <span class="co">Hash</span>[*other]
+    <span class="r">else</span>
+      raise <span class="co">TypeError</span>, <span class="s"><span class="dl">'</span><span class="k">can only append other Hashs and Enumerables</span><span class="dl">'</span></span>
+    <span class="r">end</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/aliases'">aliases</h3>
+         <table class="cube_table"
+                id="aliases_cube"
+                title="require 'zucker/1/aliases'"> <tr><th>Summary</th>    <td>Some convenient aliases (and constants) for existing methods.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Object#is_an?</h5><pre class="usage source" style="display:block"><span class="co">Object</span>.is_a?</pre><h5>Enumerable#with</h5><pre class="usage source" style="display:block"><span class="co">Enumerable</span><span class="c">#zip</span></pre><h5>Enumerable#%</h5><pre class="usage source" style="display:block"><span class="co">Enumerable</span><span class="c">#zip</span></pre><h5>Array#**</h5><pre class="usage source" style="display:block"><span class="co">Array</span><span class="c">#product</span></pre><h5>Hash#+</h5><pre class="usage source" style="display:block"><span class="co">Hash</span><span class="c">#merge</span></pre><h5>Binding#[]</h5><pre class="usage source" style="display:block"><span class="co">Binding</span><span class="c">#eval</span></pre><h5>Infinity</h5><pre class="usage source" style="display:block"><span class="fl">1.0</span> / <span class="fl">0.0</span></pre><h5>NaN</h5><pre class="usage source" style="display:block"><span class="fl">0.0</span> / <span class="fl">0.0</span></pre></td></tr><tr><th>Specification</th>    <td> <span id="show_aliases_specification">(<a href="javascript:show('aliases_specification')">show</a>)</span>
+         <pre class="source" id="aliases_specification">require <span class="s"><span class="dl">'</span><span class="k">aliases</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">(aliases)</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should create these aliases [ sorry, no real spec for this one :P ] </span><span class="dl">'</span></span> <span class="r">do</span>
+  <span class="c"># alias is_an? is_a?</span>
+
+  <span class="c">#  module Enumerable</span>
+  <span class="c">#    alias with zip</span>
+  <span class="c">#    alias %    zip</span>
+  <span class="c">#  end</span>
+
+  <span class="c">#  class Array</span>
+  <span class="c">#    alias ** product</span>
+  <span class="c">#  end</span>
+
+  <span class="c">#  class Hash</span>
+  <span class="c">#    alias + merge</span>
+  <span class="c">#  end</span>
+
+  <span class="c">#  class Binding</span>
+  <span class="c">#    #alias [] eval</span>
+  <span class="c">#    def [](expr)</span>
+  <span class="c">#      self.eval &quot;#{expr}&quot;</span>
+  <span class="c">#    end</span>
+  <span class="c">#  end</span>
+
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should define these constants</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="co">Infinity</span>.finite?.should == <span class="pc">false</span>
+    <span class="co">NaN</span>.nan?.should         == <span class="pc">true</span>
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_aliases_source">(<a href="javascript:show('aliases_source')">show</a>)</span>
+         <pre class="source" id="aliases_source"><span class="r">alias</span> <span class="fu">is_an?</span> <span class="fu">is_a?</span>
+
+<span class="r">module</span> <span class="cl">Enumerable</span>
+  <span class="r">alias</span> <span class="fu">with</span> <span class="fu">zip</span>
+  <span class="r">alias</span> <span class="fu">%</span>    <span class="fu">zip</span>
+<span class="r">end</span>
+
+<span class="r">class</span> <span class="cl">Array</span>
+  <span class="r">alias</span> <span class="fu">**</span> <span class="fu">product</span>
+<span class="r">end</span>
+
+<span class="r">class</span> <span class="cl">Hash</span>
+  <span class="r">alias</span> <span class="fu">+</span> <span class="fu">merge</span>
+<span class="r">end</span>
+
+<span class="r">class</span> <span class="cl">Binding</span>
+  <span class="c">#alias [] eval</span>
+  <span class="r">def</span> <span class="fu">[]</span>(expr)
+    <span class="pc">self</span>.eval <span class="s"><span class="dl">&quot;</span><span class="il"><span class="idl">#{</span>expr<span class="idl">}</span></span><span class="dl">&quot;</span></span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># constants - who would use these in real-world code for other things?</span>
+<span class="co">Infinity</span> = <span class="fl">1.0</span> / <span class="fl">0.0</span> <span class="c"># or 2*Float::MAX</span>
+<span class="co">NaN</span>      = <span class="fl">0.0</span> / <span class="fl">0.0</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/sandbox'">sandbox</h3>
+         <table class="cube_table"
+                id="sandbox_cube"
+                title="require 'zucker/1/sandbox'"> <tr><th>Summary</th>    <td>Creates a sandbox area.</td></tr><tr><th>Why?</th>    <td>Ruby comes with sandboxes, but they are hidden (--> integrated) in the <code>$SAFE</code> concept</td></tr><tr><th>Methods/Usage</th>    <td><h5>sandbox</h5><pre class="usage source" style="display:block">sandbox <span class="r">do</span>
+  <span class="c"># dangerous commands throw SecurityErrors ($SAFE=4)</span>
+<span class="r">end</span>
+<span class="c"># everything's normal again</span>
+</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_sandbox_specification">(<a href="javascript:show('sandbox_specification')">show</a>)</span>
+         <pre class="source" id="sandbox_specification">require <span class="s"><span class="dl">'</span><span class="k">sandbox</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">sandbox</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should throw a SecurityError if bad commands are issued</span><span class="dl">'</span></span>
+  it <span class="s"><span class="dl">'</span><span class="k">should run the lambda passed as first parameter for errors, if it is given</span><span class="dl">'</span></span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_sandbox_source">(<a href="javascript:show('sandbox_source')">show</a>)</span>
+         <pre class="source" id="sandbox_source"><span class="r">def</span> <span class="fu">sandbox</span>(rescueblock=<span class="pc">nil</span>)
+  <span class="co">Thread</span>.start <span class="r">do</span>
+    <span class="gv">$SAFE</span> = <span class="i">4</span>
+    <span class="r">yield</span>
+  <span class="r">end</span>.value
+<span class="r">rescue</span> <span class="co">SecurityError</span> =&gt; e
+  <span class="r">if</span> rescueblock
+    rescueblock.call e
+  <span class="r">else</span>
+    raise e
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/blank'">blank</h3>
+         <table class="cube_table"
+                id="blank_cube"
+                title="require 'zucker/1/blank'"> <tr><th>Summary</th>    <td>Does pretty the same as in ActiveSupport (Every object can be asked if it is blank)</td></tr><tr><th>Why?</th>    <td>It's too familiar ;)</td></tr><tr><th>Methods/Usage</th>    <td><h5>Object#blank?</h5><pre class="usage source" style="display:block"><span class="s"><span class="dl">'</span><span class="k">an object</span><span class="dl">'</span></span>.blank? <span class="c"># =&gt; false</span></pre></td></tr><tr><th>Further information</th>    <td>See ActiveSupport</td></tr><tr><th>Specification</th>    <td> <span id="show_blank_specification">(<a href="javascript:show('blank_specification')">show</a>)</span>
+         <pre class="source" id="blank_specification">require <span class="s"><span class="dl">'</span><span class="k">blank</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Object#blank?</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should be blank for blank values</span><span class="dl">'</span></span> <span class="r">do</span>
+    blank_values   = [ <span class="pc">nil</span>, <span class="pc">false</span>, <span class="s"><span class="dl">'</span><span class="dl">'</span></span>, <span class="s"><span class="dl">'</span><span class="k">   </span><span class="dl">'</span></span>, <span class="s"><span class="dl">&quot;</span><span class="k">  </span><span class="ch">\n</span><span class="ch">\t</span><span class="k">  </span><span class="ch">\r</span><span class="k"> </span><span class="dl">&quot;</span></span>, [], {}, <span class="rx"><span class="dl">/</span><span class="dl">/</span></span> ]
+
+    blank_values.each{ |blank|
+      blank.blank?.should == <span class="pc">true</span>
+    }
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should not be blank for non blank values</span><span class="dl">'</span></span> <span class="r">do</span>
+    present_values = [ <span class="co">Object</span>.new, <span class="pc">true</span>, <span class="i">0</span>, <span class="i">1</span>, <span class="s"><span class="dl">'</span><span class="k">a</span><span class="dl">'</span></span>, [<span class="pc">nil</span>], { <span class="pc">nil</span> =&gt; <span class="pc">nil</span> } ]
+
+    present_values.each{ |present|
+      present.blank?.should == <span class="pc">false</span>
+    }
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_blank_source">(<a href="javascript:show('blank_source')">show</a>)</span>
+         <pre class="source" id="blank_source"><span class="r">class</span> <span class="cl">Object</span>
+  <span class="r">def</span> <span class="fu">blank?</span>
+    <span class="r">if</span> respond_to? <span class="sy">:empty?</span> <span class="r">then</span> empty? <span class="r">else</span> !<span class="pc">self</span> <span class="r">end</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">present?</span>
+    !blank?
+  <span class="r">end</span>
+<span class="r">end</span>
+
+
+{ <span class="c"># what to do              # for which classes</span>
+  lambda{ <span class="pc">true</span> }         =&gt; [<span class="co">FalseClass</span>, <span class="co">NilClass</span>],
+  lambda{ <span class="pc">false</span> }        =&gt; [<span class="co">TrueClass</span>, <span class="co">Numeric</span>],
+  lambda{ empty? }       =&gt; [<span class="co">Array</span>, <span class="co">Hash</span>],
+  lambda{ <span class="pc">self</span> !~ <span class="rx"><span class="dl">/</span><span class="ch">\S</span><span class="dl">/</span></span> } =&gt; [<span class="co">String</span>],
+  lambda{ <span class="pc">self</span> == <span class="rx"><span class="dl">/</span><span class="dl">/</span></span>   } =&gt; [<span class="co">Regexp</span>],
+
+}.each{ |action, klass_array|
+  klass_array.each{ |klass|
+    klass.send <span class="sy">:define_method</span>, <span class="sy">:blank?</span>, &amp;action
+  }
+}
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/string'">string</h3>
+         <table class="cube_table"
+                id="string_cube"
+                title="require 'zucker/1/string'"> <tr><th>Summary</th>    <td><code>String</code> extensions.</td></tr><tr><th>Why?</th>    <td>Strings cannot be comfortable enough ;)</td></tr><tr><th>Methods/Usage</th>    <td><h5>String#^</h5><pre class="usage source" style="display:block"><span class="s"><span class="dl">'</span><span class="k">Yes vs No</span><span class="dl">'</span></span>^<span class="i">3</span> <span class="c"># =&gt; 'Yes'</span></pre><h5>String#lchomp</h5><pre class="usage source" style="display:block"><span class="s"><span class="dl">'</span><span class="k">   Yes</span><span class="dl">'</span></span>.lchomp  <span class="c"># =&gt; 'Yes'</span></pre><h5>String#lchomp!</h5><pre class="usage source" style="display:block"><span class="c"># mutable lchomp version</span></pre><h5>String#ords</h5><pre class="usage source" style="display:block"><span class="s"><span class="dl">'</span><span class="k">Hallo</span><span class="dl">'</span></span>.ords <span class="c"># =&gt; [72, 97, 108, 108, 111]</span></pre></td></tr><tr><th>Specification</th>    <td> <span id="show_string_specification">(<a href="javascript:show('string_specification')">show</a>)</span>
+         <pre class="source" id="string_specification">require <span class="s"><span class="dl">'</span><span class="k">string</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">String#^</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should give C-like substring access to strings</span><span class="dl">'</span></span> <span class="r">do</span>
+    string = <span class="s"><span class="dl">'</span><span class="k">Theoretische Informatik ist voll geil!</span><span class="dl">'</span></span>
+
+    (string|<span class="i">0</span>).should  == <span class="s"><span class="dl">'</span><span class="k">Theoretische Informatik ist voll geil!</span><span class="dl">'</span></span>
+    (string|<span class="i">1</span>).should  == <span class="s"><span class="dl">'</span><span class="k">heoretische Informatik ist voll geil!</span><span class="dl">'</span></span>
+    (string|<span class="i">13</span>).should == <span class="s"><span class="dl">'</span><span class="k">Informatik ist voll geil!</span><span class="dl">'</span></span>
+    (string|<span class="i">-1</span>).should == <span class="s"><span class="dl">'</span><span class="k">Theoretische Informatik ist voll geil</span><span class="dl">'</span></span>
+    (string|<span class="i">38</span>).should == <span class="s"><span class="dl">'</span><span class="dl">'</span></span>
+    (string|<span class="i">99</span>).should == <span class="pc">nil</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">String#lchomp</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should chomp on the left side</span><span class="dl">'</span></span> <span class="r">do</span>
+    string = <span class="s"><span class="dl">'</span><span class="k">Theoretische Informatik ist voll geil!</span><span class="dl">'</span></span>
+    string.lchomp(<span class="s"><span class="dl">'</span><span class="k">T</span><span class="dl">'</span></span>).should  == <span class="s"><span class="dl">'</span><span class="k">heoretische Informatik ist voll geil!</span><span class="dl">'</span></span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">String#ords</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should unpack characters</span><span class="dl">'</span></span> <span class="r">do</span>
+    string = <span class="s"><span class="dl">'</span><span class="k">Theoretische Informatik ist voll geil!</span><span class="dl">'</span></span>
+    string.ords.should  == [<span class="i">84</span>, <span class="i">104</span>, <span class="i">101</span>, <span class="i">111</span>, <span class="i">114</span>, <span class="i">101</span>, <span class="i">116</span>, <span class="i">105</span>, <span class="i">115</span>, <span class="i">99</span>, <span class="i">104</span>, <span class="i">101</span>, <span class="i">32</span>, <span class="i">73</span>, <span class="i">110</span>, <span class="i">102</span>, <span class="i">111</span>, <span class="i">114</span>, <span class="i">109</span>, <span class="i">97</span>, <span class="i">116</span>, <span class="i">105</span>, <span class="i">107</span>, <span class="i">32</span>, <span class="i">105</span>, <span class="i">115</span>, <span class="i">116</span>, <span class="i">32</span>, <span class="i">118</span>, <span class="i">111</span>, <span class="i">108</span>, <span class="i">108</span>, <span class="i">32</span>, <span class="i">103</span>, <span class="i">101</span>, <span class="i">105</span>, <span class="i">108</span>, <span class="i">33</span>]
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_string_source">(<a href="javascript:show('string_source')">show</a>)</span>
+         <pre class="source" id="string_source"><span class="r">class</span> <span class="cl">String</span>
+  <span class="r">def</span> <span class="fu">^</span>(pos)
+    pos = pos.to_i
+    <span class="r">if</span> pos &gt;= <span class="i">0</span>
+      <span class="pc">self</span>[pos..<span class="i">-1</span>]
+    <span class="r">else</span>
+      <span class="pc">self</span>[<span class="i">0</span>...pos]
+    <span class="r">end</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">lchomp</span>(arg=<span class="gv">$/</span>)
+    <span class="pc">self</span>.reverse.chomp(arg).reverse
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">lchomp!</span>(arg=<span class="gv">$/</span>)
+    <span class="pc">self</span>.reverse.chomp!(arg).reverse
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">ords</span>
+    <span class="pc">self</span>.unpack <span class="s"><span class="dl">'</span><span class="k">C*</span><span class="dl">'</span></span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/binding'">binding</h3>
+         <table class="cube_table"
+                id="binding_cube"
+                title="require 'zucker/1/binding'"> <tr><th>Summary</th>    <td>Adds a verbose Binding#inspect</td></tr><tr><th>Why?</th>    <td>It gives you information about the current environment</td></tr><tr><th>Methods/Usage</th>    <td><h5>Binding#inspect</h5><pre class="usage source" style="display:block">binding.inspect</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_binding_specification">(<a href="javascript:show('binding_specification')">show</a>)</span>
+         <pre class="source" id="binding_specification">require <span class="s"><span class="dl">'</span><span class="k">binding</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Binding#inspect</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should output the current environment</span><span class="dl">'</span></span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_binding_source">(<a href="javascript:show('binding_source')">show</a>)</span>
+         <pre class="source" id="binding_source"><span class="r">class</span> <span class="cl">Binding</span>
+  <span class="r">def</span> <span class="fu">inspect</span>
+    put_vars = lambda { |array|
+      <span class="r">if</span> array.empty?
+        <span class="s"><span class="dl">'</span><span class="k"> - none</span><span class="dl">'</span></span>
+      <span class="r">else</span>
+        array.map{|e| <span class="s"><span class="dl">&quot;</span><span class="k"> - </span><span class="il"><span class="idl">#{</span>e<span class="idl">}</span></span><span class="k">: </span><span class="il"><span class="idl">#{</span> <span class="pc">self</span>.eval <span class="s"><span class="dl">'</span><span class="k">#{e}</span><span class="dl">'</span></span><span class="idl">}</span></span><span class="dl">&quot;</span></span>}*<span class="s"><span class="dl">&quot;</span><span class="ch">\n</span><span class="dl">&quot;</span></span>
+      <span class="r">end</span>
+    }
+
+<span class="s"><span class="dl">&quot;</span><span class="il"><span class="idl">#{</span><span class="pc">self</span>.to_s<span class="idl">}</span></span><span class="k">
+local vars
+</span><span class="il"><span class="idl">#{</span> put_vars[ <span class="pc">self</span>.eval <span class="s"><span class="dl">'</span><span class="k">local_variables</span><span class="dl">'</span></span> ] <span class="idl">}</span></span><span class="k">
+(instance vars)
+</span><span class="il"><span class="idl">#{</span> put_vars[ <span class="pc">self</span>.eval <span class="s"><span class="dl">'</span><span class="k">instance_variables</span><span class="dl">'</span></span> ] <span class="idl">}</span></span><span class="k">
+self
+ - </span><span class="il"><span class="idl">#{</span><span class="pc">self</span>.eval <span class="s"><span class="dl">'</span><span class="k">self</span><span class="dl">'</span></span><span class="idl">}</span></span><span class="k">
+block_given?
+ - </span><span class="il"><span class="idl">#{</span><span class="pc">self</span>.eval <span class="s"><span class="dl">'</span><span class="k">block_given?</span><span class="dl">'</span></span><span class="idl">}</span></span><span class="dl">&quot;</span></span>
+
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/1/egonil'">egonil</h3>
+         <table class="cube_table"
+                id="egonil_cube"
+                title="require 'zucker/1/egonil'"> <tr><th>Summary</th>    <td>Creates a block, where <code>nil</code> does not raise <code>NoMethodError</code>s</td></tr><tr><th>Methods/Usage</th>    <td><h5>egonil, nn</h5><pre class="usage source" style="display:block">egonil <span class="r">do</span>
+  <span class="pc">nil</span>.some_methods.that[<span class="sy">:do</span>].not.exist
+<span class="r">end</span> <span class="c"># =&gt; nil</span>
+
+nn(<span class="i">5</span>){ <span class="pc">nil</span>.some_methods.that[<span class="sy">:do</span>].not.exist }
+<span class="c"># =&gt; 5</span>
+</pre></td></tr><tr><th>Further information</th>    <td>See http://rbjl.net/26-the-28-bytes-of-ruby-joy for more information and discussion</td></tr><tr><th>Specification</th>    <td> <span id="show_egonil_specification">(<a href="javascript:show('egonil_specification')">show</a>)</span>
+         <pre class="source" id="egonil_specification">require <span class="s"><span class="dl">'</span><span class="k">egonil</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">egonil</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should not raise nil exceptions in the block</span><span class="dl">'</span></span> <span class="r">do</span>
+    proc <span class="r">do</span>
+      egonil{ <span class="pc">nil</span>.some_methods.that[<span class="sy">:do</span>].not.exist }
+    <span class="r">end</span>.should_not raise_exception
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should return the nil_value if given</span><span class="dl">'</span></span> <span class="r">do</span>
+    egonil(<span class="i">9</span>){ <span class="pc">nil</span>.some_methods.that[<span class="sy">:do</span>].not.exist }.should == <span class="i">9</span>
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should restore default behaviour after the block</span><span class="dl">'</span></span> <span class="r">do</span>
+    proc <span class="r">do</span>
+      egonil{ <span class="pc">nil</span>.some_methods.that[<span class="sy">:do</span>].not.exist }
+    <span class="r">end</span>.should_not raise_exception
+
+    proc <span class="r">do</span>
+      <span class="pc">nil</span>.a_method
+    <span class="r">end</span>.should raise_exception <span class="co">NoMethodError</span>
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">raise NoMethodError for non-nil objects</span><span class="dl">'</span></span> <span class="r">do</span>
+    proc <span class="r">do</span>
+      egonil{ <span class="i">5</span>.a_method }
+    <span class="r">end</span>.should raise_exception <span class="co">NoMethodError</span>
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_egonil_source">(<a href="javascript:show('egonil_source')">show</a>)</span>
+         <pre class="source" id="egonil_source"><span class="r">def</span> <span class="fu">egonil</span>(nil_value = <span class="pc">nil</span>)
+  <span class="r">yield</span>
+<span class="r">rescue</span> <span class="co">NoMethodError</span> =&gt; e
+  <span class="r">if</span> e.message =~ <span class="rx"><span class="dl">/</span><span class="k">NilClass$</span><span class="dl">/</span></span>
+    nil_value
+  <span class="r">else</span>
+    raise <span class="co">NoMethodError</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="r">alias</span> <span class="fu">nn</span> <span class="fu">egonil</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table>
+      </div>
+<br/>
+    </div>
+  <div id="foot">
+    <div id="smile"><a href="http://rbjl.net">J-_-L</a></div>
+    This is the Ruby Zucker 1 documentation.
+    The current version is always available at <a href="http://rubyzucker.info">rubyzucker.info</a>.
+    Gem source at <a href="http://github.com/janlelis/zucker">github</a>.
+  </div>
+
+</body>
+</html>
+