zucker 1 → 2

data/lib/zucker/2/square_brackets_for.rb

@@ -0,0 +1,20 @@
+def square_brackets_for(ivar, assignment = true)
+#  undef []   if respond_to? :[]
+#  undef []=  if respond_to? :[]=
+
+#instance_eval do
+  define_method :[] do |key|
+    (instance_variable_get :"@#{ivar}")[key]
+  end
+
+  if assignment
+    define_method :[]= do |key, value|
+      (instance_variable_get :"@#{ivar}")[key] = value
+    end
+  end
+#end
+
+end
+
+# J-_-L
+

data/lib/zucker/2/string.rb

@@ -0,0 +1,25 @@
+class String
+  def ^(pos)
+    pos = pos.to_i
+    if pos >= 0
+      self[pos..-1]
+    else
+      self[0...pos]
+    end
+  end
+
+  def lchomp(arg=$/)
+    self.reverse.chomp(arg).reverse
+  end
+
+  def lchomp!(arg=$/)
+    self.reverse.chomp!(arg).reverse
+  end
+
+  def ords
+    self.unpack 'C*'
+  end
+end
+
+# J-_-L
+

data/lib/zucker/2/unary.rb

@@ -0,0 +1,22 @@
+class String
+  def +@
+    self
+  end
+
+  def -@
+    to_sym
+  end
+end
+
+class Symbol
+  def +@
+    to_s
+  end
+
+  def -@
+    self
+  end
+end
+
+# J-_-L
+

data/lib/zucker/2/union.rb

@@ -0,0 +1,14 @@
+class Regexp
+  def |(arg)
+    Regexp.union self, arg.is_a?(Regexp) ? arg : arg.to_s
+  end
+end
+
+class String
+  def |(arg)
+    Regexp.union self, arg.is_a?(Regexp) ? arg : arg.to_s
+  end
+end
+
+# J-_-L
+

data/lib/zucker/all.rb

@@ -1,6 +1,6 @@
 # require all the sugar ;)
 # see README for an explaination of what they do
 
-require 'zucker/1/default'
-require 'zucker/1/debug'
+require 'zucker/default'
+require 'zucker/debug'
 

data/lib/zucker/array2proc.rb

@@ -1,7 +1,13 @@
 class Array
   def to_proc
     Proc.new{ |obj|
-      obj.send *self
+      if self.first.is_a? Array
+        self.inject(obj){ |result, nested_array|
+          nested_array.to_proc.call result
+        }
+      else
+        obj.send *self
+      end
     }
   end
 end

data/lib/zucker/debug.rb

@@ -1,4 +1,4 @@
-require 'zucker/1/D'
-require 'zucker/1/mm'
-require 'zucker/1/binding'
+require 'zucker/D'
+require 'zucker/mm'
+require 'zucker/binding'
 

data/lib/zucker/default.rb

@@ -21,5 +21,5 @@ unary
 union
 |
 
-zucker.each{|rb| require "zucker/1/#{rb}"}
+zucker.each{|rb| require "zucker/#{rb}"}
 

data/lib/zucker/desc/D.yaml

@@ -16,7 +16,7 @@ D:
       # => 'Hello Earth'
   package: debug
   info:
-  - "This is inspired by the funny →⇧.tap⇧ method→http://moonbase.rydia.net/mental/blog/programming/eavesdropping-on-expressions→"
+  - "This is inspired by the funny →⇧.tap⇧ method→http://moonbase.rydia.net/mental/blog/programming/eavesdropping-on-expressions→."
   versions:
   - 1.9
   - 1.8

data/lib/zucker/desc/array.yaml

@@ -2,7 +2,7 @@ array:
   summary: Methods one could miss for ⇧Array⇧.
   why:
   - ⇧Array⇧ has ⇧&⇧ and ⇧|⇧, but why does it not have ⇧^⇧?
-  - ⇧sum⇧ is an alias for ⇧inject(:+)⇧, but it is just needed pretty often!
+  - ⇧sum⇧ is just an alias for ⇧inject(:+)⇧, but it is needed pretty often..
   methods:
     Array#^: "[1,2,3,4] ^ [3,4,5,6]  # => [1,2,5,6]"
     Array#sum: "[1,2,3,4,5].sum  # => 15"

data/lib/zucker/desc/array2proc.yaml

@@ -2,10 +2,14 @@ array2proc:
   summary: Calls the method named by the first paramenter and passes the other elements as paramaters.
   why: When using ⇧Symbol#to_proc⇧, you often wish to pass parameters.
   methods:
-    Array#to_proc: '[1,2,3,4].map( &[:to_s, 2] )  # => ["1", "10", "11", "100"]'
+    Array#to_proc: |
+      [1,2,3,4].map &[:*, 5] # => [5, 10, 15, 20]
+      # you can also chain them, if the first parameter is an Array
+      [1,2,3,4].map &[[:to_s, 2],[:+, 'b']]   # => ["1b", "10b", "11b", "100b"]
   info:
   - Inspired by →this article→http://www.sanityinc.com/articles/adding-array-to-proc-to-ruby→.
   - "More about →to_proc→http://rbjl.net/29-become-a-proc-star→."
+  - Chaining inspired by →eregon→http://github.com/eregon/Classes/blob/master/to_proc.rb→.
   package: default
   versions:
   - 1.9

data/lib/zucker/desc/binding.yaml

@@ -1,6 +1,6 @@
 binding:
