zucker 2 → 3

data/lib/zucker/1/desc/blank.yaml

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

data/lib/zucker/1/desc/class2proc.yaml

@@ -1,12 +0,0 @@
-class2proc:
-  summary: Creates a new instance of the class.
-  methods:
-    Class#to_proc: "[ [1,2],[3,5,6,7,3] ].map(&Set) # => [ Set[1,2], Set[5,6,7,3] ]"
-  package: default
-  info:
-  - Inspired by Ruby Facets.
-  - "More about →to_proc→http://rbjl.net/29-become-a-proc-star→."
-  versions:
-  - 1.9
-  - 1.8
-

data/lib/zucker/1/desc/egonil.yaml

@@ -1,17 +0,0 @@
-egonil:
-  summary: Creates a block, where ⇧nil⇧ does not raise ⇧NoMethodError⇧s.
-  methods:
-    egonil, nn: |
-      egonil do
-        nil.some_methods.that[:do].not.exist
-      end # => nil
-
-      nn(5){ nil.some_methods.that[:do].not.exist }
-      # => 5
-  package: default
-  info:
-  - See →this post→http://rbjl.net/26-the-28-bytes-of-ruby-joy→ for more information and discussion
-  versions:
-  - 1.9
-  - 1.8
-

data/lib/zucker/1/desc/enumerable.yaml

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

data/lib/zucker/1/desc/hash.yaml

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

data/lib/zucker/1/desc/hash2proc.yaml

@@ -1,11 +0,0 @@
-hash2proc:
-  summary: Use a hash to apply procs to specific objects.
-  methods:
-    Hash#to_proc: "[1,2,3,4].map(&{\n2 => lambda {|e| e + 1000},\n4 => :to_s,\n}) # => [1, 1002, 3, '4']"
-  package: default
-  info:
-  - "More about →to_proc→http://rbjl.net/29-become-a-proc-star→."
-  versions:
-  - 1.9
-  - 1.8
-

data/lib/zucker/1/desc/iterate.yaml

@@ -1,17 +0,0 @@
-iterate:
-  summary: Iterate over one or more collections.
-  why: "It's like ⇧.each⇧ with two differences: It feels more like a control structure and you can easily iterate over multiple objects."
-  methods:
-    iterate: |
-      iterate [1,2], [3,4,5] do |e,f|
-        puts "#{e},#{f}"
-      end
-      # outputs
-      #  1,3
-      #  2,4
-      #  ,5
-  package: default
-  versions:
-  - 1.9
-  - 1.8
-

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

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

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

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

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

@@ -1,12 +0,0 @@
-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/1/desc/mm.yaml

@@ -1,12 +0,0 @@
-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/1/desc/regexp2proc.yaml

@@ -1,13 +0,0 @@
-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/1/desc/sandbox.yaml

@@ -1,14 +0,0 @@
-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/1/desc/square_brackets_for.yaml

@@ -1,23 +0,0 @@
-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/1/desc/string.yaml

@@ -1,13 +0,0 @@
-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/1/desc/unary.yaml

@@ -1,15 +0,0 @@
-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/1/desc/union.yaml

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

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

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

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

@@ -1,1286 +0,0 @@
-<!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>
-