zucker 0.9 → 1

data/lib/zucker/desc/kernel.yaml

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

data/lib/zucker/desc/mcopy.yaml

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

data/lib/zucker/desc/mm.yaml

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

data/lib/zucker/desc/regexp2proc.yaml

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

data/lib/zucker/desc/sandbox.yaml

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

data/lib/zucker/desc/square_brackets_for.yaml

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

data/lib/zucker/desc/string.yaml

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

data/lib/zucker/desc/unary.yaml

@@ -0,0 +1,15 @@
+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#+@⇧"
+  methods:
+    String#+@: "+'was_string' # => 'was_string'"
+    String#-@: "-'was_string' # => :was_string"
+    Symbol#+@: "+:was_symbol  # => 'was_symbol'"
+    Symbol#-@: "-:was_symbol  # => :was_symbol"
+  package: default
+  info:
+  - "Inspired by (I've seen the unary + for Symbol somewhere on the net... but cannot remember where...)"
+  versions:
+  - 1.9
+  - 1.8 (+:literal not possible)
+

data/lib/zucker/desc/union.yaml

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

data/lib/zucker/doc/meta.yaml

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

data/lib/zucker/doc/zucker_doc.html

@@ -0,0 +1,1286 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+       "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <meta http-equiv="content-type" content="text/html;charset=UTF-8" />
+
+  <title>Ruby Zucker 1</title>
+  <script type="text/javascript">
+    var show = function(snippet){
+      document.getElementById( snippet ).style.display = 'block'
+      if( document.getElementById( 'show_'+snippet ) ){
+        document.getElementById( 'show_'+snippet ).style.display = 'none'
+      }
+    }
+  </script>
+  <style type="text/css">
+body{
+  background-color:#aaa;
+  color:#111;
+  font-family:sans-serif;
+}
+
+#world{
+  background:#fff;
+}
+
+h1, h2, h3, h4, h5, h6{
+  margin:0px;
+  padding:0px;
+}
+
+h1{
+  color:#222;
+  text-align:center;
+  padding:0.5em;
+}
+h2{
+  margin-left:0.5em;
+  margin-top:0.8em;
+  margin-bottom:0.5em;
+}
+
+th{
+  width:200px;
+  color:#444;
+}
+
+p{
+  margin:0px;
+  margin-bottom:0.5em;
+}
+
+p.text{
+  margin-left:1.5em;
+  margin-right:1em;
+}
+
+code{
+}
+
+.scode{
+  display:block;
+  margin:0.8em;
+#  margin-right:1.8em;
+  padding:0.5em;
+  border:1px solid black;
+  background:#eee;
+}
+
+#.cube_table{
+#  display:none;
+#}
+.cubes{
+  margin:0px;
+  margin-left:1.5em;
+  margin-right:1em;
+}
+
+a{
+  color:#111;
+}
+
+table{
+  margin:0.8em;
+  margin-top:0.2em;
+  padding:0.2em;
+  border:1px solid #111;
+  background:#eee;
+  overflow:auto;
+  display:block;
+}
+
+th{
+  text-align:left;
+  vertical-align:top;
+  padding-right:3em;
+}
+
+td{
+  width:100%;
+}
+
+li{
+  list-style:none;
+}
+
+
+#foot{
+  text-align:left;
+  padding:0.3em;
+  font-size:70%
+}
+#foot, #foot a{
+  color:#444;
+}
+#smile{
+  font-size:150%;
+  float:right;
+}
+#smile a{
+  text-decoration:none;
+}
+
+.small{
+  font-size:70%;
+}
+
+code, pre{
+  font-face:mono;
+  margin:0px;
+  padding:0px;
+}
+
+.source{
+  display:none;
+  border:1px solid #005;
+#  background:#111;
+  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 silver;
+  font-family: 'Courier New', 'Terminal', monospace;
+  color: #000;
+}
+
+#/*railscasts*/
+#.source .an { color:#E7BE69 }                      /* html attribute */
+#.source .c  { color:#BC9358; font-style: italic; } /* comment */
+#.source .ch { color:#509E4F }                      /* escaped character */
+#.source .cl { color:#FFF }                         /* class */
+#.source .co { color:#FFF }                         /* constant */
+#.source .fl { color:#A4C260 }                      /* float */
+#.source .fu { color:#FFC56D }                      /* function */
+#.source .gv { color:#D0CFFE }                      /* global variable */
+#.source .i  { color:#A4C260 }                      /* integer */
+#.source .il { background:#151515 }                 /* inline code */
+#.source .iv { color:#D0CFFE }                      /* instance variable */
+#.source .pp { color:#E7BE69 }                      /* doctype */
+#.source .r  { color:#CB7832 }                      /* keyword */
+#.source .rx { color:#A4C260 }                      /* regex */
+#.source .s  { color:#A4C260 }                      /* string */
+#.source .sy { color:#6C9CBD }                      /* symbol */
+#.source .ta { color:#E7BE69 }                      /* html tag */
+#.source .pc { color:#6C9CBD }                      /* boolean */
+
+# http://coderay.rubychan.de/
+.source pre { margin: 0px; }
+
+span.source { white-space: pre; border: 0px; padding: 2px; }
+
+table.source { border-collapse: collapse; width: 100%; padding: 2px; }
+table.source td { padding: 2px 4px; vertical-align: top; }
+
+.source .line_numbers, .source .no {
+  background-color: #def;
+  color: gray;
+  text-align: right;
+}
+.source .line_numbers a:target, .source .no a:target { color: blue; }
+.source .line_numbers .highlighted, .source .no .highlighted { color: red; }
+.source .no { padding: 0px 4px; }
+.source .code { width: 100%; }
+.source .code pre { overflow: auto; }
+
+.source .debug { color:white ! important; background:blue ! important; }
+
+.source .an { color:#007 }
+.source .at { color:#f08 }
+.source .av { color:#700 }
+.source .bi { color:#509; font-weight:bold }
+.source .c  { color:#888; }
+.source .c .dl { color:#444; }
+.source .c .ch { color:#444; }
+
+.source .ch { color:#04D }
+.source .ch .k { color:#04D }
+.source .ch .dl { color:#039 }
+
+.source .cl { color:#B06; font-weight:bold }
+.source .cm { color:#A08; font-weight:bold }
+.source .co { color:#036; font-weight:bold }
+.source .cr { color:#0A0 }
+.source .cv { color:#369 }
+.source .de { color:#B0B; }
+.source .df { color:#099; font-weight:bold }
+.source .di { color:#088; font-weight:bold }
+.source .dl { color:black }
+.source .do { color:#970 }
+.source .dt { color:#34b }
+.source .ds { color:#D42; font-weight:bold }
+.source .e  { color:#666; font-weight:bold }
+.source .en { color:#800; font-weight:bold }
+.source .er { color:#F00; background-color:#FAA }
+.source .ex { color:#C00; font-weight:bold }
+.source .fl { color:#60E; font-weight:bold }
+.source .fu { color:#06B; font-weight:bold }
+.source .gv { color:#d70; font-weight:bold }
+.source .hx { color:#058; font-weight:bold }
+.source .i  { color:#00D; font-weight:bold }
+.source .ic { color:#B44; font-weight:bold }
+
+.source .il { background-color: hsla(0,0%,0%,0.1); color: black }
+.source .il .idl { font-weight: bold; color: #666 }
+.source .idl { font-weight: bold; background-color: hsla(0,0%,0%,0.1); color: #666; }
+
+.source .im { color:#f00; }
+.source .in { color:#B2B; font-weight:bold }
+.source .iv { color:#33B }
+.source .la { color:#970; font-weight:bold }
+.source .lv { color:#963 }
+.source .ns { color:#707; font-weight:bold }
+.source .oc { color:#40E; font-weight:bold }
+.source .op { }
+.source .pc { color:#058; font-weight:bold }
+.source .pd { color:#369; font-weight:bold }
+.source .pp { color:#579; }
+.source .ps { color:#00C; font-weight:bold }
+.source .pt { color:#074; font-weight:bold }
+.source .r, .kw  { color:#080; font-weight:bold }
+
+.source .ke { color: #808; }
+.source .ke .dl { color: #606; }
+.source .ke .ch { color: #80f; }
+.source .vl { color: #088; }
+
+.source .rx { background-color:hsla(300,100%,50%,0.1); }
+.source .rx .k { color:#808 }
+.source .rx .dl { color:#404 }
+.source .rx .mod { color:#C2C }
+.source .rx .fu  { color:#404; font-weight: bold }
+
+.source .s { background-color:hsla(0,100%,50%,0.1); }
+.source .s .k { color: #D20; }
+.source .s .ch { color: #b0b; }
+.source .s .dl { color: #710; }
+
+.source .sh { background-color:hsla(120,100%,50%,0.1); }
+.source .sh .k { color:#2B2 }
+.source .sh .dl { color:#161 }
+
+.source .sy { color:#A60 }
+.source .sy .k { color:#A60 }
+.source .sy .dl { color:#630 }
+
+.source .ta { color:#070 }
+.source .ts { color:#D70; font-weight:bold }
+.source .ty { color:#339; font-weight:bold }
+.source .v  { color:#036 }
+.source .xt { color:#444 }
+
+.source .ins { background: hsla(120,100%,50%,0.2) }
+.source .del { background: hsla(0,100%,50%,0.2) }
+.source .chg { color: #aaf; background: #007; }
+.source .head { color: #f8f; background: #505 }
+.source .head .filename { color: white; }
+
+.source .ins .eye { background-color: hsla(120,100%,50%,0.2) }
+.source .del .eye { background-color: hsla(0,100%,50%,0.2) }
+
+.source .ins .ins { color: #080; background:transparent; font-weight:bold }
+.source .del .del { color: #800; background:transparent; font-weight:bold }
+.source .chg .chg { color: #66f; }
+.source .head .head { color: #f4f; }
+
+
+
+  </style>
+</head>
+<body>
+  <div id="world">
+
+    <h1>Ruby Zucker 1</h1>
+      <h2>What is it?</h2>
+      <p class="text">Zucker is the German word for sugar (<a href="http://www.forvo.com/word/zucker/">pronunciation</a>). This gem adds syntactical sugar in the form of independent, lightweight scripts that make Ruby even more 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">
+        <code class="scode">gem install zucker # might need sudo</code>
+      </p>
+
+      <h2>Usage / Organisation</h2>
+      <p class="text">The gem consists of many small snippets, called <em>cubes</em>, which are bundled in <em>packages</em>. Currently, there are two packages available: <strong>default</strong> and <strong>debug</strong>. You can use a package be requiring it in this way:
+      <code class="scode">require 'zucker/default'</code>
+      and
+      <code class="scode">require 'zucker/debug'</code>
+
+      Since there aren't any dependencies within the gem, you could also pick only the cubes you want:
+
+      <code class="scode">require 'zucker/egonil'</code>
+      </p>
+
+      <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>
+         <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>
+
+describe <span class="s"><span class="dl">'</span><span class="k">(aliases)</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should create these aliases [ sorry, no real spec for this one :P ] </span><span class="dl">'</span></span> <span class="r">do</span>
+  <span class="c"># alias is_an? is_a?</span>
+
+  <span class="c">#  module Enumerable</span>
+  <span class="c">#    alias with zip</span>
+  <span class="c">#    alias %    zip</span>
+  <span class="c">#  end</span>
+
+  <span class="c">#  class Array</span>
+  <span class="c">#    alias ** product</span>
+  <span class="c">#  end</span>
+
+  <span class="c">#  class Hash</span>
+  <span class="c">#    alias + merge</span>
+  <span class="c">#  end</span>
+
+  <span class="c">#  class Binding</span>
+  <span class="c">#    #alias [] eval</span>
+  <span class="c">#    def [](expr)</span>
+  <span class="c">#      self.eval &quot;#{expr}&quot;</span>
+  <span class="c">#    end</span>
+  <span class="c">#  end</span>
+
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should define these constants</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="co">Infinity</span>.finite?.should == <span class="pc">false</span>
+    <span class="co">NaN</span>.nan?.should         == <span class="pc">true</span>
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_aliases_source">(<a href="javascript:show('aliases_source')">show</a>)</span>
+         <pre class="source" id="aliases_source"><span class="r">alias</span> <span class="fu">is_an?</span> <span class="fu">is_a?</span>
+
+<span class="r">module</span> <span class="cl">Enumerable</span>
+  <span class="r">alias</span> <span class="fu">with</span> <span class="fu">zip</span>
+  <span class="r">alias</span> <span class="fu">%</span>    <span class="fu">zip</span>
+<span class="r">end</span>
+
+<span class="r">class</span> <span class="cl">Array</span>
+  <span class="r">alias</span> <span class="fu">**</span> <span class="fu">product</span>
+<span class="r">end</span>
+
+<span class="r">class</span> <span class="cl">Hash</span>
+  <span class="r">alias</span> <span class="fu">+</span> <span class="fu">merge</span>
+<span class="r">end</span>
+
+<span class="r">class</span> <span class="cl">Binding</span>
+  <span class="c">#alias [] eval</span>
+  <span class="r">def</span> <span class="fu">[]</span>(expr)
+    <span class="pc">self</span>.eval <span class="s"><span class="dl">&quot;</span><span class="il"><span class="idl">#{</span>expr<span class="idl">}</span></span><span class="dl">&quot;</span></span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># constants - who would use these in real-world code for other things?</span>
+<span class="co">Infinity</span> = <span class="fl">1.0</span> / <span class="fl">0.0</span> <span class="c"># or 2*Float::MAX</span>
+<span class="co">NaN</span>      = <span class="fl">0.0</span> / <span class="fl">0.0</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/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>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Array#^</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should do an exclusive or</span><span class="dl">'</span></span> <span class="r">do</span>
+    a = [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>]
+    b = [<span class="i">3</span>,<span class="i">4</span>,<span class="i">5</span>,<span class="i">6</span>]
+    (a^b).should == [<span class="i">1</span>,<span class="i">2</span>,<span class="i">5</span>,<span class="i">6</span>]
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Array#sum</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should sum the array</span><span class="dl">'</span></span> <span class="r">do</span>
+    [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>,<span class="i">5</span>].sum.should   == <span class="i">15</span>
+    <span class="s"><span class="dl">%w|</span><span class="k">More Ruby</span><span class="dl">|</span></span>.sum.should == <span class="s"><span class="dl">'</span><span class="k">MoreRuby</span><span class="dl">'</span></span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Array#chrs</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should convert the array to a string, using each element as ord value for the char</span><span class="dl">'</span></span> <span class="r">do</span>
+    [<span class="i">72</span>, <span class="i">97</span>, <span class="i">108</span>, <span class="i">108</span>, <span class="i">111</span>].chrs.should == <span class="s"><span class="dl">'</span><span class="k">Hallo</span><span class="dl">'</span></span>
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_array_source">(<a href="javascript:show('array_source')">show</a>)</span>
+         <pre class="source" id="array_source"><span class="r">class</span> <span class="cl">Array</span>
+  <span class="r">def</span> <span class="fu">^</span>(other) <span class="c"># TODO: more efficient</span>
+    (<span class="pc">self</span> - other) +
+    (other - <span class="pc">self</span>)
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">sum</span> <span class="c"># sry, you just need this one too often</span>
+    inject <span class="sy">:+</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">chrs</span>
+    <span class="pc">self</span>.pack <span class="s"><span class="dl">'</span><span class="k">C*</span><span class="dl">'</span></span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/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>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Array#to_proc</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should call the method of the first symbol, using the remaining elements as paramaters</span><span class="dl">'</span></span> <span class="r">do</span>
+    [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>].map( &amp;[<span class="sy">:to_s</span>, <span class="i">2</span>] ).should == [<span class="s"><span class="dl">&quot;</span><span class="k">1</span><span class="dl">&quot;</span></span>, <span class="s"><span class="dl">&quot;</span><span class="k">10</span><span class="dl">&quot;</span></span>, <span class="s"><span class="dl">&quot;</span><span class="k">11</span><span class="dl">&quot;</span></span>, <span class="s"><span class="dl">&quot;</span><span class="k">100</span><span class="dl">&quot;</span></span>]
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_array2proc_source">(<a href="javascript:show('array2proc_source')">show</a>)</span>
+         <pre class="source" id="array2proc_source"><span class="r">class</span> <span class="cl">Array</span>
+  <span class="r">def</span> <span class="fu">to_proc</span>
+    <span class="co">Proc</span>.new{ |obj|
+      obj.send *<span class="pc">self</span>
+    }
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/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">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/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>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Object#blank?</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should be blank for blank values</span><span class="dl">'</span></span> <span class="r">do</span>
+    blank_values   = [ <span class="pc">nil</span>, <span class="pc">false</span>, <span class="s"><span class="dl">'</span><span class="dl">'</span></span>, <span class="s"><span class="dl">'</span><span class="k">   </span><span class="dl">'</span></span>, <span class="s"><span class="dl">&quot;</span><span class="k">  </span><span class="ch">\n</span><span class="ch">\t</span><span class="k">  </span><span class="ch">\r</span><span class="k"> </span><span class="dl">&quot;</span></span>, [], {}, <span class="rx"><span class="dl">/</span><span class="dl">/</span></span> ]
+
+    blank_values.each{ |blank|
+      blank.blank?.should == <span class="pc">true</span>
+    }
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should not be blank for non blank values</span><span class="dl">'</span></span> <span class="r">do</span>
+    present_values = [ <span class="co">Object</span>.new, <span class="pc">true</span>, <span class="i">0</span>, <span class="i">1</span>, <span class="s"><span class="dl">'</span><span class="k">a</span><span class="dl">'</span></span>, [<span class="pc">nil</span>], { <span class="pc">nil</span> =&gt; <span class="pc">nil</span> } ]
+
+    present_values.each{ |present|
+      present.blank?.should == <span class="pc">false</span>
+    }
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_blank_source">(<a href="javascript:show('blank_source')">show</a>)</span>
+         <pre class="source" id="blank_source"><span class="r">class</span> <span class="cl">Object</span>
+  <span class="r">def</span> <span class="fu">blank?</span>
+    <span class="r">if</span> respond_to? <span class="sy">:empty?</span> <span class="r">then</span> empty? <span class="r">else</span> !<span class="pc">self</span> <span class="r">end</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">present?</span>
+    !blank?
+  <span class="r">end</span>
+<span class="r">end</span>
+
+
+{ <span class="c"># what to do              # for which classes</span>
+  lambda{ <span class="pc">true</span> }         =&gt; [<span class="co">FalseClass</span>, <span class="co">NilClass</span>],
+  lambda{ <span class="pc">false</span> }        =&gt; [<span class="co">TrueClass</span>, <span class="co">Numeric</span>],
+  lambda{ empty? }       =&gt; [<span class="co">Array</span>, <span class="co">Hash</span>],
+  lambda{ <span class="pc">self</span> !~ <span class="rx"><span class="dl">/</span><span class="ch">\S</span><span class="dl">/</span></span> } =&gt; [<span class="co">String</span>],
+  lambda{ <span class="pc">self</span> == <span class="rx"><span class="dl">/</span><span class="dl">/</span></span>   } =&gt; [<span class="co">Regexp</span>],
+
+}.each{ |action, klass_array|
+  klass_array.each{ |klass|
+    klass.send <span class="sy">:define_method</span>, <span class="sy">:blank?</span>, &amp;action
+  }
+}
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/class2proc'">class2proc</h3>
+         <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>
+require <span class="s"><span class="dl">'</span><span class="k">set</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Class#to_proc</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should create new instances of the class</span><span class="dl">'</span></span> <span class="r">do</span>
+    [ [<span class="i">1</span>,<span class="i">2</span>],[<span class="i">3</span>,<span class="i">5</span>,<span class="i">6</span>,<span class="i">7</span>,<span class="i">3</span>] ].map(&amp;<span class="co">Set</span>).should == [ <span class="co">Set</span>[<span class="i">1</span>,<span class="i">2</span>], <span class="co">Set</span>[<span class="i">5</span>,<span class="i">6</span>,<span class="i">7</span>,<span class="i">3</span>] ]
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_class2proc_source">(<a href="javascript:show('class2proc_source')">show</a>)</span>
+         <pre class="source" id="class2proc_source"><span class="r">class</span> <span class="cl">Class</span>
+  <span class="r">def</span> <span class="fu">to_proc</span>
+    <span class="co">Proc</span>.new <span class="r">do</span> |*args|
+      <span class="pc">self</span>.new *args
+    <span class="r">end</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/egonil'">egonil</h3>
+         <table class="cube_table"
+                id="egonil_cube"
+                title="require 'zucker/egonil'"> <tr><th>Summary</th>    <td>Creates a block, where <code>nil</code> does not raise <code>NoMethodError</code>s.</td></tr><tr><th>Methods/Usage</th>    <td><h5>egonil, nn</h5><pre class="usage source" style="display:block">egonil <span class="r">do</span>
+  <span class="pc">nil</span>.some_methods.that[<span class="sy">:do</span>].not.exist
+<span class="r">end</span> <span class="c"># =&gt; nil</span>
+
+nn(<span class="i">5</span>){ <span class="pc">nil</span>.some_methods.that[<span class="sy">:do</span>].not.exist }
+<span class="c"># =&gt; 5</span>
+</pre></td></tr><tr><th>Further information</th>    <td>See <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>
+
+describe <span class="s"><span class="dl">'</span><span class="k">egonil</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should not raise nil exceptions in the block</span><span class="dl">'</span></span> <span class="r">do</span>
+    proc <span class="r">do</span>
+      egonil{ <span class="pc">nil</span>.some_methods.that[<span class="sy">:do</span>].not.exist }
+    <span class="r">end</span>.should_not raise_exception
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should return the nil_value if given</span><span class="dl">'</span></span> <span class="r">do</span>
+    egonil(<span class="i">9</span>){ <span class="pc">nil</span>.some_methods.that[<span class="sy">:do</span>].not.exist }.should == <span class="i">9</span>
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should restore default behaviour after the block</span><span class="dl">'</span></span> <span class="r">do</span>
+    proc <span class="r">do</span>
+      egonil{ <span class="pc">nil</span>.some_methods.that[<span class="sy">:do</span>].not.exist }
+    <span class="r">end</span>.should_not raise_exception
+
+    proc <span class="r">do</span>
+      <span class="pc">nil</span>.a_method
+    <span class="r">end</span>.should raise_exception <span class="co">NoMethodError</span>
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">raise NoMethodError for non-nil objects</span><span class="dl">'</span></span> <span class="r">do</span>
+    proc <span class="r">do</span>
+      egonil{ <span class="i">5</span>.a_method }
+    <span class="r">end</span>.should raise_exception <span class="co">NoMethodError</span>
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_egonil_source">(<a href="javascript:show('egonil_source')">show</a>)</span>
+         <pre class="source" id="egonil_source"><span class="r">def</span> <span class="fu">egonil</span>(nil_value = <span class="pc">nil</span>)
+  <span class="r">yield</span>
+<span class="r">rescue</span> <span class="co">NoMethodError</span> =&gt; e
+  <span class="r">if</span> e.message =~ <span class="rx"><span class="dl">/</span><span class="k">NilClass$</span><span class="dl">/</span></span>
+    nil_value
+  <span class="r">else</span>
+    raise <span class="co">NoMethodError</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="r">alias</span> <span class="fu">nn</span> <span class="fu">egonil</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <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>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Enumerable#mash</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should &quot;map&quot; a hash</span><span class="dl">'</span></span> <span class="r">do</span>
+    [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>].mash{|e| [e, e.to_s] }.should == {<span class="i">1</span>=&gt;<span class="s"><span class="dl">'</span><span class="k">1</span><span class="dl">'</span></span>,<span class="i">2</span>=&gt;<span class="s"><span class="dl">'</span><span class="k">2</span><span class="dl">'</span></span>,<span class="i">3</span>=&gt;<span class="s"><span class="dl">'</span><span class="k">3</span><span class="dl">'</span></span>,}
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_enumerable_source">(<a href="javascript:show('enumerable_source')">show</a>)</span>
+         <pre class="source" id="enumerable_source"><span class="r">module</span> <span class="cl">Enumerable</span>
+  <span class="r">def</span> <span class="fu">mash</span>
+    ret = {}
+    each{ |kv|
+      ret.store *( <span class="r">yield</span>(kv)[<span class="i">0</span>,<span class="i">2</span>] )
+    }
+    ret
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/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>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Hash.zip</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should zip together both given enumerables and take them as key=&gt;values for a new hash</span><span class="dl">'</span></span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Hash#&lt;&lt;</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should append new elements to the hash</span><span class="dl">'</span></span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_hash_source">(<a href="javascript:show('hash_source')">show</a>)</span>
+         <pre class="source" id="hash_source"><span class="r">class</span> <span class="cl">Hash</span>
+  <span class="r">def</span> <span class="pc">self</span>.<span class="fu">zip</span>(keys,values)
+    <span class="co">Hash</span>[ *[<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>].zip( [<span class="i">4</span>,<span class="i">5</span>,<span class="i">6</span>] ).flatten ]
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">&lt;&lt;</span>(other)
+    <span class="r">case</span>
+    <span class="r">when</span> other.is_a?(<span class="co">Hash</span>)
+      merge! other
+    <span class="r">when</span> other.respond_to?(<span class="sy">:to_splat</span>)
+      merge! <span class="co">Hash</span>[*other]
+    <span class="r">else</span>
+      raise <span class="co">TypeError</span>, <span class="s"><span class="dl">'</span><span class="k">can only append other Hashs and Enumerables</span><span class="dl">'</span></span>
+    <span class="r">end</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/hash2proc'">hash2proc</h3>
+         <table class="cube_table"
+                id="hash2proc_cube"
+                title="require 'zucker/hash2proc'"> <tr><th>Summary</th>    <td>Use a hash to apply procs to specific objects.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Hash#to_proc</h5><pre class="usage source" style="display:block">[<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>].map(&amp;{
+<span class="i">2</span> =&gt; lambda {|e| e + <span class="i">1000</span>},
+<span class="i">4</span> =&gt; <span class="sy">:to_s</span>,
+}) <span class="c"># =&gt; [1, 1002, 3, '4']</span></pre></td></tr><tr><th>Further information</th>    <td>More about <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>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Hash#to_proc</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should run the proc given in the value for a key in the hash</span><span class="dl">'</span></span> <span class="r">do</span>
+    [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>].map(&amp;{
+      <span class="i">4</span> =&gt; <span class="sy">:to_s</span>,
+      <span class="c"># 3 =&gt; [:to_s, 2]  # &quot;11&quot; =&gt;  if array2proc is used</span>
+      <span class="i">2</span> =&gt; lambda {|e| e + <span class="i">1000</span>}
+    }).should == [<span class="i">1</span>, <span class="i">1002</span>, <span class="i">3</span>, <span class="s"><span class="dl">&quot;</span><span class="k">4</span><span class="dl">&quot;</span></span>]
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_hash2proc_source">(<a href="javascript:show('hash2proc_source')">show</a>)</span>
+         <pre class="source" id="hash2proc_source"><span class="r">class</span> <span class="cl">Hash</span>
+  <span class="r">def</span> <span class="fu">to_proc</span>
+    <span class="co">Proc</span>.new{ |obj|
+      <span class="r">if</span> <span class="pc">self</span>.member? obj
+        <span class="pc">self</span>[obj].to_proc.call obj
+      <span class="r">else</span>
+        obj
+      <span class="r">end</span>
+    }
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<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>
+         <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|
+  puts <span class="s"><span class="dl">&quot;</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>f<span class="idl">}</span></span><span class="dl">&quot;</span></span>
+<span class="r">end</span>
+<span class="c"># outputs</span>
+<span class="c">#  1,3</span>
+<span class="c">#  2,4</span>
+<span class="c">#  ,5</span>
+</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_iterate_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>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Object#iterate</span><span class="dl">'</span></span> <span class="r">do</span>
+  let <span class="sy">:a</span>   <span class="r">do</span> [<span class="i">1</span>, <span class="i">2</span>, <span class="i">3</span>]     <span class="r">end</span>
+  let <span class="sy">:b</span>   <span class="r">do</span> <span class="s"><span class="dl">%w|</span><span class="k">a b c d</span><span class="dl">|</span></span>   <span class="r">end</span>
+  let <span class="sy">:res</span> <span class="r">do</span> <span class="co">Hash</span>.new {[]} <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should behave like Enumerable#each for a single argument</span><span class="dl">'</span></span> <span class="r">do</span>
+    iterate a <span class="r">do</span> |ele|
+      res[<span class="sy">:iter</span>] &lt;&lt; ele
+    <span class="r">end</span>
+
+    a.each <span class="r">do</span> |ele|
+      res[<span class="sy">:each</span>] &lt;&lt; ele
+    <span class="r">end</span>
+
+    res[<span class="sy">:iter</span>].should == res[<span class="sy">:each</span>]
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should pass the right params to the block</span><span class="dl">'</span></span> <span class="r">do</span>
+    res = <span class="co">Hash</span>.new {[]} <span class="c"># TODO: why?</span>
+    res[<span class="sy">:iter_a_b</span>] = [] <span class="c"># ....</span>
+    res[<span class="sy">:iter_b_a</span>] = [] <span class="c"># ....</span>
+
+
+    iterate a, b <span class="r">do</span> |e,f|
+      res[<span class="sy">:iter_a_b</span>] &lt;&lt; [e, f]
+<span class="c">#      p res[:iter_a_b], e, f</span>
+    <span class="r">end</span>
+
+    res[<span class="sy">:iter_a_b</span>].should == [
+      [<span class="i">1</span>, <span class="s"><span class="dl">'</span><span class="k">a</span><span class="dl">'</span></span>],
+      [<span class="i">2</span>, <span class="s"><span class="dl">'</span><span class="k">b</span><span class="dl">'</span></span>],
+      [<span class="i">3</span>, <span class="s"><span class="dl">'</span><span class="k">c</span><span class="dl">'</span></span>],
+      [<span class="pc">nil</span>, <span class="s"><span class="dl">'</span><span class="k">d</span><span class="dl">'</span></span>],
+    ]
+
+    iterate b, a <span class="r">do</span> |e,f|
+      res[<span class="sy">:iter_b_a</span>] &lt;&lt; [e, f]
+    <span class="r">end</span>
+
+    res[<span class="sy">:iter_b_a</span>].should == [
+      [<span class="s"><span class="dl">'</span><span class="k">a</span><span class="dl">'</span></span>, <span class="i">1</span>],
+      [<span class="s"><span class="dl">'</span><span class="k">b</span><span class="dl">'</span></span>, <span class="i">2</span>],
+      [<span class="s"><span class="dl">'</span><span class="k">c</span><span class="dl">'</span></span>, <span class="i">3</span>],
+      [<span class="s"><span class="dl">'</span><span class="k">d</span><span class="dl">'</span></span>, <span class="pc">nil</span>],
+    ]
+
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should return enumerators if no block is applied</span><span class="dl">'</span></span> <span class="r">do</span>
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_iterate_source">(<a href="javascript:show('iterate_source')">show</a>)</span>
+         <pre class="source" id="iterate_source"><span class="r">def</span> <span class="fu">iterate</span>(*params)
+  <span class="c"># params.shift.zip(*params).each{ |*elements| yield *elements }</span>
+
+  first = params.shift
+  <span class="r">if</span> params.empty? <span class="c"># single param - like each</span>
+    <span class="r">if</span> block_given?
+      first.map{|e| <span class="r">yield</span> e }
+    <span class="r">else</span>
+      first.map
+    <span class="r">end</span>
+  <span class="r">else</span>
+    padded_first = <span class="co">Array</span>.new( [first, *params].max_by(&amp;<span class="sy">:size</span>).size ){|i| first[i] } <span class="c"># append nils</span>
+    obj = padded_first.zip *params
+    <span class="r">if</span> block_given?
+      obj.map{|es| <span class="r">yield</span> *es }
+    <span class="r">else</span>
+      obj.map.to_enum
+    <span class="r">end</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/ivars'">ivars</h3>
+         <table class="cube_table"
+                id="ivars_cube"
+                title="require 'zucker/ivars'"> <tr><th>Summary</th>    <td>This method lets you easily assign lots of instance variables.</td></tr><tr><th>Why?</th>    <td>Often, you have to write boilerplate code for assigning instance varialbles, for example this one:<br/><code>def initialize(variable1, variable2)<br/>  @variable1, @variable2 = variable1, variable2<br/>end</code><br/></td></tr><tr><th>Methods/Usage</th>    <td><h5>instance_variables_from, ivars</h5><pre class="usage source" style="display:block"><span class="r">def</span> <span class="fu">a_method</span>(a = <span class="i">1</span>, b = <span class="i">2</span>)
+  instance_variables_from binding <span class="c"># assigns @a and @b</span>
+
+  params = {<span class="sy">:c</span> =&gt; <span class="i">3</span>, <span class="sy">:d</span> =&gt; <span class="i">4</span>}
+  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>
+
+describe <span class="s"><span class="dl">'</span><span class="k">instance_variables_from</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should tansform the given parameter to instance variables</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="r">def</span> <span class="fu">a_method</span>(a = <span class="i">1</span>, b = <span class="i">2</span>)
+      instance_variables_from binding <span class="c"># assigns @a and @b</span>
+
+      params = {<span class="sy">:c</span> =&gt; <span class="i">3</span>, <span class="sy">:d</span> =&gt; <span class="i">4</span>}
+      ivars params <span class="c"># # assigns @c and @d</span>
+    <span class="r">end</span>
+
+    a_method
+    <span class="iv">@a</span>.should == <span class="i">1</span>
+    <span class="iv">@b</span>.should == <span class="i">2</span>
+    <span class="iv">@c</span>.should == <span class="i">3</span>
+    <span class="iv">@d</span>.should == <span class="i">4</span>
+
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_ivars_source">(<a href="javascript:show('ivars_source')">show</a>)</span>
+         <pre class="source" id="ivars_source"><span class="r">def</span> <span class="fu">instance_variables_from</span>(obj, *only)
+  iter =
+  <span class="r">if</span>    obj.is_a? <span class="co">Binding</span>
+    obj.eval(<span class="s"><span class="dl">'</span><span class="k">local_variables</span><span class="dl">'</span></span>).map{|e| [obj.eval(e), e] }
+  <span class="r">elsif</span> obj.is_a? <span class="co">Hash</span>
+    obj.map{|k,v| [v,k] }
+  <span class="r">else</span>
+<span class="c">#  elsif obj.is_a? Enumerable</span>
+    obj.each.with_index
+  <span class="r">end</span>
+
+  ret = []
+  iter.each{ |value, arg|
+    arg = arg.to_s
+    <span class="r">if</span> only.include?(arg) || only.include?(arg.to_sym) || only.empty?
+      arg = <span class="s"><span class="dl">'</span><span class="k">_</span><span class="dl">'</span></span> + arg  <span class="r">if</span> (<span class="i">48</span>..<span class="i">57</span>).member? arg.unpack(<span class="s"><span class="dl">'</span><span class="k">C</span><span class="dl">'</span></span>)[<span class="i">0</span>]  <span class="c"># 1.8+1.9</span>
+      ret &lt;&lt; ivar = <span class="sy"><span class="sy">:</span><span class="dl">&quot;</span><span class="k">@</span><span class="il"><span class="idl">#{</span>arg<span class="idl">}</span></span><span class="dl">&quot;</span></span>
+      <span class="pc">self</span>.instance_variable_set ivar, value
+    <span class="r">end</span>
+  }
+  ret
+<span class="r">end</span>
+<span class="r">alias</span> <span class="fu">ivars</span> <span class="fu">instance_variables_from</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/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>
+
+describe <span class="s"><span class="dl">'</span><span class="k">activate_warnings!</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should set $VERBOSE to true</span><span class="dl">'</span></span> <span class="r">do</span>
+    activate_warnings!
+    <span class="gv">$VERBOSE</span>.should == <span class="pc">true</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">deactivate_warnings!</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should set $VERBOSE to false</span><span class="dl">'</span></span> <span class="r">do</span>
+    deactivate_warnings!
+    <span class="gv">$VERBOSE</span>.should == <span class="pc">false</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">warnings_activated?</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should return $VERBOSE</span><span class="dl">'</span></span> <span class="r">do</span>
+    warnings_activated?.should == <span class="gv">$VERBOSE</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">library?</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should return false if the file is invoked directly</span><span class="dl">'</span></span> <span class="r">do</span>
+    library?.should == ( <span class="pc">__FILE__</span> != <span class="gv">$PROGRAM_NAME</span> )
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">ignore_sigint!</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should catch ctrl+c signals</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="c"># ...</span>
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_kernel_source">(<a href="javascript:show('kernel_source')">show</a>)</span>
+         <pre class="source" id="kernel_source"><span class="r">def</span> <span class="fu">activate_warnings!</span>
+  <span class="gv">$VERBOSE</span> = <span class="pc">true</span>
+<span class="r">end</span>
+
+<span class="r">def</span> <span class="fu">deactivate_warnings!</span>
+  <span class="gv">$VERBOSE</span> = <span class="pc">false</span>
+<span class="r">end</span>
+
+<span class="r">def</span> <span class="fu">warnings_activated?</span>
+  <span class="gv">$VERBOSE</span>
+<span class="r">end</span>
+
+<span class="r">def</span> <span class="fu">library?</span>
+  <span class="pc">__FILE__</span> != <span class="gv">$PROGRAM_NAME</span>
+<span class="r">end</span>
+
+<span class="r">def</span> <span class="fu">ignore_sigint!</span> <span class="c"># ctrl+c</span>
+   <span class="co">Signal</span>.trap *<span class="s"><span class="dl">%w|</span><span class="k">SIGINT IGNORE</span><span class="dl">|</span></span>
+<span class="r">end</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/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>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Object#mcopy</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">create a (deep) copy via marshalling</span><span class="dl">'</span></span> <span class="r">do</span>
+    a = <span class="s"><span class="dl">%w[</span><span class="k">hello world</span><span class="dl">]</span></span>
+    b = a.mcopy
+    b.should == a
+
+    b[<span class="i">0</span>][<span class="i">1</span>,<span class="i">1</span>] = <span class="s"><span class="dl">'</span><span class="dl">'</span></span>
+    b.should_not == a
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_mcopy_source">(<a href="javascript:show('mcopy_source')">show</a>)</span>
+         <pre class="source" id="mcopy_source"><span class="r">class</span> <span class="cl">Object</span>
+  <span class="r">def</span> <span class="fu">mcopy</span>
+    <span class="co">Marshal</span>.load <span class="co">Marshal</span>.dump <span class="pc">self</span>
+  <span class="r">end</span>
+  <span class="c"># alias copy mcopy</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/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>
+<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>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Regexp#to_proc</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should match the regex</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="s"><span class="dl">%w|</span><span class="k">just another string array</span><span class="dl">|</span></span>.map(     &amp;<span class="rx"><span class="dl">/</span><span class="k">[jy]</span><span class="dl">/</span></span>).should == [<span class="s"><span class="dl">&quot;</span><span class="k">j</span><span class="dl">&quot;</span></span>, <span class="pc">nil</span>, <span class="pc">nil</span>, <span class="s"><span class="dl">&quot;</span><span class="k">y</span><span class="dl">&quot;</span></span>]
+    <span class="s"><span class="dl">%w|</span><span class="k">just another string array</span><span class="dl">|</span></span>.select(  &amp;<span class="rx"><span class="dl">/</span><span class="k">[jy]</span><span class="dl">/</span></span>).should == [<span class="s"><span class="dl">&quot;</span><span class="k">just</span><span class="dl">&quot;</span></span>, <span class="s"><span class="dl">&quot;</span><span class="k">array</span><span class="dl">&quot;</span></span>]
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_regexp2proc_source">(<a href="javascript:show('regexp2proc_source')">show</a>)</span>
+         <pre class="source" id="regexp2proc_source"><span class="r">class</span> <span class="cl">Regexp</span>
+  <span class="r">def</span> <span class="fu">to_proc</span>
+    proc <span class="r">do</span> |e|
+      e.to_s[<span class="pc">self</span>]
+    <span class="r">end</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/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>
+  <span class="c"># dangerous commands throw SecurityErrors ($SAFE=4)</span>
+<span class="r">end</span>
+<span class="c"># everything's normal again</span>
+</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_sandbox_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>
+
+describe <span class="s"><span class="dl">'</span><span class="k">sandbox</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should throw a SecurityError if bad commands are issued</span><span class="dl">'</span></span>
+  it <span class="s"><span class="dl">'</span><span class="k">should run the lambda passed as first parameter for errors, if it is given</span><span class="dl">'</span></span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_sandbox_source">(<a href="javascript:show('sandbox_source')">show</a>)</span>
+         <pre class="source" id="sandbox_source"><span class="r">def</span> <span class="fu">sandbox</span>(rescueblock=<span class="pc">nil</span>)
+  <span class="co">Thread</span>.start <span class="r">do</span>
+    <span class="gv">$SAFE</span> = <span class="i">4</span>
+    <span class="r">yield</span>
+  <span class="r">end</span>.value
+<span class="r">rescue</span> <span class="co">SecurityError</span> =&gt; e
+  <span class="r">if</span> rescueblock
+    rescueblock.call e
+  <span class="r">else</span>
+    raise e
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/square_brackets_for'">square_brackets_for</h3>
+         <table class="cube_table"
+                id="square_brackets_for_cube"
+                title="require 'zucker/square_brackets_for'"> <tr><th>Summary</th>    <td>This helper methods defines <code>[]</code> and <code>[]=</code> for accesing an instance variable.</td></tr><tr><th>Methods/Usage</th>    <td><h5>square_brackets_for</h5><pre class="usage source" style="display:block"><span class="r">class</span> <span class="cl">Klass</span>
+  <span class="r">def</span> <span class="fu">initialize</span>
+    <span class="iv">@var</span> = {
+      <span class="sy">:a_key</span> =&gt; <span class="i">1</span>,
+      <span class="sy">:another_one</span> =&gt; <span class="i">2</span>,
+    }
+  <span class="r">end</span>
+
+  square_brackets_for <span class="sy">:var</span> <span class="c"># creates [] and []=</span>
+  <span class="c"># square_brackets_for :var, false # would create only []</span>
+<span class="r">end</span>
+
+a = <span class="co">Klass</span>.new
+a[<span class="sy">:a_key</span>] <span class="c"># =&gt; 1</span>
+</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_square_brackets_for_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>
+
+describe <span class="s"><span class="dl">'</span><span class="k">square_brackets_for</span><span class="dl">'</span></span> <span class="r">do</span>
+
+  before <span class="r">do</span>
+    <span class="r">class</span> <span class="cl">Klass</span>
+      <span class="r">def</span> <span class="fu">initialize</span>
+        <span class="iv">@var</span> = {
+          <span class="sy">:a_key</span> =&gt; <span class="i">1</span>,
+          <span class="sy">:another_one</span> =&gt; <span class="i">2</span>,
+        }
+      <span class="r">end</span>
+
+      <span class="iv">@eigenvar</span> = {
+        <span class="sy">:a_key</span> =&gt; <span class="i">99</span>
+      }
+    <span class="r">end</span>
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should define a [] getter (not a setter) for an instance var, if the second parameter is false</span><span class="dl">'</span></span> <span class="r">do</span>
+
+    <span class="r">class</span> <span class="cl">Klass</span>
+      square_brackets_for <span class="sy">:var</span>, <span class="pc">nil</span>
+    <span class="r">end</span>
+
+    a = <span class="co">Klass</span>.new
+    a[<span class="sy">:a_key</span>].should == <span class="i">1</span>
+
+    proc <span class="r">do</span>
+      a[<span class="sy">:this_is</span>] = <span class="s"><span class="dl">'</span><span class="k">not possible</span><span class="dl">'</span></span>
+    <span class="r">end</span>.should raise_exception <span class="co">NoMethodError</span>
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should define [] and []= for accessing an instance variable</span><span class="dl">'</span></span> <span class="r">do</span>
+
+    <span class="r">class</span> <span class="cl">Klass</span>
+      square_brackets_for <span class="sy">:var</span>
+    <span class="r">end</span>
+
+    a = <span class="co">Klass</span>.new
+    a[<span class="sy">:a_key</span>].should == <span class="i">1</span>
+
+    a[<span class="sy">:this_is</span>] = <span class="s"><span class="dl">'</span><span class="k">useful</span><span class="dl">'</span></span>
+    a[<span class="sy">:this_is</span>].should == <span class="s"><span class="dl">'</span><span class="k">useful</span><span class="dl">'</span></span>
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should also work for class-instance variables</span><span class="dl">'</span></span> <span class="r">do</span>
+
+    <span class="r">class</span> <span class="cl">Klass</span>
+      <span class="r">class</span> &lt;&lt; <span class="cl">Klass</span>
+        square_brackets_for <span class="sy">:eigenvar</span>
+      <span class="r">end</span>
+    <span class="r">end</span>
+
+    <span class="co">Klass</span>[<span class="sy">:a_key</span>].should == <span class="i">99</span>
+  <span class="r">end</span>
+
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_square_brackets_for_source">(<a href="javascript:show('square_brackets_for_source')">show</a>)</span>
+         <pre class="source" id="square_brackets_for_source"><span class="r">def</span> <span class="fu">square_brackets_for</span>(ivar, assignment = <span class="pc">true</span>)
+<span class="c">#  undef []   if respond_to? :[]</span>
+<span class="c">#  undef []=  if respond_to? :[]=</span>
+
+<span class="c">#instance_eval do</span>
+  define_method <span class="sy">:[]</span> <span class="r">do</span> |key|
+    (instance_variable_get <span class="sy"><span class="sy">:</span><span class="dl">&quot;</span><span class="k">@</span><span class="il"><span class="idl">#{</span>ivar<span class="idl">}</span></span><span class="dl">&quot;</span></span>)[key]
+  <span class="r">end</span>
+
+  <span class="r">if</span> assignment
+    define_method <span class="sy">:[]=</span> <span class="r">do</span> |key, value|
+      (instance_variable_get <span class="sy"><span class="sy">:</span><span class="dl">&quot;</span><span class="k">@</span><span class="il"><span class="idl">#{</span>ivar<span class="idl">}</span></span><span class="dl">&quot;</span></span>)[key] = value
+    <span class="r">end</span>
+  <span class="r">end</span>
+<span class="c">#end</span>
+
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/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>
+
+describe <span class="s"><span class="dl">'</span><span class="k">String#^</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should give C-like substring access to strings</span><span class="dl">'</span></span> <span class="r">do</span>
+    string = <span class="s"><span class="dl">'</span><span class="k">Theoretische Informatik ist voll geil!</span><span class="dl">'</span></span>
+
+    (string|<span class="i">0</span>).should  == <span class="s"><span class="dl">'</span><span class="k">Theoretische Informatik ist voll geil!</span><span class="dl">'</span></span>
+    (string|<span class="i">1</span>).should  == <span class="s"><span class="dl">'</span><span class="k">heoretische Informatik ist voll geil!</span><span class="dl">'</span></span>
+    (string|<span class="i">13</span>).should == <span class="s"><span class="dl">'</span><span class="k">Informatik ist voll geil!</span><span class="dl">'</span></span>
+    (string|<span class="i">-1</span>).should == <span class="s"><span class="dl">'</span><span class="k">Theoretische Informatik ist voll geil</span><span class="dl">'</span></span>
+    (string|<span class="i">38</span>).should == <span class="s"><span class="dl">'</span><span class="dl">'</span></span>
+    (string|<span class="i">99</span>).should == <span class="pc">nil</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">String#lchomp</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should chomp on the left side</span><span class="dl">'</span></span> <span class="r">do</span>
+    string = <span class="s"><span class="dl">'</span><span class="k">Theoretische Informatik ist voll geil!</span><span class="dl">'</span></span>
+    string.lchomp(<span class="s"><span class="dl">'</span><span class="k">T</span><span class="dl">'</span></span>).should  == <span class="s"><span class="dl">'</span><span class="k">heoretische Informatik ist voll geil!</span><span class="dl">'</span></span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">String#ords</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should unpack characters</span><span class="dl">'</span></span> <span class="r">do</span>
+    string = <span class="s"><span class="dl">'</span><span class="k">Theoretische Informatik ist voll geil!</span><span class="dl">'</span></span>
+    string.ords.should  == [<span class="i">84</span>, <span class="i">104</span>, <span class="i">101</span>, <span class="i">111</span>, <span class="i">114</span>, <span class="i">101</span>, <span class="i">116</span>, <span class="i">105</span>, <span class="i">115</span>, <span class="i">99</span>, <span class="i">104</span>, <span class="i">101</span>, <span class="i">32</span>, <span class="i">73</span>, <span class="i">110</span>, <span class="i">102</span>, <span class="i">111</span>, <span class="i">114</span>, <span class="i">109</span>, <span class="i">97</span>, <span class="i">116</span>, <span class="i">105</span>, <span class="i">107</span>, <span class="i">32</span>, <span class="i">105</span>, <span class="i">115</span>, <span class="i">116</span>, <span class="i">32</span>, <span class="i">118</span>, <span class="i">111</span>, <span class="i">108</span>, <span class="i">108</span>, <span class="i">32</span>, <span class="i">103</span>, <span class="i">101</span>, <span class="i">105</span>, <span class="i">108</span>, <span class="i">33</span>]
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_string_source">(<a href="javascript:show('string_source')">show</a>)</span>
+         <pre class="source" id="string_source"><span class="r">class</span> <span class="cl">String</span>
+  <span class="r">def</span> <span class="fu">^</span>(pos)
+    pos = pos.to_i
+    <span class="r">if</span> pos &gt;= <span class="i">0</span>
+      <span class="pc">self</span>[pos..<span class="i">-1</span>]
+    <span class="r">else</span>
+      <span class="pc">self</span>[<span class="i">0</span>...pos]
+    <span class="r">end</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">lchomp</span>(arg=<span class="gv">$/</span>)
+    <span class="pc">self</span>.reverse.chomp(arg).reverse
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">lchomp!</span>(arg=<span class="gv">$/</span>)
+    <span class="pc">self</span>.reverse.chomp!(arg).reverse
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">ords</span>
+    <span class="pc">self</span>.unpack <span class="s"><span class="dl">'</span><span class="k">C*</span><span class="dl">'</span></span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr></table> <h3 title="require 'zucker/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>
+
+describe <span class="co">Symbol</span>, <span class="s"><span class="dl">'</span><span class="k">#+@</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should convert to_s</span><span class="dl">'</span></span> <span class="r">do</span>
+    +(<span class="sy">:matz</span>) == <span class="s"><span class="dl">'</span><span class="k">matz</span><span class="dl">'</span></span> <span class="c"># () 1.8 bug</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="co">Symbol</span>, <span class="s"><span class="dl">'</span><span class="k">#-@</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should do nothing</span><span class="dl">'</span></span> <span class="r">do</span>
+    -<span class="sy">:matz</span> == <span class="sy">:matz</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="co">String</span>, <span class="s"><span class="dl">'</span><span class="k">#+@</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should do nothing</span><span class="dl">'</span></span> <span class="r">do</span>
+    +<span class="s"><span class="dl">'</span><span class="k">matz</span><span class="dl">'</span></span> == <span class="s"><span class="dl">'</span><span class="k">matz</span><span class="dl">'</span></span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="co">String</span>, <span class="s"><span class="dl">'</span><span class="k">#-@</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should convert to_sym</span><span class="dl">'</span></span> <span class="r">do</span>
+    -<span class="s"><span class="dl">'</span><span class="k">matz</span><span class="dl">'</span></span> == <span class="sy">:matz</span>
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_unary_source">(<a href="javascript:show('unary_source')">show</a>)</span>
+         <pre class="source" id="unary_source"><span class="r">class</span> <span class="cl">String</span>
+  <span class="r">def</span> <span class="fu">+@</span>
+    <span class="pc">self</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">-@</span>
+    to_sym
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="r">class</span> <span class="cl">Symbol</span>
+  <span class="r">def</span> <span class="fu">+@</span>
+    to_s
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">-@</span>
+    <span class="pc">self</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8 (+:literal not possible)</td></tr></table> <h3 title="require 'zucker/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>
+<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>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Regexp#|</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should create an Regexp.union of both operands</span><span class="dl">'</span></span> <span class="r">do</span>
+    (<span class="rx"><span class="dl">/</span><span class="k">hallo</span><span class="dl">/</span></span> | <span class="rx"><span class="dl">/</span><span class="ch">\d</span><span class="k">+</span><span class="dl">/</span></span> | <span class="rx"><span class="dl">/</span><span class="k">.</span><span class="dl">/</span></span>).should ==
+      <span class="co">Regexp</span>.union( <span class="co">Regexp</span>.union(<span class="rx"><span class="dl">/</span><span class="k">hallo</span><span class="dl">/</span></span>, <span class="rx"><span class="dl">/</span><span class="ch">\d</span><span class="k">+</span><span class="dl">/</span></span>), <span class="rx"><span class="dl">/</span><span class="k">.</span><span class="dl">/</span></span> )
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">String#|</span><span class="dl">'</span></span> <span class="r">do</span>
+  it_should_behave_like <span class="s"><span class="dl">'</span><span class="k">Regexp#|</span><span class="dl">'</span></span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_union_source">(<a href="javascript:show('union_source')">show</a>)</span>
+         <pre class="source" id="union_source"><span class="r">class</span> <span class="cl">Regexp</span>
+  <span class="r">def</span> <span class="fu">|</span>(arg)
+    <span class="co">Regexp</span>.union <span class="pc">self</span>, arg.is_a?(<span class="co">Regexp</span>) ? arg : arg.to_s
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="r">class</span> <span class="cl">String</span>
+  <span class="r">def</span> <span class="fu">|</span>(arg)
+    <span class="co">Regexp</span>.union <span class="pc">self</span>, arg.is_a?(<span class="co">Regexp</span>) ? arg : arg.to_s
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9</td></tr></table>
+      </div>
+<br/>
+    </div>
+  <div id="foot">
+    <div id="smile"><a href="http://rbjl.net">J-_-L</a></div>
+    This is the Ruby Zucker 1 documentation.
+    The current version is always available at <a href="http://rubyzucker.info">rubyzucker.info</a>.
+    Gem source can be found at <a href="http://github.com/janlelis/zucker">github</a>.
+  </div>
+
+</body>
+</html>
+