-  summary: Adds a verbose Binding#inspect
-  why: It gives you information about the current environment
+  summary: Adds a verbose ⇧Binding#inspect⇧.
+  why: It gives you information about the current environment.
   methods:
     Binding#inspect: binding.inspect
   package: debug

data/lib/zucker/desc/blank.yaml

@@ -1,11 +1,9 @@
 blank:
-  summary: Does pretty the same as in ActiveSupport (Every object can be asked if it is blank)
+  summary: Does pretty the same as in ActiveSupport (Every object can be asked if it is blank).
   why: It's too familiar ;)
   methods:
     Object#blank?: "'an object'.blank? # => false"
   package: default
-  info:
-  - See ActiveSupport
   versions:
   - 1.9
   - 1.8

data/lib/zucker/desc/egonil.yaml

@@ -10,7 +10,7 @@ egonil:
       # => 5
   package: default
   info:
-  - See →this post→http://rbjl.net/26-the-28-bytes-of-ruby-joy→ for more information and discussion
+  - See →this post→http://rbjl.net/26-the-28-bytes-of-ruby-joy→ for more information and discussion.
   versions:
   - 1.9
   - 1.8

data/lib/zucker/desc/enumerable.yaml

@@ -4,7 +4,7 @@ enumerable:
     Enumerable#mash: "[1,2,3].mash{|e| [e, e.to_s] } # => {1=>'1',2=>'2',3=>'3'}"
   package: default
   info:
-  - Inspired by Ruby Facets' mash
+  - Inspired by Ruby Facets' ⇧mash⇧.
   versions:
   - 1.9
   - 1.8

data/lib/zucker/desc/hash.yaml

@@ -2,10 +2,12 @@ hash:
   summary: Some sugar for dealing with hashs.
   methods:
     Hash.zip: "Hash.zip [1,2,3], [4,5,6] # => {1 => 4, 2 => 5, 3 => 6}"
-    Hash#<<: "{1 => 2} << [3, 4] # => {1 => 2, 3 => 4}"
+    Hash#<<: |
+      {1 => 2} << [3, 4]   # => { 1 => 2, 3 => 4 }
+      {1 => 2} << { 5=>6 } # => { 1 => 2, 5 => 6 }
   package: default
   info:
-  - Some of the operators are inspired by Ruby Facets
+  - Some of the operators are inspired by Ruby Facets.
   versions:
   - 1.9
   - 1.8

data/lib/zucker/desc/info.yaml

@@ -0,0 +1,12 @@
+info:
+  summary: Access environment information with the ⇧Info⇧ module.
+  why: "You don't need to remember in which global variable, constant or special method the information you are searching for is hidden."
+  methods:
+    Info: |
+      # see the source file for the list of accessors
+      # you could also add them to the global namespace with: include Info
+  package: default
+  versions:
+  - 1.9
+  - 1.8 (not all information)
+

data/lib/zucker/desc/kernel.yaml

@@ -1,6 +1,6 @@
 kernel:
-  summary: Some useful general shortcut methods
-  why: Readability
+  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"

data/lib/zucker/desc/mm.yaml

@@ -1,12 +1,12 @@
 mm:
   summary: ⇧mm⇧ displays an ordered public method list.
-  why: See some object's methods without those rarely used inherited methods
+  why: See one 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 →this article→http://rbjl.net/31-the-multi-mega-method-list→ for more information
+  - See →this article→http://rbjl.net/31-the-multi-mega-method-list→ for more information.
   versions:
   - 1.9
-  - 1.8
+  - 1.8 (returns strings instead of symbols)
 

data/lib/zucker/desc/regexp2proc.yaml

@@ -1,5 +1,5 @@
 regexp2proc:
-  summary: Use &/regex/ to match it against strings
+  summary: Use &/regex/ to match it against strings.
   methods:
     Regexp#to_proc: |
       %w|just another string array|.map    &/[jy]/  # => ["j", nil, nil, "y"]

data/lib/zucker/desc/sandbox.yaml

@@ -1,12 +1,17 @@
 sandbox:
   summary: Creates a sandbox area.
-  why: Ruby comes with sandboxes, but they are hidden (--> integrated) in the ⇧$SAFE⇧ concept
+  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
+
+      sandbox( lambda{} ) do
+        # no Exception is thrown, if non-nil parameter is passed
+      end
+      # if it is a proc, it will be run instead, if an SecurityError gets raised
   package: default
   versions:
   - 1.9

data/lib/zucker/desc/string.yaml

@@ -1,6 +1,6 @@
 string:
   summary: ⇧String⇧ extensions.
-  why: Strings cannot be comfortable enough ;)
+  why: Strings cannot be comfortable enough ;).
   methods:
     String#^: "'Yes vs No'^3 # => 'Yes'"
     String#lchomp: "'   Yes'.lchomp  # => 'Yes'"

data/lib/zucker/desc/unary.yaml

@@ -1,6 +1,6 @@
 unary:
   summary: Easy conversion between strings and symbols.
-  why: "Sometimes, you do not care if you get a ⇧String⇧ or ⇧Symbol⇧ as input - but when analysing it, you often need to choose one format. A concise possibility for this conversion is using the unary operators ⇧String#-@⇧ and ⇧Symbol#+@⇧"
+  why: "Sometimes, you do not care if you get a ⇧String⇧ or ⇧Symbol⇧ as input - but when analysing it, you often need to choose one format. A concise possibility for this conversion is using the unary operators ⇧String#-@⇧ and ⇧Symbol#+@⇧."
   methods:
     String#+@: "+'was_string' # => 'was_string'"
     String#-@: "-'was_string' # => :was_string"
@@ -11,5 +11,5 @@ unary:
   - "Inspired by (I've seen the unary + for Symbol somewhere on the net... but cannot remember where...)"
   versions:
   - 1.9
-  - 1.8 (+:literal not possible)
+  - 1.8 (⇧+:literal⇧ not possible)
 

data/lib/zucker/desc/union.yaml

@@ -1,5 +1,5 @@
 union:
-  summary: Easy creation of ⇧Regexp.union⇧s
+  summary: Easy creation of ⇧Regexp.union⇧s.
   methods:
     Regexp#|, String#|: |
       /Ruby\d/ | /test/i | "cheat"

data/lib/zucker/doc/zucker_doc.html

@@ -5,7 +5,7 @@
 <head>
   <meta http-equiv="content-type" content="text/html;charset=UTF-8" />
 
-  <title>Ruby Zucker 1</title>
+  <title>Ruby Zucker 2</title>
   <script type="text/javascript">
     var show = function(snippet){
       document.getElementById( snippet ).style.display = 'block'
@@ -134,19 +134,12 @@ code, pre{
 
 .source{
   display:none;
-  border:1px solid #005;
-#  background:#111;
   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;
   background-color: #f8f8f8;
+  border:1px solid #005;
   border: 1px solid silver;
   font-family: 'Courier New', 'Terminal', monospace;
   color: #000;
@@ -298,9 +291,9 @@ table.source td { padding: 2px 4px; vertical-align: top; }
 <body>
   <div id="world">
 
-    <h1>Ruby Zucker 1</h1>
+    <h1>Ruby Zucker 2</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 sweet. Read <a href="http://rbjl.net/32-introducing-ruby-zucker-a-new-syntactical-sugar-gem">this blog post</a> for a little introduction.</p>
+      <p class="text">Zucker is the German word for sugar (<a href="http://www.forvo.com/word/zucker/">pronunciation</a>). It adds syntactical sugar in the form of independent, small scripts that make Ruby even more sweet. Read <a href="http://rbjl.net/32-introducing-ruby-zucker-a-new-syntactical-sugar-gem">this blog post</a> for a little introduction.</p>
 
       <h2>Install</h2>
       <p class="text">
@@ -321,97 +314,18 @@ table.source td { padding: 2px 4px; vertical-align: top; }
       <p class="text">You can also lock your require to a specific version of Zucker by simply putting the version before the cube name in this way:
       <code>require 'zucker/1/egonil'</code>. Future releases of the gem will include all previous (main) versions, so the behaviour of these directly required cubes will not change (except for critical bugs).</p>
 
-      <h2 title="require 'zucker/all'">Cubes</h2>
-      <div class="cubes">
-         <h3 title="require 'zucker/D'">D</h3>
-         <table class="cube_table"
-                id="D_cube"
-                title="require 'zucker/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 objects</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 <a href="http://moonbase.rydia.net/mental/blog/programming/eavesdropping-on-expressions"><code>.tap</code> method</a></td></tr><tr><th>Specification</th>    <td> <span id="show_D_spec">(<a href="javascript:show('D_spec')">show</a>)</span>
-         <pre class="source" id="D_spec">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/aliases'">aliases</h3>
+       
+      <h2 title="require 'zucker/default'">Cubes[default]</h2>
+        <div class="cubes">
+         <h3 title="require 'zucker/aliases'">aliases</h3>
          <table class="cube_table"
                 id="aliases_cube"
                 title="require 'zucker/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_spec">(<a href="javascript:show('aliases_spec')">show</a>)</span>
-         <pre class="source" id="aliases_spec">require <span class="s"><span class="dl">'</span><span class="k">aliases</span><span class="dl">'</span></span>
+         <pre class="source" id="aliases_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/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>
-
+  it <span class="s"><span class="dl">'</span><span class="k">should create these aliases</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="c"># see aliases.rb for aliase list</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>
@@ -448,8 +362,8 @@ describe <span class="s"><span class="dl">'</span><span class="k">(aliases)</spa
 <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/array'">array</h3>
          <table class="cube_table"
                 id="array_cube"
-                title="require 'zucker/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_spec">(<a href="javascript:show('array_spec')">show</a>)</span>
-         <pre class="source" id="array_spec">require <span class="s"><span class="dl">'</span><span class="k">array</span><span class="dl">'</span></span>
+                title="require 'zucker/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 just an alias for <code>inject(:+)</code>, but it is 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_spec">(<a href="javascript:show('array_spec')">show</a>)</span>
+         <pre class="source" id="array_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/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>
@@ -489,59 +403,40 @@ describe <span class="s"><span class="dl">'</span><span class="k">Array#chrs</sp
 <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/array2proc'">array2proc</h3>
          <table class="cube_table"
                 id="array2proc_cube"
-                title="require 'zucker/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 <a href="http://www.sanityinc.com/articles/adding-array-to-proc-to-ruby">this article</a>.<br/>More about <a href="http://rbjl.net/29-become-a-proc-star">to_proc</a>.</td></tr><tr><th>Specification</th>    <td> <span id="show_array2proc_spec">(<a href="javascript:show('array2proc_spec')">show</a>)</span>
-         <pre class="source" id="array2proc_spec">require <span class="s"><span class="dl">'</span><span class="k">array2proc</span><span class="dl">'</span></span>
+                title="require 'zucker/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">:*</span>, <span class="i">5</span>] <span class="c"># =&gt; [5, 10, 15, 20]</span>
+<span class="c"># you can also chain them, if the first parameter is an Array</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>],[<span class="sy">:+</span>, <span class="s"><span class="dl">'</span><span class="k">b</span><span class="dl">'</span></span>]]   <span class="c"># =&gt; [&quot;1b&quot;, &quot;10b&quot;, &quot;11b&quot;, &quot;100b&quot;]</span>
+</pre></td></tr><tr><th>Further information</th>    <td>Inspired by <a href="http://www.sanityinc.com/articles/adding-array-to-proc-to-ruby">this article</a>.<br/>More about <a href="http://rbjl.net/29-become-a-proc-star">to_proc</a>.<br/>Chaining inspired by <a href="http://github.com/eregon/Classes/blob/master/to_proc.rb">eregon</a>.</td></tr><tr><th>Specification</th>    <td> <span id="show_array2proc_spec">(<a href="javascript:show('array2proc_spec')">show</a>)</span>
+         <pre class="source" id="array2proc_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/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>
+
+  it <span class="s"><span class="dl">&quot;</span><span class="k">should convert each element to a proc and chain it, if the first parameter is an array</span><span class="dl">&quot;</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">:*</span>,<span class="i">2</span>],[<span class="sy">:+</span>,<span class="i">4</span>]] ).should == [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>].map{|i| i*<span class="i">2</span> + <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_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/binding'">binding</h3>
-         <table class="cube_table"
-                id="binding_cube"
-                title="require 'zucker/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_spec">(<a href="javascript:show('binding_spec')">show</a>)</span>
-         <pre class="source" id="binding_spec">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">if</span> <span class="pc">self</span>.first.is_a? <span class="co">Array</span>
+        <span class="pc">self</span>.inject(obj){ |result, nested_array|
+          nested_array.to_proc.call result
+        }
       <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>
+        obj.send *<span class="pc">self</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/blank'">blank</h3>
          <table class="cube_table"
                 id="blank_cube"
-                title="require 'zucker/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_spec">(<a href="javascript:show('blank_spec')">show</a>)</span>
-         <pre class="source" id="blank_spec">require <span class="s"><span class="dl">'</span><span class="k">blank</span><span class="dl">'</span></span>
+                title="require 'zucker/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>Specification</th>    <td> <span id="show_blank_spec">(<a href="javascript:show('blank_spec')">show</a>)</span>
+         <pre class="source" id="blank_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/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>
@@ -588,7 +483,7 @@ describe <span class="s"><span class="dl">'</span><span class="k">Object#blank?<
          <table class="cube_table"
                 id="class2proc_cube"
                 title="require 'zucker/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 <a href="http://rbjl.net/29-become-a-proc-star">to_proc</a>.</td></tr><tr><th>Specification</th>    <td> <span id="show_class2proc_spec">(<a href="javascript:show('class2proc_spec')">show</a>)</span>
-         <pre class="source" id="class2proc_spec">require <span class="s"><span class="dl">'</span><span class="k">class2proc</span><span class="dl">'</span></span>
+         <pre class="source" id="class2proc_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/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>
@@ -613,8 +508,8 @@ describe <span class="s"><span class="dl">'</span><span class="k">Class#to_proc<
 
 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 <a href="http://rbjl.net/26-the-28-bytes-of-ruby-joy">this post</a> for more information and discussion</td></tr><tr><th>Specification</th>    <td> <span id="show_egonil_spec">(<a href="javascript:show('egonil_spec')">show</a>)</span>
-         <pre class="source" id="egonil_spec">require <span class="s"><span class="dl">'</span><span class="k">egonil</span><span class="dl">'</span></span>
+</pre></td></tr><tr><th>Further information</th>    <td>See <a href="http://rbjl.net/26-the-28-bytes-of-ruby-joy">this post</a> for more information and discussion.</td></tr><tr><th>Specification</th>    <td> <span id="show_egonil_spec">(<a href="javascript:show('egonil_spec')">show</a>)</span>
+         <pre class="source" id="egonil_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/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>
@@ -658,8 +553,8 @@ describe <span class="s"><span class="dl">'</span><span class="k">egonil</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/enumerable'">enumerable</h3>
          <table class="cube_table"
                 id="enumerable_cube"
-                title="require 'zucker/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_spec">(<a href="javascript:show('enumerable_spec')">show</a>)</span>
-         <pre class="source" id="enumerable_spec">require <span class="s"><span class="dl">'</span><span class="k">enumerable</span><span class="dl">'</span></span>
+                title="require 'zucker/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' <code>mash</code>.</td></tr><tr><th>Specification</th>    <td> <span id="show_enumerable_spec">(<a href="javascript:show('enumerable_spec')">show</a>)</span>
+         <pre class="source" id="enumerable_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/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>
@@ -679,29 +574,38 @@ describe <span class="s"><span class="dl">'</span><span class="k">Enumerable#mas
 <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/hash'">hash</h3>
          <table class="cube_table"
                 id="hash_cube"
-                title="require 'zucker/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_spec">(<a href="javascript:show('hash_spec')">show</a>)</span>
-         <pre class="source" id="hash_spec">require <span class="s"><span class="dl">'</span><span class="k">hash</span><span class="dl">'</span></span>
+                title="require 'zucker/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>
+{<span class="i">1</span> =&gt; <span class="i">2</span>} &lt;&lt; { <span class="i">5</span>=&gt;<span class="i">6</span> } <span class="c"># =&gt; { 1 =&gt; 2, 5 =&gt; 6 }</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_spec">(<a href="javascript:show('hash_spec')">show</a>)</span>
+         <pre class="source" id="hash_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/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>
+  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">do</span>
+    <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>] ).should == { <span class="i">1</span>=&gt;<span class="i">4</span>, <span class="i">2</span>=&gt;<span class="i">5</span>, <span class="i">3</span>=&gt;<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">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>
+  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">do</span>
+    a =  { <span class="i">1</span>=&gt;<span class="i">4</span>, <span class="i">2</span>=&gt;<span class="i">5</span>, <span class="i">3</span>=&gt;<span class="i">6</span> }
+    a &lt;&lt; { <span class="i">4</span>=&gt;<span class="i">7</span> }
+    a &lt;&lt; [<span class="i">5</span>, <span class="i">8</span>]
+    a.should == { <span class="i">1</span>=&gt;<span class="i">4</span>, <span class="i">2</span>=&gt;<span class="i">5</span>, <span class="i">3</span>=&gt;<span class="i">6</span>, <span class="i">4</span>=&gt;<span class="i">7</span>, <span class="i">5</span>=&gt;<span class="i">8</span> }
+  <span class="r">end</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="co">Hash</span>[ *keys.zip( values ).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>)
+    <span class="r">when</span> other.is_a?(<span class="co">Enumerable</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>
+      raise <span class="co">TypeError</span>, <span class="s"><span class="dl">'</span><span class="k">can only append other Hashs and Enumerables (or Classes that implement to_splat)</span><span class="dl">'</span></span>
     <span class="r">end</span>
   <span class="r">end</span>
 <span class="r">end</span>
@@ -713,7 +617,7 @@ describe <span class="s"><span class="dl">'</span><span class="k">Hash#&lt;&lt;<
 <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 <a href="http://rbjl.net/29-become-a-proc-star">to_proc</a>.</td></tr><tr><th>Specification</th>    <td> <span id="show_hash2proc_spec">(<a href="javascript:show('hash2proc_spec')">show</a>)</span>
-         <pre class="source" id="hash2proc_spec">require <span class="s"><span class="dl">'</span><span class="k">hash2proc</span><span class="dl">'</span></span>
+         <pre class="source" id="hash2proc_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/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>
@@ -736,7 +640,182 @@ describe <span class="s"><span class="dl">'</span><span class="k">Hash#to_proc</
   <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/iterate'">iterate</h3>
+<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/info'">info</h3>
+         <table class="cube_table"
+                id="info_cube"
+                title="require 'zucker/info'"> <tr><th>Summary</th>    <td>Access environment information with the <code>Info</code> module.</td></tr><tr><th>Why?</th>    <td>You don't need to remember in which global variable, constant or special method the information you are searching for is hidden.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Info</h5><pre class="usage source" style="display:block"><span class="c"># see the source file for the list of accessors</span>
+<span class="c"># you could also add them to the global namespace with: include Info</span>
+</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_info_spec">(<a href="javascript:show('info_spec')">show</a>)</span>
+         <pre class="source" id="info_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/info</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Info</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should define accessors for global variables, constants and some special methods/keywords</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="c"># see sourcefile for the list</span>
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_info_source">(<a href="javascript:show('info_source')">show</a>)</span>
+         <pre class="source" id="info_source"><span class="r">module</span> <span class="cl">Info</span>
+  <span class="r">class</span> &lt;&lt; <span class="cl">Info</span>
+    <span class="c"># hash like access</span>
+    <span class="r">def</span> <span class="fu">[]</span>(what)
+      send what
+    <span class="r">end</span>
+
+    <span class="c"># TODO: maybe add a descriptions method</span>
+  <span class="r">end</span>
+
+  module_function
+
+  <span class="c"># current script file</span>
+  <span class="r">def</span> <span class="fu">current_file</span>
+    <span class="pc">__FILE__</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">current_file_directory</span>
+    <span class="co">File</span>.dirname(<span class="pc">__FILE__</span>)
+  <span class="r">end</span>
+
+  <span class="c"># input</span>
+  <span class="r">def</span> <span class="fu">last_input_file</span>
+    <span class="gv">$FILENAME</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">last_input_line_number</span>
+    <span class="gv">$.</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">last_input</span>
+    <span class="gv">$_</span>
+  <span class="r">end</span>
+
+  <span class="c"># program</span>
+  <span class="r">def</span> <span class="fu">program_name</span>
+    <span class="gv">$0</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">program_arguments</span>
+    <span class="gv">$:</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">loaded_programs</span>
+    <span class="gv">$&quot;</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">program_data</span>
+    ::<span class="co">DATA</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">child_program_status</span>
+    <span class="gv">$CHILD_STATUS</span>
+  <span class="r">end</span>
+
+  <span class="c"># system info</span>
+  <span class="r">def</span> <span class="fu">environment</span>
+    ::<span class="co">ENV</span>
+  <span class="r">end</span>
+  <span class="r">alias</span> <span class="fu">env</span> <span class="fu">environment</span>
+
+  <span class="r">def</span> <span class="fu">working_directory</span>
+    <span class="co">Dir</span>.pwd
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">platform</span>
+    ::<span class="co">RUBY_PLATFORM</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">process_id</span>
+    <span class="gv">$$</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">load_path</span>
+    <span class="gv">$:</span>
+  <span class="r">end</span>
+
+  <span class="c"># current</span>
+  <span class="r">def</span> <span class="fu">current_line</span>
+    <span class="pc">__LINE__</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">current_method</span> <span class="c"># 1.9</span>
+    __method__
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">current_callstack</span>
+    caller
+  <span class="r">end</span>
+
+  <span class="c"># dealing with strings</span>
+  <span class="r">def</span> <span class="fu">gets_separator</span>
+    <span class="gv">$/</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">join_separator</span>
+    <span class="gv">$,</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">print_separator</span>
+    <span class="gv">$,</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">split_separator</span>
+    <span class="gv">$;</span>
+  <span class="r">end</span>
+
+  <span class="c"># misc</span>
+  <span class="r">def</span> <span class="fu">security_level</span>
+    <span class="gv">$SAFE</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">debug_activated?</span>
+    <span class="gv">$DEBUG</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">last_exception</span>
+    <span class="gv">$!</span>
+  <span class="r">end</span>
+
+  <span class="c"># defined objects</span>
+  <span class="r">def</span> <span class="fu">global_variables</span>
+    global_variables
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">global_constants</span>
+    <span class="co">Object</span>.constants
+  <span class="r">end</span>
+
+  <span class="c"># encoding (1.9)</span>
+  <span class="r">def</span> <span class="fu">source_encoding</span>
+    __ENCODING__
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">external_encoding</span>
+    <span class="co">Encoding</span>.default_external
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">internal_encoding</span>
+    <span class="co">Encoding</span>.default_internal
+  <span class="r">end</span>
+
+  <span class="c"># ruby version info</span>
+  <span class="r">def</span> <span class="fu">ruby_version</span>
+    ::<span class="co">RUBY_VERSION</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">ruby_patchlevel</span>
+    ::<span class="co">RUBY_PATCHLEVEL</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">ruby_description</span>
+    ::<span class="co">RUBY_DESCRIPTION</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">ruby_release_date</span>
+    ::<span class="co">RUBY_RELEASE_DATE</span>
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8 (not all information)</td></tr></table> <h3 title="require 'zucker/iterate'">iterate</h3>
          <table class="cube_table"
                 id="iterate_cube"
                 title="require 'zucker/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|
@@ -747,7 +826,7 @@ describe <span class="s"><span class="dl">'</span><span class="k">Hash#to_proc</
 <span class="c">#  2,4</span>
 <span class="c">#  ,5</span>
 </pre></td></tr><tr><th>Specification</th>    <td> <span id="show_iterate_spec">(<a href="javascript:show('iterate_spec')">show</a>)</span>
-         <pre class="source" id="iterate_spec">require <span class="s"><span class="dl">'</span><span class="k">iterate</span><span class="dl">'</span></span>
+         <pre class="source" id="iterate_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/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>
@@ -831,7 +910,7 @@ describe <span class="s"><span class="dl">'</span><span class="k">Object#iterate
   instance_variables_from 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_spec">(<a href="javascript:show('ivars_spec')">show</a>)</span>
-         <pre class="source" id="ivars_spec">require <span class="s"><span class="dl">'</span><span class="k">ivars</span><span class="dl">'</span></span>
+         <pre class="source" id="ivars_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/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>
@@ -853,7 +932,7 @@ describe <span class="s"><span class="dl">'</span><span class="k">instance_varia
          <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] }
+    obj.eval(<span class="s"><span class="dl">'</span><span class="k">local_variables</span><span class="dl">'</span></span>).map{|e| [obj.eval(<span class="s"><span class="dl">&quot;</span><span class="il"><span class="idl">#{</span>e<span class="idl">}</span></span><span class="dl">&quot;</span></span>), 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>
@@ -877,8 +956,8 @@ describe <span class="s"><span class="dl">'</span><span class="k">instance_varia
 <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/kernel'">kernel</h3>
          <table class="cube_table"
                 id="kernel_cube"
-                title="require 'zucker/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_spec">(<a href="javascript:show('kernel_spec')">show</a>)</span>
-         <pre class="source" id="kernel_spec">require <span class="s"><span class="dl">'</span><span class="k">kernel</span><span class="dl">'</span></span>
+                title="require 'zucker/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_spec">(<a href="javascript:show('kernel_spec')">show</a>)</span>
+         <pre class="source" id="kernel_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/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>
@@ -894,12 +973,6 @@ describe <span class="s"><span class="dl">'</span><span class="k">deactivate_war
   <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> )
@@ -919,23 +992,21 @@ describe <span class="s"><span class="dl">'</span><span class="k">ignore_sigint!
   <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/mcopy'">mcopy</h3>
+<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/mcopy'">mcopy</h3>
          <table class="cube_table"
                 id="mcopy_cube"
                 title="require 'zucker/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_spec">(<a href="javascript:show('mcopy_spec')">show</a>)</span>
-         <pre class="source" id="mcopy_spec">require <span class="s"><span class="dl">'</span><span class="k">mcopy</span><span class="dl">'</span></span>
+         <pre class="source" id="mcopy_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/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>
@@ -954,51 +1025,13 @@ describe <span class="s"><span class="dl">'</span><span class="k">Object#mcopy</
   <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/mm'">mm</h3>
-         <table class="cube_table"
-                id="mm_cube"
-                title="require 'zucker/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 <a href="http://rbjl.net/31-the-multi-mega-method-list">this article</a> for more information</td></tr><tr><th>Specification</th>    <td> <span id="show_mm_spec">(<a href="javascript:show('mm_spec')">show</a>)</span>
-         <pre class="source" id="mm_spec">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/regexp2proc'">regexp2proc</h3>
          <table class="cube_table"
                 id="regexp2proc_cube"
-                title="require 'zucker/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>
+                title="require 'zucker/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 <a href="http://rbjl.net/29-become-a-proc-star">to_proc</a>.</td></tr><tr><th>Specification</th>    <td> <span id="show_regexp2proc_spec">(<a href="javascript:show('regexp2proc_spec')">show</a>)</span>
-         <pre class="source" id="regexp2proc_spec">require <span class="s"><span class="dl">'</span><span class="k">regexp2proc</span><span class="dl">'</span></span>
+         <pre class="source" id="regexp2proc_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/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>
@@ -1017,25 +1050,53 @@ describe <span class="s"><span class="dl">'</span><span class="k">Regexp#to_proc
 <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/sandbox'">sandbox</h3>
          <table class="cube_table"
                 id="sandbox_cube"
-                title="require 'zucker/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>
+                title="require 'zucker/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>
+
+sandbox( lambda{} ) <span class="r">do</span>
+  <span class="c"># no Exception is thrown, if non-nil parameter is passed</span>
+<span class="r">end</span>
+<span class="c"># if it is a proc, it will be run instead, if an SecurityError gets raised</span>
 </pre></td></tr><tr><th>Specification</th>    <td> <span id="show_sandbox_spec">(<a href="javascript:show('sandbox_spec')">show</a>)</span>
-         <pre class="source" id="sandbox_spec">require <span class="s"><span class="dl">'</span><span class="k">sandbox</span><span class="dl">'</span></span>
+         <pre class="source" id="sandbox_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/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>
+  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> <span class="r">do</span>
+    proc <span class="r">do</span>
+      sandbox <span class="r">do</span>
+        <span class="sh"><span class="dl">`</span><span class="k">ls</span><span class="dl">`</span></span>
+      <span class="r">end</span>
+    <span class="r">end</span>.should raise_exception <span class="co">SecurityError</span>
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should not throw an exception for errors, if the given parameter is not nil</span><span class="dl">'</span></span> <span class="r">do</span>
+    proc <span class="r">do</span>
+      sandbox( <span class="pc">true</span> ) <span class="r">do</span>
+        <span class="sh"><span class="dl">`</span><span class="k">ls</span><span class="dl">`</span></span>
+      <span class="r">end</span>
+    <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 run the proc passed as parameter for errors, if it is given</span><span class="dl">'</span></span> <span class="r">do</span>
+    sandbox( lambda{|e| e.class } ) <span class="r">do</span>
+      <span class="sh"><span class="dl">`</span><span class="k">ls</span><span class="dl">`</span></span>
+    <span class="r">end</span>.should == <span class="co">SecurityError</span>
+  <span class="r">end</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>)
+         <pre class="source" id="sandbox_source"><span class="r">def</span> <span class="fu">sandbox</span>(rescueblock_or_default=<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">if</span> !rescueblock_or_default.nil?
+    <span class="r">if</span> rescueblock_or_default.is_a? <span class="co">Proc</span>
+      rescueblock_or_default.call e
+    <span class="r">else</span>
+      rescueblock_or_default
+    <span class="r">end</span>
   <span class="r">else</span>
     raise e
   <span class="r">end</span>
@@ -1059,7 +1120,7 @@ describe <span class="s"><span class="dl">'</span><span class="k">sandbox</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_spec">(<a href="javascript:show('square_brackets_for_spec')">show</a>)</span>
-         <pre class="source" id="square_brackets_for_spec">require <span class="s"><span class="dl">'</span><span class="k">square_brackets_for</span><span class="dl">'</span></span>
+         <pre class="source" id="square_brackets_for_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/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>
 
@@ -1138,19 +1199,19 @@ describe <span class="s"><span class="dl">'</span><span class="k">square_bracket
 <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/string'">string</h3>
          <table class="cube_table"
                 id="string_cube"
-                title="require 'zucker/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_spec">(<a href="javascript:show('string_spec')">show</a>)</span>
-         <pre class="source" id="string_spec">require <span class="s"><span class="dl">'</span><span class="k">string</span><span class="dl">'</span></span>
+                title="require 'zucker/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_spec">(<a href="javascript:show('string_spec')">show</a>)</span>
+         <pre class="source" id="string_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/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>
+    (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>
 
@@ -1193,8 +1254,8 @@ describe <span class="s"><span class="dl">'</span><span class="k">String#ords</s
 <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/unary'">unary</h3>
          <table class="cube_table"
                 id="unary_cube"
-                title="require 'zucker/unary'"> <tr><th>Summary</th>    <td>Easy conversion between strings and symbols.</td></tr><tr><th>Why?</th>    <td>Sometimes, you do not care if you get a <code>String</code> or <code>Symbol</code> as input - but when analysing it, you often need to choose one format. A concise possibility for this conversion is using the unary operators <code>String#-@</code> and <code>Symbol#+@</code></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 (I've seen the unary + for Symbol somewhere on the net... but cannot remember where...)</td></tr><tr><th>Specification</th>    <td> <span id="show_unary_spec">(<a href="javascript:show('unary_spec')">show</a>)</span>
-         <pre class="source" id="unary_spec">require <span class="s"><span class="dl">'</span><span class="k">unary</span><span class="dl">'</span></span>
+                title="require 'zucker/unary'"> <tr><th>Summary</th>    <td>Easy conversion between strings and symbols.</td></tr><tr><th>Why?</th>    <td>Sometimes, you do not care if you get a <code>String</code> or <code>Symbol</code> as input - but when analysing it, you often need to choose one format. A concise possibility for this conversion is using the unary operators <code>String#-@</code> and <code>Symbol#+@</code>.</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 (I've seen the unary + for Symbol somewhere on the net... but cannot remember where...)</td></tr><tr><th>Specification</th>    <td> <span id="show_unary_spec">(<a href="javascript:show('unary_spec')">show</a>)</span>
+         <pre class="source" id="unary_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/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>
@@ -1239,24 +1300,26 @@ describe <span class="co">String</span>, <span class="s"><span class="dl">'</spa
   <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/union'">union</h3>
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8 (<code>+:literal</code> not possible)</td></tr></table> <h3 title="require 'zucker/union'">union</h3>
          <table class="cube_table"
                 id="union_cube"
-                title="require 'zucker/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>
+                title="require 'zucker/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_spec">(<a href="javascript:show('union_spec')">show</a>)</span>
-         <pre class="source" id="union_spec">require <span class="s"><span class="dl">'</span><span class="k">union</span><span class="dl">'</span></span>
+         <pre class="source" id="union_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/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> )
+shared_examples_for <span class="s"><span class="dl">&quot;</span><span class="k">Regexp.union operator</span><span class="dl">&quot;</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">&quot;</span><span class="k">should create an Regexp.union of both operands</span><span class="dl">&quot;</span></span> <span class="r">do</span>
   <span class="r">end</span>
 <span class="r">end</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_should_behave_like <span class="s"><span class="dl">'</span><span class="k">Regexp.union operator</span><span class="dl">'</span></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>
+  it_should_behave_like <span class="s"><span class="dl">'</span><span class="k">Regexp.union operator</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)
@@ -1271,12 +1334,157 @@ describe <span class="s"><span class="dl">'</span><span class="k">String#|</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>
-      </div>
+        </div> 
+      <h2 title="require 'zucker/debug'">Cubes[debug]</h2>
+        <div class="cubes">
+         <h3 title="require 'zucker/D'">D</h3>
+         <table class="cube_table"
+                id="D_cube"
+                title="require 'zucker/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 objects</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 <a href="http://moonbase.rydia.net/mental/blog/programming/eavesdropping-on-expressions"><code>.tap</code> method</a>.</td></tr><tr><th>Specification</th>    <td> <span id="show_D_spec">(<a href="javascript:show('D_spec')">show</a>)</span>
+         <pre class="source" id="D_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/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
+    }
+
+    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>
+
+  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>
+    capture_stdout <span class="r">do</span>
+      a[<span class="i">0</span>].<span class="co">D</span>
+      a[<span class="i">1</span>].<span class="co">D</span>
+      a[<span class="i">6</span>].<span class="co">D</span>
+    <span class="r">end</span>.should == <span class="s"><span class="dl">%{</span><span class="k">1</span><span class="ch">\n</span><span class="k">&quot;1&quot;</span><span class="ch">\n</span><span class="k">true</span><span class="ch">\n</span><span class="dl">}</span></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>
+    capture_stdout <span class="r">do</span>
+      a[<span class="i">0</span>].<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>}
+      a[<span class="i">1</span>].<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>}
+      a[<span class="i">6</span>].<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>}
+    <span class="r">end</span>.should == <span class="s"><span class="dl">%{</span><span class="k">This is a: 1</span><span class="ch">\n</span><span class="k">This is a: 1</span><span class="ch">\n</span><span class="k">This is a: true</span><span class="ch">\n</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_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/binding'">binding</h3>
+         <table class="cube_table"
+                id="binding_cube"
+                title="require 'zucker/binding'"> <tr><th>Summary</th>    <td>Adds a verbose <code>Binding#inspect</code>.</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_spec">(<a href="javascript:show('binding_spec')">show</a>)</span>
+         <pre class="source" id="binding_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/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">do</span>
+    pending <span class="s"><span class="dl">'</span><span class="k">#TODO: write spec</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_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/mm'">mm</h3>
+         <table class="cube_table"
+                id="mm_cube"
+                title="require 'zucker/mm'"> <tr><th>Summary</th>    <td><code>mm</code> displays an ordered public method list.</td></tr><tr><th>Why?</th>    <td>See one 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 <a href="http://rbjl.net/31-the-multi-mega-method-list">this article</a> for more information.</td></tr><tr><th>Specification</th>    <td> <span id="show_mm_spec">(<a href="javascript:show('mm_spec')">show</a>)</span>
+         <pre class="source" id="mm_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/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">do</span>
+    pending <span class="s"><span class="dl">'</span><span class="k">#TODO: write spec</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_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 (returns strings instead of symbols)</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.
+    This is the Ruby Zucker 2 documentation.
     The current version is always available at <a href="http://rubyzucker.info">rubyzucker.info</a>.
     Gem source can be found at <a href="http://github.com/janlelis/zucker">github</a>.
   </div>