zucker 8 → 9

data/desc/kernel.yaml

@@ -0,0 +1,14 @@
+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"
+    executed_directly?, standalone?: "executed_directly? # checks, if the current file is run directly -> true"
+    library?: "library? # checks, if the current file is run directly -> false"
+    irb?: "irb? # returns false if not called from IRB"
+    ignore_sigint!: "ignore_sigint! # blocks CTRL+C"
+  versions:
+  - 1.9
+  - 1.8
+

data/desc/mcopy.yaml

@@ -0,0 +1,11 @@
+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
+  versions:
+  - 1.9
+  - 1.8
+

data/desc/mm.yaml

@@ -0,0 +1,15 @@
+mm:
+  summary: ⇧m⇧ displays an ordered public method list.
+  why: See one object's methods without those rarely used inherited methods.
+  methods:
+    Object#m, Object#mm, Object#method_list: |
+      >> 5.mm 2 # outputs the list (2 levels deep), for example:
+      # = Fixnum
+      # to_s  -@  +  -  *  /  div  %  modulo  divmod  fdiv  **  abs  magnitude  ==  ===  <=>  >  >=  <  <=  ~  &  |  ^  []  <<  >>  to_f  size  zero?  odd?  even?  succ
+      # = Integer
+      # integer?  odd?  even?  upto  downto  times  succ  next  pred  chr  ord  to_i  to_int  floor  ceil  truncate  round  gcd  lcm  gcdlcm  numerator  denominator  to_r  rationalize
+  info:
+  - See →this article→http://rbjl.net/31-the-multi-mega-method-list→ for more information.
+  versions:
+  - 1.9
+  - 1.8

data/desc/not.yaml

@@ -0,0 +1,11 @@
+not:
+  summary: ⇧not⇧ returns an object on which all methods are redirected to it's receiver object, but returns inverted boolean.
+  why: Better readability.
+  methods:
+    Object#not: |
+      [1,2,3].not.empty? # true
+  info:
+  - See →this article by Jay Field→http://blog.jayfields.com/2007/08/ruby-adding-not-method-for-readability.html→ for more information.
+  versions:
+  - 1.9
+

data/desc/oo.yaml

@@ -0,0 +1,10 @@
+oo:
+  summary: The ⇧o⇧ method outputs the current method, line, file and label (if given).
+  methods:
+    o, oo: |
+      o # e.g: Reached method `irb_binding', line 1 of file (irb)
+      o:Label # e.g: Label: reached method `abc', line 7 of file (irb)
+  versions:
+  - 1.9
+  - 1.8
+

data/desc/os.yaml

@@ -0,0 +1,19 @@
+os:
+  summary: Detect the operating system.
+  why: Checking for ⇧RUBY_PLATFORM⇧ does not report the OS when using JRuby and for better readability.
+  methods:
+    OS: "# displays the operating system"
+    OS.linux?: "OS.linux? # true if you are on a linux machine"
+    OS.mac?: "OS.mac? # true for macs"
+    OS.bsd?: "OS.bsd? # true for bsds"
+    OS.windows?: "include OS; windows? # true for windows. Example of including OS to get the os methods into the global namespace"
+    OS.solaris?: "OS.solaris? # true for solaris/sunos"
+    OS.posix?: "OS.posix? # true if system is posix compatible"
+    OS.is?: "OS.is? /x/ # matches the regex against the os string"
+  info:
+  - This cube depends on system information and may not be 100% accurate.
+  - "Syntax and semantic inspired by Roger Pack's →os gem→http://github.com/rdp/os→."
+  versions:
+  - 1.9
+  - 1.8
+

data/desc/qq.yaml

@@ -0,0 +1,11 @@
+qq:
+  summary: The ⇧q⇧ method does the same like ⇧p⇧, but puts out multiple arguments on the same line.
+  methods:
+    q, qq: |
+      q "zucker", '', {6=>7}, 5, 2.3, :o # outputs "zucker"  ""  {6=>7}  5  2.3  :o
+  info:
+  - Inspired by →rdp→http://github.com/rdp/sane/blob/master/lib/sane/pps.rb→.
+  versions:
+  - 1.9
+  - 1.8
+

data/desc/regexp_to_proc.yaml

@@ -0,0 +1,12 @@
+regexp_to_proc:
+  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"]
+  info:
+  - "More about →to_proc→http://rbjl.net/29-become-a-proc-star→."
+  versions:
+  - 1.9
+  - 1.8
+

data/desc/regexp_visualize.yaml

@@ -0,0 +1,23 @@
+regexp_visualize:
+  summary: Test your regex against a string, handy for the command line.
+  methods:
+    "Regexp#visualize, Regexp#vis": |
+      # regex = /\b([A-Z0-9._%+-]+)@([A-Z0-9.-]+\.[A-Z]{2,4})\b/i
+      regex.vis 'I do not contain an email address.'
+      # no match
+      regex.vis 'I contain an email address: mail@example.com'
+      # I contain an email address:  >mail@example.com< 
+      regex.vis 'mail@example.com', 1
+      # 1:  >mail< @example.com
+      regex.vis 'mail@example.com', 2
+      # 2: mail@ >example.com< 
+      regex.vis 'mail@example.com', 3
+      # 3: no match
+      regex.vis 'mail@example.com', [0,1,2]
+      # 0:  >mail@example.com< 
+      # 1:  >mail< @example.com
+      # 2: mail@ >example.com< 
+  versions:
+  - 1.9
+  - 1.8
+

data/desc/sandbox.yaml

@@ -0,0 +1,12 @@
+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
+  versions:
+  - 1.9
+  - 1.8

data/desc/square_brackets_for.yaml

@@ -0,0 +1,22 @@
+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
+  versions:
+  - 1.9
+  - 1.8
+

data/desc/string.yaml

@@ -0,0 +1,23 @@
+string:
+  summary: ⇧String⇧ extensions.
+  why: Strings cannot be comfortable enough ;).
+  methods:
+    String#-: "'1234abc5678' - 'b' - /\d/ # => ac"
+    String#^: "'Yes vs No'^7 # => 'No'"
+    String#lchomp: "'   Yes'.lchomp  # => 'Yes'"
+    String#lchomp!: "# mutable lchomp version"
+    String#ords: "'Hallo'.ords # => [72, 97, 108, 108, 111]"
+    String#constantize: |
+      'Object'.constantize # => Object
+      'Spec::VERSION'.constantize # => Spec::VERSION if rspec is loaded
+      # you can also pass a parameter or block to define what happens, when constant does not exist
+      'IdontExist'.constantize(Array) # => Array
+      'String5'.constantize do |string|
+        string.chop.constantize
+      end # => String
+  info:
+  - "⇧constantize⇧ is an improved version of ActiveSupport's one."
+  versions:
+  - 1.9
+  - 1.8
+

data/desc/tap.yaml

@@ -0,0 +1,17 @@
+tap:
+  summary: This cube adds the two ⇧tap⇧ variants ⇧tap_on⇧ (known as ⇧returning⇧ in ActiveSupport) and ⇧make_new⇧.
+  methods:
+    tap_on: |
+      tap_on [1,2] do |obj|
+        obj[4] = 5
+      end #=> [1, 2, nil, nil, 5]
+    make_new: |
+      make_new Hash do |obj|
+        obj[1] = 2
+      end #=> {1 => 2}
+  info:
+  - "Read more about using tap on the →ruby best practices→http://blog.rubybestpractices.com/posts/gregory/011-tap-that-hash.html→ blog."
+  versions:
+  - 1.9
+  - 1.8
+

data/desc/unary.yaml

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

data/desc/union.yaml

@@ -0,0 +1,10 @@
+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)/
+  versions:
+  - 1.9
+  - 1.8

data/desc/version.yaml

@@ -0,0 +1,28 @@
+version:
+  summary: Adds a ⇧RubyVersion⇧ class for easy compatibility checks.
+  methods:
+    RubyVersion: |
+      # return RUBY_VERSION
+      RubyVersion
+      # check for the main version with a Float
+      RubyVersion.is? 1.8
+      # use strings for exacter checking
+      RubyVersion.is.above '1.8.7'
+      RubyVersion.is.at_least '1.8.7' # or exactly, below, at_most
+      # you can use the common comparison operators
+      RubyVersion >= '1.8.7'
+      RubyVersion.between? '1.8.6', '1.8.7'
+      # relase date checks
+      RubyVersion.is.older_than Date.today
+      RubyVersion.is.newer_than '2009-08-19'
+      # accessors
+      RubyVersion.major # e.g. => 1
+      RubyVersion.minor # e.g. => 8
+      RubyVersion.tiny  # e.g. => 7
+      RubyVersion.patchlevel # e.g. => 249
+      RubyVersion.description # e.g. => "ruby 1.8.7 (2010-01-10 patchlevel 249) [i486-linux]"
+  info:
+  - Thanks to Hanmac for a nice improvement.
+  versions:
+  - 1.9
+  - 1.8

data/doc/zucker_doc.html

@@ -0,0 +1,2688 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
+       "http://www.w3.org/TR/xhtml11/DTD/xhtml11.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 9</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:left;
+  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;
+}
+
+ul{
+  margin:5px 0px !important;
+  padding:none;
+}
+
+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;
+  width:98%;
+  padding: 3px 5px;
+  overflow: auto;
+  font-size: 12px;
+  background-color: #f8f8f8;
+  border:1px solid #005;
+  border: 1px solid silver;
+  font-family: 'Courier New', 'Terminal', monospace;
+  color: #000;
+}
+
+# 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; }
+
+.rubylogo{
+  margin-left:20px;
+  margin-top:10px;
+  margin-right:15px;
+  float:left;
+}
+
+  </style>
+</head>
+<body>
+  <div id="world">
+    <img class="rubylogo" alt="ruby" src="data:image/png;base64,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" />
+    <h1>Ruby Zucker 9</h1>
+      <h2 style="clear:both">What is it?</h2>
+      <p class="text">Zucker (<a href="http://www.forvo.com/word/zucker/">pronunciation</a>) is the German word for sugar. It adds syntactic sugar in the form of independent, small scripts that make Ruby even more sweet. It adds a lot of useful helper methods for an improved readability and usage. Everything is documented on this page.</p>
+      <p class="text">See the <a href="http://github.com/janlelis/zucker">github page</a> and wiki for issues, discussion and information about contributing.</p>
+
+      <h2>Install</h2>
+      <p class="text">
+        <code class="scode">gem install zucker --no-rdoc --no-ri # might need sudo</code>
+      </p>
+      <h3 style="padding-left:1.3em">Quickstart</h3>
+      <p class="text">
+        <code class="scode">require 'zucker/all'</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>packs</em>. Since there aren't any dependencies within the gem, you can easily require only the packs or cubes you want:
+        <code class="scode">require 'zucker/cube_or_pack_name'</code>
+      </p>
+      <h3 style="padding-left:1.3em">Packages</h3>
+      <ul class="text">
+         <li><a href="#control" style="text-decoration:none;font-weight:bold;">control</a>: Cubes that change program behaviour.</li> 
+ <li><a href="#env" style="text-decoration:none;font-weight:bold;">env</a>: Cubes for collecting information.</li> 
+ <li><a href="#extensions" style="text-decoration:none;font-weight:bold;">extensions</a>: More extensions for Ruby base classes.</li> 
+ <li><a href="#object" style="text-decoration:none;font-weight:bold;">object</a>: Extensions for <code>Object</code>.</li> 
+ <li><a href="#to_proc" style="text-decoration:none;font-weight:bold;">to_proc</a>: Adds some <code>to_proc</code> extensions to use with <code>&amp;</code>.</li> 
+ <li><a href="#shortcuts" style="text-decoration:none;font-weight:bold;">shortcuts</a>: Cubes that save you keystrokes or disambiguate things.</li> 
+ <li><a href="#debug" style="text-decoration:none;font-weight:bold;">debug</a>: Print debugging tools.</li> 
+      </ul>
+      <p class="text">
+        Furthermore, there are two meta packs available: <strong>all</strong> simply requires all cubes and <strong>default</strong> requires all cubes except <strong>debug</strong>.</p>
+
+      <h3 style="padding-left:1.3em">Which methods and constants are added directly to the global namespace by the <em>default</em> pack?</h3>
+      <p class="text">
+
+      <code class="scode">Info, RubyVersion, RubyEngine, OS, Infinity, NaN, alias_for, aliases_for, egonil, nn, iterate, instance_variables_from, ivars, activate_warnings!, deactivate_warnings!, executed_directly?, standalone?, library?, ignore_sigint!, sandbox, tap_on, make_new, (blank?, present?, mcopy)</code>
+      </p>
+
+       
+      <h2 title="require 'zucker/control'" id="control">Cubes[control]</h2>
+        
+        <div class="cubes">
+         <h3 title="require 'zucker/egonil'" id="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="pc">nil</span>.some_methods.that[<span class="sy">:do</span>].not.exist } <span class="c"># =&gt; nil</span>
+</pre></td></tr><tr><th>Information</th>    <td>See <a href="http://rbjl.net/26-the-28-bytes-of-ruby-joy">this post</a> for more information and discussion.</td></tr><tr><th>Specification</th>    <td> <span id="show_egonil_spec">(<a href="javascript:show('egonil_spec')">show</a>)</span>
+         <pre class="source" id="egonil_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/egonil</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">egonil</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should not raise nil exceptions in the block</span><span class="dl">'</span></span> <span class="r">do</span>
+    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 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>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should raise other Exceptions</span><span class="dl">'</span></span> <span class="r">do</span>
+    proc <span class="r">do</span>
+      egonil{ <span class="i">5</span> / <span class="i">0</span> }
+    <span class="r">end</span>.should raise_exception <span class="co">ZeroDivisionError</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">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<span class="c"># code by Yohan, slightly edited and comments by me</span>
+<span class="r">def</span> <span class="fu">egonil</span>(&amp;block)
+  <span class="c"># grip methods</span>
+  ori_method_missing   = <span class="co">NilClass</span>.instance_method(<span class="sy">:method_missing</span>)
+  catch_method_missing = <span class="co">NilClass</span>.instance_method(<span class="sy">:catch_method_missing</span>)
+  <span class="c"># activate ego mode</span>
+  <span class="co">NilClass</span>.send <span class="sy">:define_method</span>, <span class="sy">:method_missing</span>, catch_method_missing
+  <span class="c"># run code</span>
+  <span class="r">yield</span>
+<span class="r">ensure</span>
+  <span class="c"># no matter what happens: restore default nil behaviour</span>
+  <span class="co">NilClass</span>.send <span class="sy">:define_method</span>, <span class="sy">:method_missing</span>, ori_method_missing
+<span class="r">end</span>
+
+<span class="c"># this is the ego nil</span>
+<span class="r">class</span> <span class="cl">NilClass</span>
+  <span class="r">def</span> <span class="fu">catch_method_missing</span>(m, *args, &amp;block)
+    <span class="pc">nil</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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/egonil">github wiki</a></td></tr></table> <h3 title="require 'zucker/iterate'" id="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">zucker/iterate</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Object#iterate</span><span class="dl">'</span></span> <span class="r">do</span>
+  let <span class="sy">:a</span>   <span class="r">do</span> [<span class="i">1</span>, <span class="i">2</span>, <span class="i">3</span>]     <span class="r">end</span>
+  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="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>
+    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>
+
+    enumerator = iterate a,b
+    enumerator.should be_kind_of(<span class="co">RUBY_VERSION</span> &lt; <span class="s"><span class="dl">'</span><span class="k">1.9</span><span class="dl">'</span></span> ? <span class="co">Enumerable</span>::<span class="co">Enumerator</span> : <span class="co">Enumerator</span>)
+    enumerator.to_a.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>]]
+  <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">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<span class="r">def</span> <span class="fu">iterate</span>(*params)
+  <span class="c"># params.shift.zip(*params).each{ |*elements| yield *elements }</span>
+  raise <span class="co">ArgumentError</span>, <span class="s"><span class="dl">&quot;</span><span class="k">wrong number of arguments (0)</span><span class="dl">&quot;</span></span> <span class="r">if</span> params.empty?
+
+  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.to_enum
+    <span class="r">end</span>
+  <span class="r">else</span> <span class="c"># multiple params</span>
+    max_size = [first, *params].max_by(&amp;<span class="sy">:count</span>).size
+    padded_first = first.to_a + [<span class="pc">nil</span>]*(max_size - first.count)  <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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/iterate">github wiki</a></td></tr></table> <h3 title="require 'zucker/kernel'" id="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>executed_directly?, standalone?</h5><pre class="usage source" style="display:block">executed_directly? <span class="c"># checks, if the current file is run directly -&gt; true</span></pre><h5>library?</h5><pre class="usage source" style="display:block">library? <span class="c"># checks, if the current file is run directly -&gt; false</span></pre><h5>irb?</h5><pre class="usage source" style="display:block">irb? <span class="c"># returns false if not called from IRB</span></pre><h5>ignore_sigint!</h5><pre class="usage source" style="display:block">ignore_sigint! <span class="c"># blocks CTRL+C</span></pre></td></tr><tr><th>Specification</th>    <td> <span id="show_kernel_spec">(<a href="javascript:show('kernel_spec')">show</a>)</span>
+         <pre class="source" id="kernel_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/kernel</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">activate_warnings!</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should set $VERBOSE to true</span><span class="dl">'</span></span> <span class="r">do</span>
+    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">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">executed_directly?</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should return true if the file is invoked directly</span><span class="dl">'</span></span> <span class="r">do</span>
+    executed_directly?.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">irb?</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should return true if called in IRB</span><span class="dl">'</span></span> <span class="r">do</span>; <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">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="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># J-_-L</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">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<span class="r">module</span> <span class="cl">Kernel</span>
+  private
+
+  <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">library?</span>
+    caller[<span class="i">0</span>].rindex(<span class="rx"><span class="dl">/</span><span class="k">:</span><span class="ch">\d</span><span class="k">+(:in `.*')?$</span><span class="dl">/</span></span>)
+    <span class="gv">$PROGRAM_NAME</span> != <span class="gv">$`</span> <span class="c"># __FILE__</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">executed_directly?</span>
+    caller[<span class="i">0</span>].rindex(<span class="rx"><span class="dl">/</span><span class="k">:</span><span class="ch">\d</span><span class="k">+(:in `.*')?$</span><span class="dl">/</span></span>)
+    <span class="gv">$PROGRAM_NAME</span> == <span class="gv">$`</span> <span class="c"># __FILE__</span>
+  <span class="r">end</span>
+  <span class="r">alias</span> <span class="fu">standalone?</span> <span class="fu">executed_directly?</span>
+  <span class="r">alias</span> <span class="fu">directly_executed?</span> <span class="fu">executed_directly?</span>
+
+  <span class="r">def</span> <span class="fu">irb?</span>
+    (<span class="r">defined?</span>(<span class="co">IRB</span>) &amp;&amp; <span class="gv">$0</span> =~ <span class="rx"><span class="dl">/</span><span class="k">irb</span><span class="dl">/</span></span>) || (<span class="r">defined?</span>(<span class="co">Ripl</span>) &amp;&amp; <span class="gv">$0</span> =~ <span class="rx"><span class="dl">/</span><span class="k">ripl</span><span class="dl">/</span></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="pc">true</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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/kernel">github wiki</a></td></tr></table> <h3 title="require 'zucker/sandbox'" id="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 (-&gt; 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">zucker/sandbox</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">sandbox</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should throw a SecurityError if bad commands are issued</span><span class="dl">'</span></span> <span class="r">do</span>
+    proc <span class="r">do</span>
+      sandbox <span class="r">do</span>
+        <span class="sh"><span class="dl">`</span><span class="k">ls</span><span class="dl">`</span></span>
+      <span class="r">end</span>
+    <span class="r">end</span>.should raise_exception <span class="co">SecurityError</span>
+  <span class="r">end</span>
+<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">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<span class="r">module</span> <span class="cl">Kernel</span>
+  private
+
+  <span class="r">def</span> <span class="fu">sandbox</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">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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/sandbox">github wiki</a></td></tr></table> <h3 title="require 'zucker/tap'" id="tap">tap</h3>
+         <table class="cube_table"
+                id="tap_cube"
+                title="require 'zucker/tap'"> <tr><th>Summary</th>    <td>This cube adds the two <code>tap</code> variants <code>tap_on</code> (known as <code>returning</code> in ActiveSupport) and <code>make_new</code>.</td></tr><tr><th>Methods/Usage</th>    <td><h5>tap_on</h5><pre class="usage source" style="display:block">tap_on [<span class="i">1</span>,<span class="i">2</span>] <span class="r">do</span> |obj|
+  obj[<span class="i">4</span>] = <span class="i">5</span>
+<span class="r">end</span> <span class="c">#=&gt; [1, 2, nil, nil, 5]</span>
+</pre><h5>make_new</h5><pre class="usage source" style="display:block">make_new <span class="co">Hash</span> <span class="r">do</span> |obj|
+  obj[<span class="i">1</span>] = <span class="i">2</span>
+<span class="r">end</span> <span class="c">#=&gt; {1 =&gt; 2}</span>
+</pre></td></tr><tr><th>Information</th>    <td>Read more about using tap on the <a href="http://blog.rubybestpractices.com/posts/gregory/011-tap-that-hash.html">ruby best practices</a> blog.</td></tr><tr><th>Specification</th>    <td> <span id="show_tap_spec">(<a href="javascript:show('tap_spec')">show</a>)</span>
+         <pre class="source" id="tap_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/tap</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">tap_on</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should call tap on the argument and apply the block</span><span class="dl">'</span></span> <span class="r">do</span>
+    obj = <span class="s"><span class="dl">&quot;</span><span class="k">an_object</span><span class="dl">&quot;</span></span>
+    block = <span class="sy">:reverse</span>.to_proc
+
+    tap_on( obj, &amp;block ).should == obj.tap( &amp;block )
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">make_new</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should create a new instance of the class given as argument, apply the block on it and return result</span><span class="dl">'</span></span> <span class="r">do</span>
+    make_new <span class="co">Hash</span> <span class="r">do</span> |obj|
+      obj[<span class="i">1</span>] = <span class="i">2</span>
+    <span class="r">end</span>.should.send(<span class="sy"><span class="sy">:</span><span class="dl">'</span><span class="k">==</span><span class="dl">'</span></span>, { <span class="i">1</span> =&gt; <span class="i">2</span>})
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_tap_source">(<a href="javascript:show('tap_source')">show</a>)</span>
+         <pre class="source" id="tap_source">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<span class="r">def</span> <span class="fu">tap_on</span>(obj, &amp;block)
+  obj.tap &amp;block
+<span class="r">end</span>
+
+<span class="r">def</span> <span class="fu">make_new</span>(what, *args, &amp;block)
+  what.new(*args).tap &amp;block
+<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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/tap">github wiki</a></td></tr></table>
+        </div> 
+      <h2 title="require 'zucker/env'" id="env">Cubes[env]</h2>
+        
+        <div class="cubes">
+         <h3 title="require 'zucker/engine'" id="engine">engine</h3>
+         <table class="cube_table"
+                id="engine_cube"
+                title="require 'zucker/engine'"> <tr><th>Summary</th>    <td>Adds a <code>RubyEngine</code> class for easy compatibility checks.</td></tr><tr><th>Methods/Usage</th>    <td><h5>RubyEngine</h5><pre class="usage source" style="display:block"><span class="c"># outputs the interpreter name</span></pre><h5>RubyEngine.mri?</h5><pre class="usage source" style="display:block"><span class="co">RubyEngine</span>.mri? <span class="c"># true if using the official Ruby interpreter</span></pre><h5>RubyEngine.jruby?</h5><pre class="usage source" style="display:block"><span class="co">RubyEngine</span>.jruby? <span class="c"># true if using JRuby</span></pre><h5>RubyEngine.rubinius?</h5><pre class="usage source" style="display:block"><span class="co">RubyEngine</span>.rubinius? <span class="c"># true if using rubinius</span></pre><h5>RubyEngine.ree?</h5><pre class="usage source" style="display:block"><span class="co">RubyEngine</span>.ree? <span class="c"># true if using enterprise edition</span></pre><h5>RubyEngine.ironruby?</h5><pre class="usage source" style="display:block"><span class="co">RubyEngine</span>.ironruby? <span class="c"># true if using IronRuby</span></pre><h5>RubyEngine.macruby?</h5><pre class="usage source" style="display:block"><span class="co">RubyEngine</span>.macruby? <span class="c"># true if using MacRuby</span></pre><h5>RubyEngine.cardinal?</h5><pre class="usage source" style="display:block"><span class="co">RubyEngine</span>.cardinal? <span class="c"># true if using parrot</span></pre></td></tr><tr><th>Specification</th>    <td> <span id="show_engine_spec">(<a href="javascript:show('engine_spec')">show</a>)</span>
+         <pre class="source" id="engine_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/engine</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">RubyEngine</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should display the current ruby interpreter (to_s)</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="co">RubyEngine</span>
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should create many method aliases for asking for a specific interpreter</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="c"># please see the source or description file</span>
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_engine_source">(<a href="javascript:show('engine_source')">show</a>)</span>
+         <pre class="source" id="engine_source">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<span class="r">module</span> <span class="cl">RubyEngine</span>
+    <span class="c"># try to guess the interpreter</span>
+    <span class="iv">@interpreter</span> = <span class="r">case</span>
+    <span class="r">when</span> <span class="co">RUBY_PLATFORM</span> == <span class="s"><span class="dl">'</span><span class="k">parrot</span><span class="dl">'</span></span>
+      <span class="s"><span class="dl">'</span><span class="k">cardinal</span><span class="dl">'</span></span>
+    <span class="r">when</span> <span class="co">Object</span>.const_defined?(<span class="sy">:RUBY_ENGINE</span>)
+      <span class="r">if</span> <span class="co">RUBY_ENGINE</span> == <span class="s"><span class="dl">'</span><span class="k">ruby</span><span class="dl">'</span></span>
+        <span class="r">if</span> <span class="co">RUBY_DESCRIPTION</span> =~ <span class="rx"><span class="dl">/</span><span class="k">Enterprise</span><span class="dl">/</span></span>
+          <span class="s"><span class="dl">'</span><span class="k">ree</span><span class="dl">'</span></span>
+        <span class="r">else</span>
+          <span class="s"><span class="dl">'</span><span class="k">mri</span><span class="dl">'</span></span>
+        <span class="r">end</span>
+      <span class="r">else</span>
+        <span class="co">RUBY_ENGINE</span>.to_s <span class="c"># jruby, rbx, ironruby, macruby, etc.</span>
+      <span class="r">end</span>
+    <span class="r">else</span> <span class="c"># probably 1.8</span>
+      <span class="s"><span class="dl">'</span><span class="k">mri</span><span class="dl">'</span></span>
+    <span class="r">end</span>
+
+  <span class="r">class</span> &lt;&lt; <span class="cl">self</span>
+    <span class="r">def</span> <span class="fu">is?</span>(what)
+      what === <span class="iv">@interpreter</span>
+    <span class="r">end</span>
+    <span class="r">alias</span> <span class="fu">is</span> <span class="fu">is?</span>
+
+    <span class="r">def</span> <span class="fu">to_s</span>
+      <span class="iv">@interpreter</span>.to_s
+    <span class="r">end</span>
+
+    <span class="c"># ask methods</span>
+
+    <span class="r">def</span> <span class="fu">mri?</span>
+      <span class="co">RubyEngine</span>.is? <span class="s"><span class="dl">'</span><span class="k">mri</span><span class="dl">'</span></span>
+    <span class="r">end</span>
+    <span class="r">alias</span> <span class="fu">official_ruby?</span> <span class="fu">mri?</span>
+    <span class="r">alias</span> <span class="fu">ruby?</span> <span class="fu">mri?</span>
+
+    <span class="r">def</span> <span class="fu">jruby?</span>
+      <span class="co">RubyEngine</span>.is? <span class="s"><span class="dl">'</span><span class="k">jruby</span><span class="dl">'</span></span>
+    <span class="r">end</span>
+    <span class="r">alias</span> <span class="fu">java?</span> <span class="fu">jruby?</span>
+
+    <span class="r">def</span> <span class="fu">rubinius?</span>
+      <span class="co">RubyEngine</span>.is? <span class="s"><span class="dl">'</span><span class="k">rbx</span><span class="dl">'</span></span>
+    <span class="r">end</span>
+    <span class="r">alias</span> <span class="fu">rbx?</span> <span class="fu">rubinius?</span>
+
+    <span class="r">def</span> <span class="fu">ree?</span>
+      <span class="co">RubyEngine</span>.is? <span class="s"><span class="dl">'</span><span class="k">ree</span><span class="dl">'</span></span>
+    <span class="r">end</span>
+    <span class="r">alias</span> <span class="fu">enterprise?</span> <span class="fu">ree?</span>
+
+    <span class="r">def</span> <span class="fu">ironruby?</span>
+      <span class="co">RubyEngine</span>.is? <span class="s"><span class="dl">'</span><span class="k">ironruby</span><span class="dl">'</span></span>
+    <span class="r">end</span>
+    <span class="r">alias</span> <span class="fu">iron_ruby?</span> <span class="fu">ironruby?</span>
+
+    <span class="r">def</span> <span class="fu">cardinal?</span>
+      <span class="co">RubyEngine</span>.is? <span class="s"><span class="dl">'</span><span class="k">cardinal</span><span class="dl">'</span></span>
+    <span class="r">end</span>
+    <span class="r">alias</span> <span class="fu">parrot?</span> <span class="fu">cardinal?</span>
+    <span class="r">alias</span> <span class="fu">perl?</span> <span class="fu">cardinal?</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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/engine">github wiki</a></td></tr></table> <h3 title="require 'zucker/info'" id="info">info</h3>
+         <table class="cube_table"
+                id="info_cube"
+                title="require 'zucker/info'"> <tr><th>Summary</th>    <td>Access environment information with the <code>Info</code> module.</td></tr><tr><th>Why?</th>    <td>You don't need to remember in which global variable, constant or special method the information you are searching for is hidden.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Info</h5><pre class="usage source" style="display:block"><span class="c"># for example</span>
+<span class="co">Info</span>.working_directory <span class="c"># Dir.pwd</span>
+<span class="co">Info</span>.load_path         <span class="c"># $:</span>
+<span class="co">Info</span>.platform          <span class="c"># RUBY_PLATFORM</span>
+<span class="co">Info</span>.current_file      <span class="c"># similar to __FILE__</span>
+<span class="c"># you could also add them to the global namespace with: include Info</span>
+<span class="c"># see the source file for the list of accessors or</span>
+<span class="co">Info</span>.list
+</pre></td></tr><tr><th>Information</th>    <td>Please note that it is not possible to put some of __THOSE_KEYWORDS__ in methods, so the result might slightly differ. This might affect <code>current_file</code>, <code>current_file_directory</code>, <code>current_line</code> and <code>current_method</code>.<br/>Thanks to Facets for the <code>caller</code> Regexp.</td></tr><tr><th>Specification</th>    <td> <span id="show_info_spec">(<a href="javascript:show('info_spec')">show</a>)</span>
+         <pre class="source" id="info_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/info</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Info</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should define accessors for global variables, constants and some special methods/keywords</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="c"># see sourcefile for the list</span>
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_info_source">(<a href="javascript:show('info_source')">show</a>)</span>
+         <pre class="source" id="info_source">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+require <span class="s"><span class="dl">'</span><span class="k">rbconfig</span><span class="dl">'</span></span>
+require <span class="s"><span class="dl">'</span><span class="k">etc</span><span class="dl">'</span></span>
+
+<span class="r">module</span> <span class="cl">Info</span>
+  <span class="r">class</span> &lt;&lt; <span class="cl">self</span>
+    <span class="c"># hash like access</span>
+    <span class="r">def</span> <span class="fu">[]</span>(what)
+      send what
+    <span class="r">end</span>
+
+    <span class="c"># list available info methods</span>
+    <span class="r">def</span> <span class="fu">list</span>
+      singleton_methods - [<span class="sy">:[]</span>, <span class="sy">:list</span>, <span class="s"><span class="dl">'</span><span class="k">[]</span><span class="dl">'</span></span>, <span class="s"><span class="dl">'</span><span class="k">list</span><span class="dl">'</span></span>]
+    <span class="r">end</span>
+  <span class="r">end</span>
+
+  module_function
+
+  <span class="c"># input</span>
+  <span class="r">def</span> <span class="fu">last_input_file</span>
+    <span class="gv">$FILENAME</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">last_input_line_number</span>
+    <span class="gv">$.</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">last_input</span>
+    <span class="gv">$_</span>
+  <span class="r">end</span>
+
+  <span class="c"># program</span>
+  <span class="r">def</span> <span class="fu">program_name</span>
+    <span class="gv">$0</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">program_arguments</span>
+    <span class="gv">$:</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">loaded_programs</span>
+    <span class="gv">$&quot;</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">program_data</span>
+    ::<span class="co">DATA</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">child_program_status</span>
+    <span class="gv">$CHILD_STATUS</span>
+  <span class="r">end</span>
+
+  <span class="c"># system info</span>
+  <span class="r">def</span> <span class="fu">environment</span>
+    ::<span class="co">ENV</span>
+  <span class="r">end</span>
+  <span class="r">alias</span> <span class="fu">env</span> <span class="fu">environment</span>
+
+  <span class="r">def</span> <span class="fu">working_directory</span>
+    <span class="co">Dir</span>.pwd
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">platform</span>
+    ::<span class="co">RUBY_PLATFORM</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">os</span>
+    <span class="co">RbConfig</span>::<span class="co">CONFIG</span>[<span class="s"><span class="dl">'</span><span class="k">host_os</span><span class="dl">'</span></span>]
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">process_id</span>
+    <span class="gv">$$</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">load_path</span>
+    <span class="gv">$:</span>
+  <span class="r">end</span>
+
+  <span class="c"># user</span>
+  <span class="r">def</span> <span class="fu">user_login</span>
+    <span class="co">Etc</span>.getlogin
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">user_name</span>
+    <span class="co">Etc</span>.getpwnam(user_login).gecos.split(<span class="s"><span class="dl">'</span><span class="k">,</span><span class="dl">'</span></span>)[<span class="i">0</span>]
+  <span class="r">end</span>
+
+  <span class="c"># current</span>
+
+  <span class="r">def</span> <span class="fu">current_file</span> <span class="c">#  __FILE__</span>
+    <span class="r">return</span> <span class="gv">$`</span> <span class="r">if</span> caller[<span class="i">0</span>].rindex(<span class="rx"><span class="dl">/</span><span class="k">:</span><span class="ch">\d</span><span class="k">+(:in `.*')?$</span><span class="dl">/</span></span>)
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">current_file_directory</span>
+    <span class="r">if</span> current_file[<span class="i">0</span>,<span class="i">1</span>] == <span class="s"><span class="dl">'</span><span class="k">(</span><span class="dl">'</span></span> &amp;&amp; current_file[<span class="i">-1</span>,<span class="i">1</span>] == <span class="s"><span class="dl">'</span><span class="k">)</span><span class="dl">'</span></span>
+      current_file
+    <span class="r">else</span>
+      <span class="co">File</span>.dirname(current_file)
+    <span class="r">end</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">current_line</span> <span class="c"># __LINE__</span>
+    <span class="r">return</span> <span class="gv">$1</span>.to_i <span class="r">if</span> caller[<span class="i">0</span>].rindex( <span class="rx"><span class="dl">/</span><span class="k">:(</span><span class="ch">\d</span><span class="k">+)(:in `.*')?$</span><span class="dl">/</span></span> )
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">current_method</span> <span class="c"># __method__ (except aliases)</span>
+    <span class="r">return</span> <span class="gv">$1</span>.to_sym <span class="r">if</span> caller(<span class="i">1</span>)[<span class="i">0</span>].rindex( <span class="rx"><span class="dl">/</span><span class="ch">\`</span><span class="k">([^</span><span class="ch">\'</span><span class="k">]+)</span><span class="ch">\'</span><span class="dl">/</span></span> )
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">current_callstack</span>
+    caller
+  <span class="r">end</span>
+
+  <span class="c"># dealing with strings</span>
+  <span class="r">def</span> <span class="fu">gets_separator</span>
+    <span class="gv">$/</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">join_separator</span>
+    <span class="gv">$,</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">print_separator</span>
+    <span class="gv">$,</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">split_separator</span>
+    <span class="gv">$;</span>
+  <span class="r">end</span>
+
+  <span class="c"># misc</span>
+  <span class="r">def</span> <span class="fu">security_level</span>
+    <span class="gv">$SAFE</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">warnings_activated?</span>
+    <span class="gv">$VERBOSE</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">debug_activated?</span>
+    <span class="gv">$DEBUG</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">last_exception</span>
+    <span class="gv">$!</span>
+  <span class="r">end</span>
+
+  <span class="c"># defined objects</span>
+  <span class="r">def</span> <span class="fu">global_variables</span>
+    <span class="co">Object</span>.send <span class="sy">:global_variables</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">global_constants</span>
+    <span class="co">Object</span>.constants
+  <span class="r">end</span>
+
+  <span class="c"># encoding (1.9)</span>
+  <span class="c">#def source_encoding</span>
+  <span class="c">#  __ENCODING__</span>
+  <span class="c">#end</span>
+
+  <span class="r">def</span> <span class="fu">external_encoding</span>
+    <span class="co">Encoding</span>.default_external
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">internal_encoding</span>
+    <span class="co">Encoding</span>.default_internal
+  <span class="r">end</span>
+
+  <span class="c"># ruby version info</span>
+  <span class="r">def</span> <span class="fu">ruby_version</span> <span class="c"># also see the RubyVersion cube</span>
+    ::<span class="co">RUBY_VERSION</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">ruby_patchlevel</span>
+    ::<span class="co">RUBY_PATCHLEVEL</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">ruby_description</span>
+    ::<span class="co">RUBY_DESCRIPTION</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">ruby_release_date</span>
+    ::<span class="co">RUBY_RELEASE_DATE</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">ruby_engine</span> <span class="c"># warning! not support by every implementation. It's saver to use the RubyEngine cube</span>
+    ::<span class="co">RUBY_ENGINE</span>
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8 (not all information)</td></tr><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/info">github wiki</a></td></tr></table> <h3 title="require 'zucker/os'" id="os">os</h3>
+         <table class="cube_table"
+                id="os_cube"
+                title="require 'zucker/os'"> <tr><th>Summary</th>    <td>Detect the operating system.</td></tr><tr><th>Why?</th>    <td>Checking for <code>RUBY_PLATFORM</code> does not report the OS when using JRuby and for better readability.</td></tr><tr><th>Methods/Usage</th>    <td><h5>OS</h5><pre class="usage source" style="display:block"><span class="c"># displays the operating system</span></pre><h5>OS.linux?</h5><pre class="usage source" style="display:block"><span class="co">OS</span>.linux? <span class="c"># true if you are on a linux machine</span></pre><h5>OS.mac?</h5><pre class="usage source" style="display:block"><span class="co">OS</span>.mac? <span class="c"># true for macs</span></pre><h5>OS.bsd?</h5><pre class="usage source" style="display:block"><span class="co">OS</span>.bsd? <span class="c"># true for bsds</span></pre><h5>OS.windows?</h5><pre class="usage source" style="display:block">include <span class="co">OS</span>; windows? <span class="c"># true for windows. Example of including OS to get the os methods into the global namespace</span></pre><h5>OS.solaris?</h5><pre class="usage source" style="display:block"><span class="co">OS</span>.solaris? <span class="c"># true for solaris/sunos</span></pre><h5>OS.posix?</h5><pre class="usage source" style="display:block"><span class="co">OS</span>.posix? <span class="c"># true if system is posix compatible</span></pre><h5>OS.is?</h5><pre class="usage source" style="display:block"><span class="co">OS</span>.is? <span class="rx"><span class="dl">/</span><span class="k">x</span><span class="dl">/</span></span> <span class="c"># matches the regex against the os string</span></pre></td></tr><tr><th>Information</th>    <td>This cube depends on system information and may not be 100% accurate.<br/>Syntax and semantic inspired by Roger Pack's <a href="http://github.com/rdp/os">os gem</a>.</td></tr><tr><th>Specification</th>    <td> <span id="show_os_spec">(<a href="javascript:show('os_spec')">show</a>)</span>
+         <pre class="source" id="os_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/os</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">OS</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should display the used operation system (to_s)</span><span class="dl">'</span></span> <span class="r">do</span>; <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">linux?</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should return true if OS is a linux</span><span class="dl">'</span></span> <span class="r">do</span>; <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">mac?</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should return true if OS is a mac or darwin</span><span class="dl">'</span></span> <span class="r">do</span>; <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">bsd?</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should return true if OS is a bsd</span><span class="dl">'</span></span> <span class="r">do</span>; <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">windows?</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should return true if OS is a windows</span><span class="dl">'</span></span> <span class="r">do</span>; <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">solaris?</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should return true if OS is a solaris or sunos</span><span class="dl">'</span></span> <span class="r">do</span>; <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">posix?</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should return true if OS is posix compatible</span><span class="dl">'</span></span> <span class="r">do</span>; <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">OS.is?</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">&quot;</span><span class="k">should test if RbConfig::CONFIG['host_os'] matches the regex (boolean value)</span><span class="dl">&quot;</span></span> <span class="r">do</span>
+    <span class="co">OS</span>.is?(<span class="rx"><span class="dl">/</span><span class="k">linux</span><span class="dl">/</span></span>).should ==
+    !!( <span class="co">RbConfig</span>::<span class="co">CONFIG</span>[<span class="s"><span class="dl">'</span><span class="k">host_os</span><span class="dl">'</span></span>] =~ <span class="rx"><span class="dl">/</span><span class="k">linux</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_os_source">(<a href="javascript:show('os_source')">show</a>)</span>
+         <pre class="source" id="os_source">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+require <span class="s"><span class="dl">'</span><span class="k">rbconfig</span><span class="dl">'</span></span>
+
+<span class="r">module</span> <span class="cl">OS</span>
+  <span class="r">class</span> &lt;&lt; <span class="cl">self</span>
+    <span class="r">def</span> <span class="fu">is?</span>(what)
+      what === <span class="co">RbConfig</span>::<span class="co">CONFIG</span>[<span class="s"><span class="dl">'</span><span class="k">host_os</span><span class="dl">'</span></span>]
+    <span class="r">end</span>
+    <span class="r">alias</span> <span class="fu">is</span> <span class="fu">is?</span>
+
+    <span class="r">def</span> <span class="fu">to_s</span>
+      <span class="co">RbConfig</span>::<span class="co">CONFIG</span>[<span class="s"><span class="dl">'</span><span class="k">host_os</span><span class="dl">'</span></span>]
+    <span class="r">end</span>
+  <span class="r">end</span>
+
+  module_function
+
+  <span class="r">def</span> <span class="fu">linux?</span>
+    <span class="co">OS</span>.is?( <span class="rx"><span class="dl">/</span><span class="k">linux|cygwin</span><span class="dl">/</span></span> )
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">mac?</span>
+    <span class="co">OS</span>.is?( <span class="rx"><span class="dl">/</span><span class="k">mac|darwin</span><span class="dl">/</span></span> )
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">bsd?</span>
+    <span class="co">OS</span>.is?( <span class="rx"><span class="dl">/</span><span class="k">bsd</span><span class="dl">/</span></span> )
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">windows?</span>
+    <span class="co">OS</span>.is?( <span class="rx"><span class="dl">/</span><span class="k">mswin|mingw</span><span class="dl">/</span></span> )
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">solaris?</span>
+    <span class="co">OS</span>.is?( <span class="rx"><span class="dl">/</span><span class="k">solaris|sunos</span><span class="dl">/</span></span> )
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">posix?</span>
+    linux? <span class="r">or</span> mac? <span class="r">or</span> bsd? <span class="r">or</span> solaris? <span class="r">or</span> <span class="r">begin</span> 
+        fork <span class="r">do</span> <span class="r">end</span>
+        <span class="pc">true</span>
+      <span class="r">rescue</span> <span class="co">NotImplementedError</span>, <span class="co">NoMethodError</span>
+        <span class="pc">false</span>
+      <span class="r">end</span>
+  <span class="r">end</span>
+
+  <span class="c">#def symbian?</span>
+    <span class="c">#TODO who knows what symbian returns?</span>
+  <span class="c">#end</span>
+
+  <span class="c"># ...</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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/os">github wiki</a></td></tr></table> <h3 title="require 'zucker/version'" id="version">version</h3>
+         <table class="cube_table"
+                id="version_cube"
+                title="require 'zucker/version'"> <tr><th>Summary</th>    <td>Adds a <code>RubyVersion</code> class for easy compatibility checks.</td></tr><tr><th>Methods/Usage</th>    <td><h5>RubyVersion</h5><pre class="usage source" style="display:block"><span class="c"># return RUBY_VERSION</span>
+<span class="co">RubyVersion</span>
+<span class="c"># check for the main version with a Float</span>
+<span class="co">RubyVersion</span>.is? <span class="fl">1.8</span>
+<span class="c"># use strings for exacter checking</span>
+<span class="co">RubyVersion</span>.is.above <span class="s"><span class="dl">'</span><span class="k">1.8.7</span><span class="dl">'</span></span>
+<span class="co">RubyVersion</span>.is.at_least <span class="s"><span class="dl">'</span><span class="k">1.8.7</span><span class="dl">'</span></span> <span class="c"># or exactly, below, at_most</span>
+<span class="c"># you can use the common comparison operators</span>
+<span class="co">RubyVersion</span> &gt;= <span class="s"><span class="dl">'</span><span class="k">1.8.7</span><span class="dl">'</span></span>
+<span class="co">RubyVersion</span>.between? <span class="s"><span class="dl">'</span><span class="k">1.8.6</span><span class="dl">'</span></span>, <span class="s"><span class="dl">'</span><span class="k">1.8.7</span><span class="dl">'</span></span>
+<span class="c"># relase date checks</span>
+<span class="co">RubyVersion</span>.is.older_than <span class="co">Date</span>.today
+<span class="co">RubyVersion</span>.is.newer_than <span class="s"><span class="dl">'</span><span class="k">2009-08-19</span><span class="dl">'</span></span>
+<span class="c"># accessors</span>
+<span class="co">RubyVersion</span>.major <span class="c"># e.g. =&gt; 1</span>
+<span class="co">RubyVersion</span>.minor <span class="c"># e.g. =&gt; 8</span>
+<span class="co">RubyVersion</span>.tiny  <span class="c"># e.g. =&gt; 7</span>
+<span class="co">RubyVersion</span>.patchlevel <span class="c"># e.g. =&gt; 249</span>
+<span class="co">RubyVersion</span>.description <span class="c"># e.g. =&gt; &quot;ruby 1.8.7 (2010-01-10 patchlevel 249) [i486-linux]&quot;</span>
+</pre></td></tr><tr><th>Information</th>    <td>Thanks to Hanmac for a nice improvement.</td></tr><tr><th>Specification</th>    <td> <span id="show_version_spec">(<a href="javascript:show('version_spec')">show</a>)</span>
+         <pre class="source" id="version_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/version</span><span class="dl">'</span></span>
+require <span class="s"><span class="dl">'</span><span class="k">date</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">RubyVersion</span><span class="dl">'</span></span> <span class="r">do</span>
+  before <span class="sy">:all</span> <span class="r">do</span>
+    <span class="iv">@remember_version</span> = <span class="co">RUBY_VERSION</span>
+    capture_stderr{ <span class="co">RUBY_VERSION</span> = <span class="s"><span class="dl">'</span><span class="k">1.8.7</span><span class="dl">'</span></span> }
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should display RUBY_VERSION if called directly (to_s)</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="co">RubyVersion</span>.to_s.should == <span class="s"><span class="dl">'</span><span class="k">1.8.7</span><span class="dl">'</span></span>
+  <span class="r">end</span>
+
+  context <span class="s"><span class="dl">'</span><span class="k">using is method with parameter</span><span class="dl">'</span></span> <span class="r">do</span>
+    it <span class="s"><span class="dl">'</span><span class="k">should check for main version (1.8 or 1.9) when Float paramater is given</span><span class="dl">'</span></span> <span class="r">do</span>
+      <span class="co">RubyVersion</span>.is?( <span class="fl">1.8</span> ).should == <span class="pc">true</span>
+      <span class="co">RubyVersion</span>.is?( <span class="fl">1.9</span> ).should == <span class="pc">false</span>
+    <span class="r">end</span>
+
+    it <span class="s"><span class="dl">'</span><span class="k">should check with string comparison if parameter is not Float</span><span class="dl">'</span></span> <span class="r">do</span>
+      <span class="co">RubyVersion</span>.is?( <span class="s"><span class="dl">'</span><span class="k">1.8</span><span class="dl">'</span></span> ).should == <span class="pc">false</span>
+    <span class="r">end</span>
+  <span class="r">end</span>
+
+  context <span class="s"><span class="dl">'</span><span class="k">using is method without parameter but method chaining</span><span class="dl">'</span></span> <span class="r">do</span>
+    it <span class="s"><span class="dl">'</span><span class="k">should return a string for usage with comparison operators</span><span class="dl">'</span></span> <span class="r">do</span>
+      (<span class="co">RubyVersion</span>.is &gt; <span class="s"><span class="dl">'</span><span class="k">1.8.7</span><span class="dl">'</span></span>).should == <span class="pc">false</span>
+      (<span class="co">RubyVersion</span> &lt;= <span class="s"><span class="dl">'</span><span class="k">1.8.7</span><span class="dl">'</span></span>).should == <span class="pc">true</span>
+      (<span class="co">RubyVersion</span>.is.between? <span class="s"><span class="dl">'</span><span class="k">1.8.6</span><span class="dl">'</span></span>, <span class="s"><span class="dl">'</span><span class="k">1.8.7</span><span class="dl">'</span></span>).should == <span class="pc">true</span>
+    <span class="r">end</span>
+
+    it <span class="s"><span class="dl">'</span><span class="k">should create some handy compare aliases</span><span class="dl">'</span></span> <span class="r">do</span>
+      <span class="co">RubyVersion</span>.is.above( <span class="s"><span class="dl">'</span><span class="k">1.8.7</span><span class="dl">'</span></span> ).should == <span class="pc">false</span>
+      <span class="co">RubyVersion</span>.is.at_least( <span class="s"><span class="dl">'</span><span class="k">1.8.7</span><span class="dl">'</span></span> ).should == <span class="pc">true</span>
+      <span class="co">RubyVersion</span>.is.exactly( <span class="s"><span class="dl">'</span><span class="k">1.8.7</span><span class="dl">'</span></span> ).should == <span class="pc">true</span>
+    <span class="r">end</span>
+
+    it <span class="s"><span class="dl">'</span><span class="k">also allows to check for the release dates</span><span class="dl">'</span></span> <span class="r">do</span>
+      <span class="co">RubyVersion</span>.is.older_than( <span class="co">Date</span>.today ).should == <span class="pc">true</span>
+      <span class="co">RubyVersion</span>.is.newer_than( <span class="s"><span class="dl">'</span><span class="k">2000-01-01</span><span class="dl">'</span></span> ).should == <span class="pc">true</span>
+    <span class="r">end</span>
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should define some accessors</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="co">RubyVersion</span>.major.should == <span class="i">1</span>
+    <span class="co">RubyVersion</span>.minor.should == <span class="i">8</span>
+    <span class="co">RubyVersion</span>.tiny.should == <span class="i">7</span>
+    <span class="c"># RubyVersion.patchlevel  # =&gt; RUBY_PATCHLEVEL</span>
+    <span class="c"># RubyVersion.description # =&gt; RUBY_DESCRIPTION</span>
+  <span class="r">end</span>
+
+  after <span class="sy">:all</span> <span class="r">do</span>
+    capture_stderr{ <span class="co">RUBY_VERSION</span> = <span class="iv">@remember_version</span> }
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_version_source">(<a href="javascript:show('version_source')">show</a>)</span>
+         <pre class="source" id="version_source">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+require <span class="s"><span class="dl">'</span><span class="k">date</span><span class="dl">'</span></span>
+require <span class="s"><span class="dl">'</span><span class="k">time</span><span class="dl">'</span></span>
+
+<span class="r">module</span> <span class="cl">RubyVersion</span>
+  <span class="r">class</span> &lt;&lt; <span class="cl">self</span>
+    <span class="r">def</span> <span class="fu">to_s</span>
+      <span class="co">RUBY_VERSION</span>
+    <span class="r">end</span>
+
+    <span class="c"># comparable</span>
+    <span class="r">def</span> <span class="fu">&lt;=&gt;</span>(other)
+      value = <span class="r">case</span> other
+        <span class="r">when</span> <span class="co">Integer</span>
+          <span class="co">RUBY_VERSION</span>.to_i
+        <span class="r">when</span> <span class="co">Float</span>
+          <span class="co">RUBY_VERSION</span>.to_f
+        <span class="r">when</span> <span class="co">String</span>
+          <span class="co">RUBY_VERSION</span>
+        <span class="r">when</span> <span class="co">Date</span>, <span class="co">Time</span>
+          other.class.parse(<span class="co">RUBY_RELEASE_DATE</span>)
+        <span class="r">else</span>
+          other = other.to_s
+          <span class="co">RUBY_VERSION</span>
+        <span class="r">end</span>
+      value &lt;=&gt; other
+    <span class="r">end</span>
+    include <span class="co">Comparable</span>
+
+    <span class="c"># chaining for dsl-like language</span>
+    <span class="r">def</span> <span class="fu">is?</span>(other = <span class="pc">nil</span>)
+      <span class="r">if</span> other
+        <span class="co">RubyVersion</span> == other
+      <span class="r">else</span>
+        <span class="co">RubyVersion</span>
+      <span class="r">end</span>
+    <span class="r">end</span>
+    <span class="r">alias</span> <span class="fu">is</span> <span class="fu">is?</span>
+
+    <span class="c"># aliases</span>
+    <span class="r">alias</span> <span class="fu">below</span>     <span class="fu">&lt;</span>
+    <span class="r">alias</span> <span class="fu">below?</span>    <span class="fu">&lt;</span>
+    <span class="r">alias</span> <span class="fu">at_most</span>   <span class="fu">&lt;=</span>
+    <span class="r">alias</span> <span class="fu">at_most?</span>  <span class="fu">&lt;=</span>
+    <span class="r">alias</span> <span class="fu">above</span>     <span class="fu">&gt;</span>
+    <span class="r">alias</span> <span class="fu">above?</span>    <span class="fu">&gt;</span>
+    <span class="r">alias</span> <span class="fu">at_least</span>  <span class="fu">&gt;=</span>
+    <span class="r">alias</span> <span class="fu">at_least?</span> <span class="fu">&gt;=</span>
+    <span class="r">alias</span> <span class="fu">exactly</span>   <span class="fu">==</span>
+    <span class="r">alias</span> <span class="fu">exactly?</span>  <span class="fu">==</span>
+    <span class="r">def</span> <span class="fu">not</span>(other)
+      <span class="pc">self</span> != other
+    <span class="r">end</span>
+    <span class="r">alias</span> <span class="fu">not?</span>     <span class="fu">not</span>
+    <span class="r">alias</span> <span class="fu">between</span> <span class="fu">between?</span>
+
+    <span class="c"># compare dates</span>
+    <span class="r">def</span> <span class="fu">newer_than</span>(other)
+      <span class="r">if</span> other.is_a? <span class="co">Date</span> <span class="r">or</span> other.is_a? <span class="co">Time</span>
+        <span class="co">RubyVersion</span> &gt; other
+      <span class="r">else</span>
+        <span class="co">RUBY_RELEASE_DATE</span> &gt; other.to_s
+      <span class="r">end</span>
+    <span class="r">end</span>
+    <span class="r">alias</span> <span class="fu">newer_than?</span> <span class="fu">newer_than</span>
+
+    <span class="r">def</span> <span class="fu">older_than</span>(other)
+      <span class="r">if</span> other.is_a? <span class="co">Date</span> <span class="r">or</span> other.is_a? <span class="co">Time</span>
+        <span class="co">RubyVersion</span> &lt; other
+      <span class="r">else</span>
+        <span class="co">RUBY_RELEASE_DATE</span> &lt; other.to_s
+      <span class="r">end</span>
+    <span class="r">end</span>
+    <span class="r">alias</span> <span class="fu">older_than?</span> <span class="fu">older_than</span>
+
+    <span class="r">def</span> <span class="fu">released_today</span>
+      <span class="co">RubyVersion</span>.date == <span class="co">Date</span>.today
+    <span class="r">end</span>
+    <span class="r">alias</span> <span class="fu">released_today?</span> <span class="fu">released_today</span>
+
+    <span class="c"># accessors</span>
+
+    <span class="r">def</span> <span class="fu">major</span>
+      <span class="co">RUBY_VERSION</span>.to_i
+    <span class="r">end</span>
+    <span class="r">alias</span> <span class="fu">main</span> <span class="fu">major</span>
+
+    <span class="r">def</span> <span class="fu">minor</span>
+      <span class="co">RUBY_VERSION</span>.split(<span class="s"><span class="dl">'</span><span class="k">.</span><span class="dl">'</span></span>)[<span class="i">1</span>].to_i
+    <span class="r">end</span>
+    <span class="r">alias</span> <span class="fu">mini</span> <span class="fu">minor</span>
+
+    <span class="r">def</span> <span class="fu">tiny</span>
+      <span class="co">RUBY_VERSION</span>.split(<span class="s"><span class="dl">'</span><span class="k">.</span><span class="dl">'</span></span>)[<span class="i">2</span>].to_i
+    <span class="r">end</span>
+
+    <span class="r">alias</span> <span class="fu">teeny</span> <span class="fu">tiny</span>
+
+    <span class="r">def</span> <span class="fu">patchlevel</span>
+      <span class="co">RUBY_PATCHLEVEL</span>
+    <span class="r">end</span>
+
+    <span class="r">def</span> <span class="fu">platform</span>
+      <span class="co">RUBY_PLATFORM</span>
+    <span class="r">end</span>
+
+    <span class="r">def</span> <span class="fu">release_date</span>
+      <span class="co">Date</span>.parse <span class="co">RUBY_RELEASE_DATE</span>
+    <span class="r">end</span>
+    <span class="r">alias</span> <span class="fu">date</span> <span class="fu">release_date</span>
+
+    <span class="r">def</span> <span class="fu">description</span>
+      <span class="co">RUBY_DESCRIPTION</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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/version">github wiki</a></td></tr></table>
+        </div> 
+      <h2 title="require 'zucker/extensions'" id="extensions">Cubes[extensions]</h2>
+        
+        <div class="cubes">
+         <h3 title="require 'zucker/array'" id="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>&amp;</code> and <code>|</code>, but why does it not have <code>^</code>?</p><p><code>sum</code> 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">zucker/array</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Array#^</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should do an exclusive or</span><span class="dl">'</span></span> <span class="r">do</span>
+    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">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<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="c"># can take an argument &amp; block to be Rails compatible</span>
+  <span class="r">def</span> <span class="fu">sum</span>(identity = <span class="i">0</span>, &amp;block)
+    <span class="c"># inject(:+)</span>
+    <span class="r">if</span> block_given?
+      map(&amp;block).sum( identity )
+    <span class="r">else</span>
+      inject(<span class="sy">:+</span>) || identity
+    <span class="r">end</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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/array">github wiki</a></td></tr></table> <h3 title="require 'zucker/enumerable'" id="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>Information</th>    <td>Inspired by Ruby Facets' <code>mash</code>.</td></tr><tr><th>Specification</th>    <td> <span id="show_enumerable_spec">(<a href="javascript:show('enumerable_spec')">show</a>)</span>
+         <pre class="source" id="enumerable_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/enumerable</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Enumerable#mash</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should &quot;map&quot; a hash</span><span class="dl">'</span></span> <span class="r">do</span>
+    [<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">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/enumerable">github wiki</a></td></tr></table> <h3 title="require 'zucker/file'" id="file">file</h3>
+         <table class="cube_table"
+                id="file_cube"
+                title="require 'zucker/file'"> <tr><th>Summary</th>    <td>Extensions for <code>File</code>.</td></tr><tr><th>Methods/Usage</th>    <td><h5>File#gsub</h5><pre class="usage source" style="display:block"><span class="co">File</span>.gsub <span class="s"><span class="dl">'</span><span class="k">some_filename</span><span class="dl">'</span></span>, {
+  <span class="rx"><span class="dl">/</span><span class="k">hi</span><span class="dl">/</span></span> =&gt; <span class="s"><span class="dl">'</span><span class="k">cu</span><span class="dl">'</span></span>,
+  <span class="rx"><span class="dl">/</span><span class="ch">\d</span><span class="dl">/</span></span> =&gt; proc <span class="r">do</span> (<span class="gv">$&amp;</span>.to_i+<span class="i">1</span>).to_s <span class="r">end</span>
+} <span class="c"># will read the file and substitute the hash keys with their values</span>
+</pre><h5>File#delete!</h5><pre class="usage source" style="display:block"><span class="co">File</span>.delete! <span class="s"><span class="dl">'</span><span class="k">some_filename</span><span class="dl">'</span></span> <span class="c"># will delete the file, don't care if it exist.</span></pre></td></tr><tr><th>Information</th>    <td>Idea for <code>.File#delete!</code>. from sugar-high.</td></tr><tr><th>Specification</th>    <td> <span id="show_file_spec">(<a href="javascript:show('file_spec')">show</a>)</span>
+         <pre class="source" id="file_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/file</span><span class="dl">'</span></span>
+require <span class="s"><span class="dl">'</span><span class="k">fileutils</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">File#gsub</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should read filename in arg1, substitute every key in the arg2 with its value and save the file</span><span class="dl">'</span></span> 
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">File#delete!</span><span class="dl">'</span></span> <span class="r">do</span>
+  let <span class="sy">:random_filename</span>   <span class="r">do</span>
+    <span class="s"><span class="dl">'</span><span class="k">test_</span><span class="dl">'</span></span> + (<span class="i">0</span>..<span class="i">20</span>).map{|e| [*<span class="s"><span class="dl">'</span><span class="k">a</span><span class="dl">'</span></span>..<span class="s"><span class="dl">'</span><span class="k">z</span><span class="dl">'</span></span>].send <span class="co">RUBY_VERSION</span> &gt; <span class="s"><span class="dl">'</span><span class="k">1.9</span><span class="dl">'</span></span> ? <span class="sy">:sample</span> : <span class="sy">:choice</span> }*<span class="s"><span class="dl">'</span><span class="dl">'</span></span>
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should delete the filename given as argument if it exists + return non-nil</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="co">FileUtils</span>.touch random_filename
+    res = <span class="pc">false</span>
+    proc <span class="r">do</span>
+      res = <span class="co">File</span>.delete! random_filename
+    <span class="r">end</span>.should_not raise_exception
+    res.should be_true
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should do nothing if the filename given as argument does not exist + return nil</span><span class="dl">'</span></span> <span class="r">do</span>
+    res = <span class="pc">false</span>
+    proc <span class="r">do</span>
+      res = <span class="co">File</span>.delete! random_filename
+    <span class="r">end</span>.should_not raise_exception
+    res.should be_false
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_file_source">(<a href="javascript:show('file_source')">show</a>)</span>
+         <pre class="source" id="file_source"><span class="r">class</span> &lt;&lt; <span class="cl">File</span>
+  <span class="r">def</span> <span class="fu">gsub</span>(filename, regex_hash)
+    data = <span class="co">File</span>.read filename
+    <span class="co">File</span>.open(filename,<span class="s"><span class="dl">'</span><span class="k">w</span><span class="dl">'</span></span>){ |file|
+      regex_hash.each{ |regex, new_string|
+        regex = regex.to_s <span class="r">unless</span> regex.is_a? <span class="co">Regexp</span>
+
+        <span class="r">if</span> new_string.is_a? <span class="co">Proc</span>
+          data.gsub! regex, &amp;new_string
+        <span class="r">else</span>
+          data.gsub! regex, new_string
+        <span class="r">end</span>
+      }
+      file.print data
+    }
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">delete!</span> filename
+    <span class="r">return</span> <span class="pc">nil</span> <span class="r">if</span> !<span class="co">File</span>.exist?(filename)
+    <span class="co">File</span>.delete filename
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/file">github wiki</a></td></tr></table> <h3 title="require 'zucker/hash'" id="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#&lt;&lt;</h5><pre class="usage source" style="display:block">{<span class="i">1</span>=&gt;<span class="i">2</span>} &lt;&lt; [<span class="i">3</span>, <span class="i">4</span>]   <span class="c"># =&gt; { 1=&gt;2, 3=&gt;4 }</span>
+{<span class="i">1</span>=&gt;<span class="i">2</span>} &lt;&lt; { <span class="i">5</span>=&gt;<span class="i">6</span> } <span class="c"># =&gt; { 1=&gt;2, 5=&gt;6 }</span>
+</pre><h5>Hash#&amp;</h5><pre class="usage source" style="display:block">{ <span class="i">1</span>=&gt;<span class="i">4</span>, <span class="i">2</span>=&gt;<span class="i">5</span>, <span class="i">3</span>=&gt;<span class="i">6</span> } &amp; { <span class="i">1</span>=&gt;<span class="i">4</span>, <span class="i">2</span>=&gt;<span class="i">7</span> } <span class="c"># =&gt; { 1=&gt;4 }</span></pre></td></tr><tr><th>Information</th>    <td>Some of the operators are inspired by Ruby Facets.</td></tr><tr><th>Specification</th>    <td> <span id="show_hash_spec">(<a href="javascript:show('hash_spec')">show</a>)</span>
+         <pre class="source" id="hash_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/hash</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Hash.zip</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should zip together both given enumerables and take them as key=&gt;values for a new hash</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="co">Hash</span>.zip( [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>], [<span class="i">4</span>,<span class="i">5</span>,<span class="i">6</span>] ).should == { <span class="i">1</span>=&gt;<span class="i">4</span>, <span class="i">2</span>=&gt;<span class="i">5</span>, <span class="i">3</span>=&gt;<span class="i">6</span> }
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Hash#&lt;&lt;</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should append new elements to the hash</span><span class="dl">'</span></span> <span class="r">do</span>
+    a =  { <span class="i">1</span>=&gt;<span class="i">4</span>, <span class="i">2</span>=&gt;<span class="i">5</span>, <span class="i">3</span>=&gt;<span class="i">6</span> }
+    a &lt;&lt; { <span class="i">4</span>=&gt;<span class="i">7</span> }
+    a &lt;&lt; [<span class="i">5</span>, <span class="i">8</span>]
+    a.should == { <span class="i">1</span>=&gt;<span class="i">4</span>, <span class="i">2</span>=&gt;<span class="i">5</span>, <span class="i">3</span>=&gt;<span class="i">6</span>, <span class="i">4</span>=&gt;<span class="i">7</span>, <span class="i">5</span>=&gt;<span class="i">8</span> }
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Hash#&amp;</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should select a sub hash containt only equal key-value pairs</span><span class="dl">'</span></span> <span class="r">do</span>
+    a =  { <span class="i">1</span>=&gt;<span class="i">4</span>, <span class="i">2</span>=&gt;<span class="i">5</span>, <span class="i">3</span>=&gt;<span class="i">6</span> }
+    b=   { <span class="i">1</span>=&gt;<span class="i">4</span>, <span class="i">2</span>=&gt;<span class="i">7</span> }
+    (a &amp; b).should == { <span class="i">1</span>=&gt;<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_hash_source">(<a href="javascript:show('hash_source')">show</a>)</span>
+         <pre class="source" id="hash_source">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<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>[ *keys.zip( values ).flatten ]
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">&lt;&lt;</span>(other)
+    <span class="r">case</span>
+    <span class="r">when</span> other.is_a?(<span class="co">Hash</span>)
+      merge! other
+    <span class="r">when</span> other.is_a?(<span class="co">Enumerable</span>) || other.respond_to?(<span class="sy">:to_splat</span>)
+      merge! <span class="co">Hash</span>[*other]
+    <span class="r">else</span>
+      raise <span class="co">TypeError</span>, <span class="s"><span class="dl">'</span><span class="k">can only append other Hashs and Enumerables (or Classes that implement to_splat)</span><span class="dl">'</span></span>
+    <span class="r">end</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">&amp;</span>(other)
+    <span class="co">Hash</span>[ *select{ |k,v|
+      other[k] == v
+    }.flatten ]
+  <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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/hash">github wiki</a></td></tr></table> <h3 title="require 'zucker/string'" id="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">1234abc5678</span><span class="dl">'</span></span> - <span class="s"><span class="dl">'</span><span class="k">b</span><span class="dl">'</span></span> - <span class="rx"><span class="dl">/</span><span class="ch">\d</span><span class="dl">/</span></span> <span class="c"># =&gt; ac</span></pre><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">7</span> <span class="c"># =&gt; 'No'</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><h5>String#constantize</h5><pre class="usage source" style="display:block"><span class="s"><span class="dl">'</span><span class="k">Object</span><span class="dl">'</span></span>.constantize <span class="c"># =&gt; Object</span>
+<span class="s"><span class="dl">'</span><span class="k">Spec::VERSION</span><span class="dl">'</span></span>.constantize <span class="c"># =&gt; Spec::VERSION if rspec is loaded</span>
+<span class="c"># you can also pass a parameter or block to define what happens, when constant does not exist</span>
+<span class="s"><span class="dl">'</span><span class="k">IdontExist</span><span class="dl">'</span></span>.constantize(<span class="co">Array</span>) <span class="c"># =&gt; Array</span>
+<span class="s"><span class="dl">'</span><span class="k">String5</span><span class="dl">'</span></span>.constantize <span class="r">do</span> |string|
+  string.chop.constantize
+<span class="r">end</span> <span class="c"># =&gt; String</span>
+</pre></td></tr><tr><th>Information</th>    <td><code>constantize</code> is an improved version of ActiveSupport's one.</td></tr><tr><th>Specification</th>    <td> <span id="show_string_spec">(<a href="javascript:show('string_spec')">show</a>)</span>
+         <pre class="source" id="string_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/string</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">String#-</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should remove the applied Regexp or String from self via gsub</span><span class="dl">'</span></span> <span class="r">do</span>
+    (<span class="s"><span class="dl">'</span><span class="k">1234abc5678</span><span class="dl">'</span></span> - <span class="s"><span class="dl">'</span><span class="k">b</span><span class="dl">'</span></span> - <span class="rx"><span class="dl">/</span><span class="ch">\d</span><span class="dl">/</span></span>).should == <span class="s"><span class="dl">'</span><span class="k">ac</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 <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>
+
+  describe <span class="s"><span class="dl">'</span><span class="k">String#constantize</span><span class="dl">'</span></span> <span class="r">do</span>
+    it <span class="s"><span class="dl">'</span><span class="k">should return the constant with that name</span><span class="dl">'</span></span> <span class="r">do</span>
+      <span class="s"><span class="dl">'</span><span class="k">Object</span><span class="dl">'</span></span>.constantize.should == <span class="co">Object</span>
+    <span class="r">end</span>
+
+    it <span class="s"><span class="dl">'</span><span class="k">should also work for nested constants</span><span class="dl">'</span></span> <span class="r">do</span>
+      <span class="s"><span class="dl">'</span><span class="k">Zucker::VERSION</span><span class="dl">'</span></span>.constantize.should == <span class="co">Zucker</span>::<span class="co">VERSION</span>
+    <span class="r">end</span>
+
+    it <span class="s"><span class="dl">'</span><span class="k">should throw name error if constant does not exist (and no parameter is given)</span><span class="dl">'</span></span> <span class="r">do</span>
+      proc <span class="r">do</span>
+        <span class="s"><span class="dl">'</span><span class="k">ObfsefsefsefafesafaefRubyZuckerafdfselijfesject</span><span class="dl">'</span></span>.constantize
+      <span class="r">end</span>.should raise_exception <span class="co">NameError</span>
+    <span class="r">end</span>
+
+    it <span class="s"><span class="dl">'</span><span class="k">should call the block (and not raise an error) if constant does not exist and block given</span><span class="dl">'</span></span> <span class="r">do</span>
+      proc <span class="r">do</span>
+        <span class="s"><span class="dl">'</span><span class="k">ObfsefsefsefafesafaefRubyZuckerafdfselijfesject</span><span class="dl">'</span></span>.constantize <span class="r">do</span> |string|
+           <span class="co">Default</span> = [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>]
+        <span class="r">end</span>.should == [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>]
+      <span class="r">end</span>.should_not raise_exception <span class="co">NameError</span>
+    <span class="r">end</span>
+
+    it <span class="s"><span class="dl">'</span><span class="k">should return the second parameter (and not raise an error) if constant does not exist and parameter given</span><span class="dl">'</span></span> <span class="r">do</span>
+      proc <span class="r">do</span>
+        <span class="s"><span class="dl">'</span><span class="k">ObfsefsefsefafesafaefRubyZuckerafdfselijfesject</span><span class="dl">'</span></span>.constantize(<span class="co">Array</span>).should == <span class="co">Array</span>
+      <span class="r">end</span>.should_not raise_exception <span class="co">NameError</span>
+    <span class="r">end</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">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<span class="r">class</span> <span class="cl">String</span>
+  <span class="r">def</span> <span class="fu">-</span>(rem)
+    gsub( <span class="co">Regexp</span> === rem ? rem : rem.to_s, <span class="s"><span class="dl">'</span><span class="dl">'</span></span> )
+  <span class="r">end</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>)
+    reverse.chomp(arg).reverse
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">lchomp!</span>(arg = <span class="gv">$/</span>)
+    reverse.chomp!(arg).reverse
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">ords</span>
+    unpack <span class="s"><span class="dl">'</span><span class="k">C*</span><span class="dl">'</span></span>
+   <span class="c"># bytes.to_a</span>
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">constantize</span>(default_value = <span class="pc">nil</span>) <span class="c"># always uses global scope as in AS... is this good?</span>
+    get_constant = lambda{
+      <span class="pc">self</span>.split(<span class="rx"><span class="dl">/</span><span class="k">::</span><span class="dl">/</span></span>).inject( <span class="co">Object</span> ){ |base_constant, current_constant|
+        base_constant.const_get current_constant
+      }      
+    }
+
+    <span class="r">if</span> !default_value &amp;&amp; !block_given?
+      get_constant.call
+    <span class="r">else</span>
+      <span class="r">begin</span>
+        get_constant.call
+      <span class="r">rescue</span> <span class="co">NameError</span>
+        <span class="r">if</span> block_given?
+          <span class="r">yield</span> <span class="pc">self</span>
+        <span class="r">else</span>
+          default_value
+        <span class="r">end</span>
+      <span class="r">end</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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/string">github wiki</a></td></tr></table> <h3 title="require 'zucker/unary'" id="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>Information</th>    <td>Inspired by (I've seen the unary + for Symbol somewhere on the net... but cannot remember where...)</td></tr><tr><th>Specification</th>    <td> <span id="show_unary_spec">(<a href="javascript:show('unary_spec')">show</a>)</span>
+         <pre class="source" id="unary_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/unary</span><span class="dl">'</span></span>
+
+describe <span class="co">Symbol</span>, <span class="s"><span class="dl">'</span><span class="k">#+@</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should convert to_s</span><span class="dl">'</span></span> <span class="r">do</span>
+    +(<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">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<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 (<code>+:literal</code> not possible)</td></tr><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/unary">github wiki</a></td></tr></table> <h3 title="require 'zucker/union'" id="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">zucker/union</span><span class="dl">'</span></span>
+
+shared_examples_for <span class="s"><span class="dl">&quot;</span><span class="k">Regexp.union operator</span><span class="dl">&quot;</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">&quot;</span><span class="k">should create an Regexp.union of both operands</span><span class="dl">&quot;</span></span> <span class="r">do</span>
+    (<span class="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>).should ==
+      <span class="co">Regexp</span>.union( <span class="co">Regexp</span>.union( <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="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Regexp#|</span><span class="dl">'</span></span> <span class="r">do</span>
+  it_should_behave_like <span class="s"><span class="dl">'</span><span class="k">Regexp.union operator</span><span class="dl">'</span></span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">String#|</span><span class="dl">'</span></span> <span class="r">do</span>
+  it_should_behave_like <span class="s"><span class="dl">'</span><span class="k">Regexp.union operator</span><span class="dl">'</span></span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_union_source">(<a href="javascript:show('union_source')">show</a>)</span>
+         <pre class="source" id="union_source">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<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, 1.8</td></tr><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/union">github wiki</a></td></tr></table>
+        </div> 
+      <h2 title="require 'zucker/object'" id="object">Cubes[object]</h2>
+        
+        <div class="cubes">
+         <h3 title="require 'zucker/blank'" id="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>Specification</th>    <td> <span id="show_blank_spec">(<a href="javascript:show('blank_spec')">show</a>)</span>
+         <pre class="source" id="blank_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/blank</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Object#blank?</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should be blank for blank values</span><span class="dl">'</span></span> <span class="r">do</span>
+    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">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/blank">github wiki</a></td></tr></table> <h3 title="require 'zucker/mcopy'" id="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">zucker/mcopy</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Object#mcopy</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">create a (deep) copy via marshalling</span><span class="dl">'</span></span> <span class="r">do</span>
+    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">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<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="r">end</span>
+
+<span class="c"># J-_-L</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/mcopy">github wiki</a></td></tr></table> <h3 title="require 'zucker/not'" id="not">not</h3>
+         <table class="cube_table"
+                id="not_cube"
+                title="require 'zucker/not'"> <tr><th>Summary</th>    <td><code>not</code> returns an object on which all methods are redirected to it's receiver object, but returns inverted boolean.</td></tr><tr><th>Why?</th>    <td>Better readability.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Object#not</h5><pre class="usage source" style="display:block">[<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>].not.empty? <span class="c"># true</span>
+</pre></td></tr><tr><th>Information</th>    <td>See <a href="http://blog.jayfields.com/2007/08/ruby-adding-not-method-for-readability.html">this article by Jay Field</a> for more information.</td></tr><tr><th>Specification</th>    <td> <span id="show_not_spec">(<a href="javascript:show('not_spec')">show</a>)</span>
+         <pre class="source" id="not_spec"><span class="r">if</span> <span class="r">defined?</span> <span class="co">BasicObject</span> <span class="c"># 1.9 only</span>
+
+  require <span class="s"><span class="dl">'</span><span class="k">zucker/not</span><span class="dl">'</span></span>
+
+  describe <span class="s"><span class="dl">'</span><span class="k">Object#not</span><span class="dl">'</span></span> <span class="r">do</span>
+    it <span class="s"><span class="dl">&quot;</span><span class="k">should return an object on which all methods are redirected to it's receiver object, but return an inverted boolean</span><span class="dl">&quot;</span></span> <span class="r">do</span>
+      [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>].not.empty?.should == <span class="pc">true</span>
+      <span class="pc">nil</span>.not.nil?.should == <span class="pc">false</span>
+    <span class="r">end</span>
+  <span class="r">end</span>
+
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_not_source">(<a href="javascript:show('not_source')">show</a>)</span>
+         <pre class="source" id="not_source">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<span class="r">class</span> <span class="cl">Object</span>
+  <span class="r">def</span> <span class="fu">not</span>
+    <span class="co">NotClass</span>.new <span class="pc">self</span>
+  <span class="r">end</span>
+
+  <span class="r">class</span> <span class="cl">NotClass</span> &lt; <span class="co">BasicObject</span>
+    <span class="r">def</span> <span class="fu">initialize</span>(receiver)
+      <span class="iv">@receiver</span> = receiver
+    <span class="r">end</span>
+    
+    <span class="r">def</span> <span class="fu">method_missing</span>(m, *args, &amp;block)
+      <span class="r">not</span> <span class="iv">@receiver</span>.public_send( m, *args, &amp;block )
+    <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</td></tr><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/not">github wiki</a></td></tr></table>
+        </div> 
+      <h2 title="require 'zucker/to_proc'" id="to_proc">Cubes[to_proc]</h2>
+        
+        <div class="cubes">
+         <h3 title="require 'zucker/array_to_proc'" id="array_to_proc">array_to_proc</h3>
+         <table class="cube_table"
+                id="array_to_proc_cube"
+                title="require 'zucker/array_to_proc'"> <tr><th>Summary</th>    <td>Calls the method named by the first paramenter and passes the other elements as paramaters.</td></tr><tr><th>Why?</th>    <td>When using <code>Symbol#to_proc</code>, you often wish to pass parameters.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Array#to_proc</h5><pre class="usage source" style="display:block">[<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>].map &amp;[<span class="sy">:*</span>, <span class="i">5</span>] <span class="c"># =&gt; [5, 10, 15, 20]</span>
+<span class="c"># you can also chain them, if the first parameter is an Array</span>
+[<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>].map &amp;[[<span class="sy">:to_s</span>, <span class="i">2</span>],[<span class="sy">:+</span>, <span class="s"><span class="dl">'</span><span class="k">b</span><span class="dl">'</span></span>]]   <span class="c"># =&gt; [&quot;1b&quot;, &quot;10b&quot;, &quot;11b&quot;, &quot;100b&quot;]</span>
+</pre></td></tr><tr><th>Information</th>    <td>Inspired by <a href="http://www.sanityinc.com/articles/adding-array-to-proc-to-ruby">this article</a>.<br/>More about <a href="http://rbjl.net/29-become-a-proc-star">to_proc</a>.<br/>Chaining inspired by <a href="http://github.com/eregon/Classes/blob/master/to_proc.rb">eregon</a>.</td></tr><tr><th>Specification</th>    <td> <span id="show_array_to_proc_spec">(<a href="javascript:show('array_to_proc_spec')">show</a>)</span>
+         <pre class="source" id="array_to_proc_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/array_to_proc</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Array#to_proc</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should call the method of the first symbol, using the remaining elements as paramaters</span><span class="dl">'</span></span> <span class="r">do</span>
+    [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>].map( &amp;[<span class="sy">:to_s</span>, <span class="i">2</span>] ).should == [<span class="s"><span class="dl">&quot;</span><span class="k">1</span><span class="dl">&quot;</span></span>, <span class="s"><span class="dl">&quot;</span><span class="k">10</span><span class="dl">&quot;</span></span>, <span class="s"><span class="dl">&quot;</span><span class="k">11</span><span class="dl">&quot;</span></span>, <span class="s"><span class="dl">&quot;</span><span class="k">100</span><span class="dl">&quot;</span></span>]
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">&quot;</span><span class="k">should convert each element to a proc and chain it, if the first parameter is an array</span><span class="dl">&quot;</span></span> <span class="r">do</span>
+    [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>].map( &amp;[[<span class="sy">:*</span>,<span class="i">2</span>],[<span class="sy">:+</span>,<span class="i">4</span>]] ).should == [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>,<span class="i">4</span>].map{|i| i*<span class="i">2</span> + <span class="i">4</span> }
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_array_to_proc_source">(<a href="javascript:show('array_to_proc_source')">show</a>)</span>
+         <pre class="source" id="array_to_proc_source">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<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|
+      <span class="r">if</span> <span class="pc">self</span>.first.is_a? <span class="co">Array</span>
+        <span class="pc">self</span>.inject(obj){ |result, nested_array|
+          nested_array.to_proc.call result
+        }
+      <span class="r">else</span>
+        obj.send *<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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/array_to_proc">github wiki</a></td></tr></table> <h3 title="require 'zucker/class_to_proc'" id="class_to_proc">class_to_proc</h3>
+         <table class="cube_table"
+                id="class_to_proc_cube"
+                title="require 'zucker/class_to_proc'"> <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>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_class_to_proc_spec">(<a href="javascript:show('class_to_proc_spec')">show</a>)</span>
+         <pre class="source" id="class_to_proc_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/class_to_proc</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_class_to_proc_source">(<a href="javascript:show('class_to_proc_source')">show</a>)</span>
+         <pre class="source" id="class_to_proc_source">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/class_to_proc">github wiki</a></td></tr></table> <h3 title="require 'zucker/hash_to_proc'" id="hash_to_proc">hash_to_proc</h3>
+         <table class="cube_table"
+                id="hash_to_proc_cube"
+                title="require 'zucker/hash_to_proc'"> <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>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_hash_to_proc_spec">(<a href="javascript:show('hash_to_proc_spec')">show</a>)</span>
+         <pre class="source" id="hash_to_proc_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/hash_to_proc</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_hash_to_proc_source">(<a href="javascript:show('hash_to_proc_source')">show</a>)</span>
+         <pre class="source" id="hash_to_proc_source">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/hash_to_proc">github wiki</a></td></tr></table> <h3 title="require 'zucker/regexp_to_proc'" id="regexp_to_proc">regexp_to_proc</h3>
+         <table class="cube_table"
+                id="regexp_to_proc_cube"
+                title="require 'zucker/regexp_to_proc'"> <tr><th>Summary</th>    <td>Use <code>&amp;/regex/</code> 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>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_regexp_to_proc_spec">(<a href="javascript:show('regexp_to_proc_spec')">show</a>)</span>
+         <pre class="source" id="regexp_to_proc_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/regexp_to_proc</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_regexp_to_proc_source">(<a href="javascript:show('regexp_to_proc_source')">show</a>)</span>
+         <pre class="source" id="regexp_to_proc_source">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/regexp_to_proc">github wiki</a></td></tr></table>
+        </div> 
+      <h2 title="require 'zucker/shortcuts'" id="shortcuts">Cubes[shortcuts]</h2>
+        
+        <div class="cubes">
+         <h3 title="require 'zucker/alias_for'" id="alias_for">alias_for</h3>
+         <table class="cube_table"
+                id="alias_for_cube"
+                title="require 'zucker/alias_for'"> <tr><th>Summary</th>    <td>A different way to create aliases: Reversed order and you can pass multiple alias names.</td></tr><tr><th>Why?</th>    <td>It's clearer in which order to put the arguments.</td></tr><tr><th>Methods/Usage</th>    <td><h5>alias_for, aliases_for</h5><pre class="usage source" style="display:block">alias_for <span class="sy">:methods</span>, <span class="sy">:ms</span> <span class="c"># creates an alias for the method :methods with the name ms</span>
+<span class="r">module</span> <span class="cl">Enumerable</span>
+  aliases_for <span class="sy">:zip</span>, <span class="sy">:with</span>, <span class="sy">:%</span>
+<span class="r">end</span> <span class="c"># creates multiple aliases</span>
+</pre><h5>Module#method_alias_for, Module#method_aliases_for</h5><pre class="usage source" style="display:block"><span class="c"># same as alias_for, but using Module#alias_method instead of alias</span>
+</pre></td></tr><tr><th>Information</th>    <td>Thanks to Kristian Mandrup for the idea and alias method specs.</td></tr><tr><th>Specification</th>    <td> <span id="show_alias_for_spec">(<a href="javascript:show('alias_for_spec')">show</a>)</span>
+         <pre class="source" id="alias_for_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/alias_for</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">alias_for</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 alias for global methods</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="c"># rspec bug? </span>
+    <span class="c"># def m1</span>
+    <span class="c">#   1</span>
+    <span class="c"># end</span>
+    <span class="c"># alias_for :m1, :a1</span>
+    <span class="c">#</span>
+    <span class="c"># proc do</span>
+    <span class="c">#   a1.should == 1</span>
+    <span class="c"># end.should_not raise_exception</span>
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should create an alias for instance methods</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="r">class</span> <span class="cl">Array</span>
+      <span class="r">def</span> <span class="fu">m2</span>
+        <span class="i">2</span>
+      <span class="r">end</span>
+      alias_for <span class="sy">:m2</span>, <span class="sy">:a2</span>
+    <span class="r">end</span>
+    proc <span class="r">do</span>
+
+      [<span class="i">1</span>,<span class="i">2</span>,<span class="i">3</span>].a2.should == <span class="i">2</span>
+    <span class="r">end</span>.should_not raise_exception
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should create an alias for class (singleton) methods</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="r">class</span> <span class="cl">Array</span>
+      <span class="r">class</span> &lt;&lt; <span class="cl">Array</span>
+        <span class="r">def</span> <span class="fu">m3</span>
+          <span class="i">3</span>
+        <span class="r">end</span>
+        alias_for <span class="sy">:m3</span>, <span class="sy">:a3</span>
+      <span class="r">end</span>
+    <span class="r">end</span>
+
+    proc <span class="r">do</span>
+      <span class="co">Array</span>.a3.should == <span class="i">3</span>
+    <span class="r">end</span>.should_not raise_exception
+  <span class="r">end</span>
+
+
+  it <span class="s"><span class="dl">'</span><span class="k">should create aliases for the first argument with all other arguments</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="r">class</span> <span class="cl">Object</span>
+      <span class="r">def</span> <span class="fu">m4</span>
+        <span class="i">4</span>
+      <span class="r">end</span>
+    alias_for <span class="sy">:m4</span>, <span class="sy">:ma</span>, <span class="sy">:mb</span>, <span class="sy">:mc</span>
+    <span class="r">end</span>
+    proc <span class="r">do</span>
+      <span class="i">1</span>.ma.should   == <span class="i">4</span>
+      <span class="s"><span class="dl">&quot;</span><span class="k">1</span><span class="dl">&quot;</span></span>.mb.should == <span class="i">4</span>
+      [<span class="i">1</span>].mc.should == <span class="i">4</span>
+    <span class="r">end</span>.should_not raise_exception
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="c"># alias_method</span>
+<span class="r">module</span> <span class="cl">Blip</span>
+  <span class="r">def</span> <span class="fu">blip</span>
+    <span class="s"><span class="dl">'</span><span class="k">blip</span><span class="dl">'</span></span>
+  <span class="r">end</span>
+  alias_methods_for <span class="sy">:blip</span>, <span class="sy">:blap</span>, <span class="sy">:blup</span>
+  
+  <span class="r">class</span> &lt;&lt; <span class="cl">self</span>
+    <span class="r">def</span> <span class="fu">self_blip</span>
+      <span class="s"><span class="dl">'</span><span class="k">blip</span><span class="dl">'</span></span>
+    <span class="r">end</span>
+    alias_methods_for <span class="sy">:self_blip</span>, <span class="sy">:self_blap</span>, <span class="sy">:self_blup</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+<span class="r">class</span> <span class="cl">Hello</span>
+  include <span class="co">Blip</span>
+  
+  <span class="r">def</span> <span class="fu">hello</span>
+    <span class="s"><span class="dl">'</span><span class="k">hello</span><span class="dl">'</span></span>
+  <span class="r">end</span>
+  alias_methods_for <span class="sy">:hello</span>, <span class="sy">:hi</span>, <span class="sy">:howdy</span>
+  
+  <span class="r">class</span> &lt;&lt; <span class="cl">self</span>
+    <span class="r">def</span> <span class="fu">self_hello</span>
+      <span class="s"><span class="dl">'</span><span class="k">hello</span><span class="dl">'</span></span>
+    <span class="r">end</span>
+    alias_methods_for <span class="sy">:self_hello</span>, <span class="sy">:self_hi</span>, <span class="sy">:self_howdy</span>
+  <span class="r">end</span>
+<span class="r">end</span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">alias_methods_for</span><span class="dl">'</span></span> <span class="r">do</span>
+  let(<span class="sy">:h</span>) { <span class="co">Hello</span>.new }
+
+  context <span class="s"><span class="dl">&quot;</span><span class="k">module context</span><span class="dl">&quot;</span></span> <span class="r">do</span>
+    it <span class="s"><span class="dl">&quot;</span><span class="k">should alias instance methods</span><span class="dl">&quot;</span></span> <span class="r">do</span>
+      h.blap.should == h.blip
+      h.blup.should == h.blip
+    <span class="r">end</span>
+
+    it <span class="s"><span class="dl">&quot;</span><span class="k">should alias class methods</span><span class="dl">&quot;</span></span> <span class="r">do</span>
+      <span class="co">Blip</span>.self_blap.should == <span class="co">Blip</span>.self_blip
+      <span class="co">Blip</span>.self_blup.should == <span class="co">Blip</span>.self_blip
+    <span class="r">end</span>
+  <span class="r">end</span>
+
+  context <span class="s"><span class="dl">&quot;</span><span class="k">class context</span><span class="dl">&quot;</span></span> <span class="r">do</span>
+    it <span class="s"><span class="dl">&quot;</span><span class="k">should alias instance methods</span><span class="dl">&quot;</span></span> <span class="r">do</span>
+      h.hi.should == h.hello
+      h.howdy.should == h.hello
+    <span class="r">end</span>
+
+    it <span class="s"><span class="dl">&quot;</span><span class="k">should alias class methods</span><span class="dl">&quot;</span></span> <span class="r">do</span>
+      <span class="co">Hello</span>.self_hi.should == <span class="co">Hello</span>.self_hello
+      <span class="co">Hello</span>.self_howdy.should == <span class="co">Hello</span>.self_hello
+    <span class="r">end</span>
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_alias_for_source">(<a href="javascript:show('alias_for_source')">show</a>)</span>
+         <pre class="source" id="alias_for_source">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<span class="r">def</span> <span class="fu">alias_for</span>(m, *aliases)
+  aliases.each{ |a|
+    class_eval <span class="s"><span class="dl">&quot;</span><span class="k">alias </span><span class="il"><span class="idl">#{</span>a<span class="idl">}</span></span><span class="k"> </span><span class="il"><span class="idl">#{</span>m<span class="idl">}</span></span><span class="dl">&quot;</span></span>
+  }
+<span class="r">end</span>
+<span class="r">alias</span> <span class="fu">aliases_for</span> <span class="fu">alias_for</span>
+
+<span class="r">class</span> <span class="cl">Module</span>
+  <span class="r">def</span> <span class="fu">alias_method_for</span>(m, *alias_methods)
+    alias_methods.each{ |a|
+      class_eval <span class="r">do</span>
+        alias_method a.to_sym, m.to_sym
+      <span class="r">end</span>
+    }
+  <span class="r">end</span>
+  <span class="r">alias</span> <span class="fu">alias_methods_for</span> <span class="fu">alias_method_for</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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/alias_for">github wiki</a></td></tr></table> <h3 title="require 'zucker/aliases'" id="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>File.filename</h5><pre class="usage source" style="display:block"><span class="co">File</span>.basename</pre><h5>Dir.join</h5><pre class="usage source" style="display:block"><span class="co">File</span>.join</pre><h5>Dir.split</h5><pre class="usage source" style="display:block"><span class="co">File</span>.split</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">zucker/aliases</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">(aliases)</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should create these aliases</span><span class="dl">'</span></span> <span class="r">do</span>
+    <span class="c"># see aliases.rb for aliase list</span>
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should define these constants</span><span class="dl">'</span></span> <span class="r">do</span>
+    <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">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<span class="r">class</span> <span class="cl">Object</span>
+  <span class="r">alias</span> <span class="fu">is_an?</span> <span class="fu">is_a?</span> <span class="c"># thanks to utility_belt</span>
+<span class="r">end</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">alias</span> <span class="fu">contains?</span> <span class="fu">include?</span>
+<span class="r">end</span>
+
+<span class="r">class</span> <span class="cl">String</span>
+  <span class="r">alias</span> <span class="fu">contains?</span> <span class="fu">include?</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="r">class</span> &lt;&lt; <span class="cl">File</span>
+  <span class="r">alias</span> <span class="fu">filename</span> <span class="fu">basename</span> <span class="c"># thanks rdp :)</span>
+<span class="r">end</span>
+
+<span class="r">class</span> &lt;&lt; <span class="cl">Dir</span>
+  <span class="r">def</span> <span class="fu">join</span>(*args)
+    <span class="co">File</span>.join(*args)
+  <span class="r">end</span>
+
+  <span class="r">def</span> <span class="fu">split</span>(*args)
+    <span class="co">File</span>.split(*args)
+  <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 or Float::INFINITY</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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/aliases">github wiki</a></td></tr></table> <h3 title="require 'zucker/ivars'" id="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 variables, 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">zucker/ivars</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">instance_variables_from</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should tansform the given parameter to instance variables</span><span class="dl">'</span></span> <span class="r">do</span>
+    <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">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<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(<span class="s"><span class="dl">&quot;</span><span class="il"><span class="idl">#{</span>e<span class="idl">}</span></span><span class="dl">&quot;</span></span>), e] }
+  <span class="r">elsif</span> obj.is_a? <span class="co">Hash</span>
+    obj.map{|k,v| [v,k] }
+  <span class="r">else</span>
+<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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/ivars">github wiki</a></td></tr></table> <h3 title="require 'zucker/square_brackets_for'" id="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">zucker/square_brackets_for</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">square_brackets_for</span><span class="dl">'</span></span> <span class="r">do</span>
+
+  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">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<span class="r">class</span> <span class="cl">Module</span>
+  <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>
+
+    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="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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/square_brackets_for">github wiki</a></td></tr></table>
+        </div> 
+      <h2 title="require 'zucker/debug'" id="debug">Cubes[debug]</h2>
+        <p class="text">(not included by <code>require 'zucker/default'</code>)</p>
+        <div class="cubes">
+         <h3 title="require 'zucker/binding'" id="binding">binding</h3>
+         <table class="cube_table"
+                id="binding_cube"
+                title="require 'zucker/binding'"> <tr><th>Summary</th>    <td>Adds a <code>Binding#vars</code>. It gives you information about the current environment variables.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Binding#variables, Binding#vars</h5><pre class="usage source" style="display:block"><span class="c"># shows your current environment's variables, irb example:</span>
+&gt;&gt; a=<span class="i">3</span>
+=&gt; <span class="i">3</span>
+&gt;&gt; binding.vars
+=&gt; <span class="c">#&lt;Binding:0x94c4b50&gt;</span>
+local variables
+ - <span class="ke">a</span>: <span class="i">3</span>
+ - <span class="ke">_</span>: <span class="c">#&lt;Binding:0x94c4b50&gt;</span>
+(instance variables)
+ - none
+<span class="pc">self</span>
+ - main
+block_given?
+ - <span class="pc">false</span>
+</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_binding_spec">(<a href="javascript:show('binding_spec')">show</a>)</span>
+         <pre class="source" id="binding_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/binding</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Binding#variables</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should output information about the current environment</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_binding_source">(<a href="javascript:show('binding_source')">show</a>)</span>
+         <pre class="source" id="binding_source">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<span class="r">class</span> <span class="cl">Binding</span>
+  <span class="r">def</span> <span class="fu">variables</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|
+          val = (<span class="pc">self</span>.eval <span class="s"><span class="dl">&quot;</span><span class="il"><span class="idl">#{</span>e<span class="idl">}</span></span><span class="dl">&quot;</span></span>).inspect
+          <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> val <span class="idl">}</span></span><span class="dl">&quot;</span></span>
+        }.join <span class="s"><span class="dl">&quot;</span><span class="ch">\n</span><span class="dl">&quot;</span></span>
+      <span class="r">end</span>
+    }
+
+    puts <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 variables
+</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 variables)
+</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">alias</span> <span class="fu">vars</span> <span class="fu">variables</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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/binding">github wiki</a></td></tr></table> <h3 title="require 'zucker/cc'" id="cc">cc</h3>
+         <table class="cube_table"
+                id="cc_cube"
+                title="require 'zucker/cc'"> <tr><th>Summary</th>    <td><code>c</code> outputs the current method callstack.</td></tr><tr><th>Methods/Usage</th>    <td><h5>c, cc</h5><pre class="usage source" style="display:block">c <span class="c"># shows the method callstack</span>
+c <span class="pc">true</span> <span class="c"># do not hide irb/ripl callstack</span>
+</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_cc_spec">(<a href="javascript:show('cc_spec')">show</a>)</span>
+         <pre class="source" id="cc_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/cc</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">c</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 method callstack</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_cc_source">(<a href="javascript:show('cc_source')">show</a>)</span>
+         <pre class="source" id="cc_source">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<span class="r">module</span> <span class="cl">Kernel</span>
+  private
+
+  <span class="r">def</span> <span class="fu">c</span>(show_irb = <span class="pc">false</span>)
+    method_stack = caller.reverse.map{ |m|
+      m.rindex( <span class="rx"><span class="dl">/</span><span class="k">:</span><span class="ch">\d</span><span class="k">+(:in `(.*)')?$</span><span class="dl">/</span></span> )
+      <span class="gv">$2</span>
+    }.compact
+    
+    <span class="r">if</span> !show_irb
+      <span class="r">if</span> a = method_stack.index( <span class="s"><span class="dl">'</span><span class="k">irb_binding</span><span class="dl">'</span></span> )
+        method_stack = [ method_stack[<span class="i">0</span>], <span class="s"><span class="dl">'</span><span class="k">(irb)</span><span class="dl">'</span></span>, *method_stack[a+<span class="i">1</span>..<span class="i">-1</span>] ]
+      <span class="r">elsif</span> a = method_stack[<span class="i">1</span>..<span class="i">-1</span>].index( <span class="s"><span class="dl">'</span><span class="k">&lt;main&gt;</span><span class="dl">'</span></span> )
+        method_stack = [ method_stack[<span class="i">0</span>], <span class="s"><span class="dl">'</span><span class="k">(ripl)</span><span class="dl">'</span></span>, *method_stack[a+<span class="i">2</span>..<span class="i">-1</span>] ]
+      <span class="r">end</span>
+    <span class="r">end</span>
+
+    <span class="c"># puts method_stack.map.with_index{ |m, i|</span>
+    method_stack.each_with_index{ |m, i|
+      puts <span class="s"><span class="dl">&quot;</span><span class="k">  </span><span class="dl">&quot;</span></span>*i + m
+    }
+    <span class="pc">nil</span>
+  <span class="r">end</span>
+
+  <span class="r">alias</span> <span class="fu">cc</span> <span class="fu">c</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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/cc">github wiki</a></td></tr></table> <h3 title="require 'zucker/dd'" id="dd">dd</h3>
+         <table class="cube_table"
+                id="dd_cube"
+                title="require 'zucker/dd'"> <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, Object#dd</h5><pre class="usage source" style="display:block">some.d.methods.d.noone.d.knows.d
+<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>).d
+<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.d{|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>Information</th>    <td>This is inspired by the <a href="http://moonbase.rydia.net/mental/blog/programming/eavesdropping-on-expressions"><code>.tap</code> method</a>.<br/>There is also <code>tap</code> cube with more <code>tap</code> methods.</td></tr><tr><th>Specification</th>    <td> <span id="show_dd_spec">(<a href="javascript:show('dd_spec')">show</a>)</span>
+         <pre class="source" id="dd_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/dd</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">&quot;</span><span class="k">should not change the object's value</span><span class="dl">&quot;</span></span> <span class="r">do</span>
+    capture_stdout <span class="r">do</span>
+      a.each{ |e|
+        (e.d).should == e
+      }
+
+      a.each{ |e|
+        (e.d{|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>
+
+  it <span class="s"><span class="dl">&quot;</span><span class="k">should puts .inspect if no block is given (and not change the object's value)</span><span class="dl">&quot;</span></span> <span class="r">do</span>
+    capture_stdout <span class="r">do</span>
+      a[<span class="i">0</span>].d
+      a[<span class="i">1</span>].d
+      a[<span class="i">6</span>].d
+    <span class="r">end</span>.should == <span class="s"><span class="dl">%{</span><span class="k">1</span><span class="ch">\n</span><span class="k">&quot;1&quot;</span><span class="ch">\n</span><span class="k">true</span><span class="ch">\n</span><span class="dl">}</span></span>
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">&quot;</span><span class="k">should puts the block if it is given (and not change the object's value)</span><span class="dl">&quot;</span></span> <span class="r">do</span>
+    capture_stdout <span class="r">do</span>
+      a[<span class="i">0</span>].d{|value| <span class="s"><span class="dl">&quot;</span><span class="k">This is a: </span><span class="il"><span class="idl">#{</span>value<span class="idl">}</span></span><span class="dl">&quot;</span></span>}
+      a[<span class="i">1</span>].d{|value| <span class="s"><span class="dl">&quot;</span><span class="k">This is a: </span><span class="il"><span class="idl">#{</span>value<span class="idl">}</span></span><span class="dl">&quot;</span></span>}
+      a[<span class="i">6</span>].d{|value| <span class="s"><span class="dl">&quot;</span><span class="k">This is a: </span><span class="il"><span class="idl">#{</span>value<span class="idl">}</span></span><span class="dl">&quot;</span></span>}
+    <span class="r">end</span>.should == <span class="s"><span class="dl">%{</span><span class="k">This is a: 1</span><span class="ch">\n</span><span class="k">This is a: 1</span><span class="ch">\n</span><span class="k">This is a: true</span><span class="ch">\n</span><span class="dl">}</span></span>
+  <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_dd_source">(<a href="javascript:show('dd_source')">show</a>)</span>
+         <pre class="source" id="dd_source">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<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">alias</span> <span class="fu">dd</span> <span class="fu">d</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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/dd">github wiki</a></td></tr></table> <h3 title="require 'zucker/mm'" id="mm">mm</h3>
+         <table class="cube_table"
+                id="mm_cube"
+                title="require 'zucker/mm'"> <tr><th>Summary</th>    <td><code>m</code> displays an ordered public method list.</td></tr><tr><th>Why?</th>    <td>See one object's methods without those rarely used inherited methods.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Object#m, Object#mm, Object#method_list</h5><pre class="usage source" style="display:block">&gt;&gt; <span class="i">5</span>.mm <span class="i">2</span> <span class="c"># outputs the list (2 levels deep), for example:</span>
+<span class="c"># = Fixnum</span>
+<span class="c"># to_s  -@  +  -  *  /  div  %  modulo  divmod  fdiv  **  abs  magnitude  ==  ===  &lt;=&gt;  &gt;  &gt;=  &lt;  &lt;=  ~  &amp;  |  ^  []  &lt;&lt;  &gt;&gt;  to_f  size  zero?  odd?  even?  succ</span>
+<span class="c"># = Integer</span>
+<span class="c"># integer?  odd?  even?  upto  downto  times  succ  next  pred  chr  ord  to_i  to_int  floor  ceil  truncate  round  gcd  lcm  gcdlcm  numerator  denominator  to_r  rationalize</span>
+</pre></td></tr><tr><th>Information</th>    <td>See <a href="http://rbjl.net/31-the-multi-mega-method-list">this article</a> for more information.</td></tr><tr><th>Specification</th>    <td> <span id="show_mm_spec">(<a href="javascript:show('mm_spec')">show</a>)</span>
+         <pre class="source" id="mm_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/mm</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Object#mm</span><span class="dl">'</span></span> <span class="r">do</span>
+  it <span class="s"><span class="dl">'</span><span class="k">should display an ordered method list</span><span class="dl">'</span></span> <span class="r">do</span>; <span class="r">end</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Source</th>    <td> <span id="show_mm_source">(<a href="javascript:show('mm_source')">show</a>)</span>
+         <pre class="source" id="mm_source">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<span class="r">module</span> <span class="cl">Kernel</span>
+  <span class="r">def</span> <span class="fu">m</span>(levels = <span class="i">1</span>)
+    <span class="c"># output helper</span>
+    mputs = proc{ |e| puts e.map(&amp;<span class="sy">:to_s</span>)*<span class="s"><span class="dl">'</span><span class="k">  </span><span class="dl">'</span></span> }
+
+    <span class="c"># how to get results</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>
+    <span class="r">end</span>
+
+    <span class="c"># eigenclass</span>
+    eigen = <span class="pc">self</span>.singleton_methods
+    <span class="r">if</span> !eigen.empty?
+      puts <span class="s"><span class="dl">'</span><span class="k">= Eigenclass</span><span class="dl">'</span></span> <span class="c"># sorry for not being up to date, I just love the word</span>
+      mputs[ <span class="pc">self</span>.singleton_methods ]
+    <span class="r">end</span>
+
+    <span class="c"># display</span>
+    levels.times{ |level|
+      <span class="r">if</span> cur = klass.ancestors[level]
+        puts <span class="s"><span class="dl">&quot;</span><span class="k">= </span><span class="il"><span class="idl">#{</span>cur<span class="idl">}</span></span><span class="dl">&quot;</span></span>  <span class="c"># put class name</span>
+        mputs[ 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">nil</span>
+  <span class="r">end</span>
+
+  <span class="r">alias</span> <span class="fu">mm</span>          <span class="fu">m</span>
+  <span class="r">alias</span> <span class="fu">method_list</span> <span class="fu">m</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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/mm">github wiki</a></td></tr></table> <h3 title="require 'zucker/oo'" id="oo">oo</h3>
+         <table class="cube_table"
+                id="oo_cube"
+                title="require 'zucker/oo'"> <tr><th>Summary</th>    <td>The <code>o</code> method outputs the current method, line, file and label (if given).</td></tr><tr><th>Methods/Usage</th>    <td><h5>o, oo</h5><pre class="usage source" style="display:block">o <span class="c"># e.g: Reached method `irb_binding', line 1 of file (irb)</span>
+o<span class="sy">:Label</span> <span class="c"># e.g: Label: reached method `abc', line 7 of file (irb)</span>
+</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_oo_spec">(<a href="javascript:show('oo_spec')">show</a>)</span>
+         <pre class="source" id="oo_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/oo</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">o</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 line, file, method and label (if given)</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_oo_source">(<a href="javascript:show('oo_source')">show</a>)</span>
+         <pre class="source" id="oo_source">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<span class="r">module</span> <span class="cl">Kernel</span>
+  private
+
+  <span class="r">def</span> <span class="fu">o</span>(desc = <span class="pc">nil</span>)
+    caller[<span class="i">0</span>].rindex( <span class="rx"><span class="dl">/</span><span class="k">:(</span><span class="ch">\d</span><span class="k">+)(:in (`.*'))?$</span><span class="dl">/</span></span> )
+    m = <span class="gv">$3</span> ? <span class="s"><span class="dl">&quot;</span><span class="k">method </span><span class="dl">#</span><span class="gv">$3</span><span class="k">, </span><span class="dl">&quot;</span></span> : <span class="s"><span class="dl">&quot;</span><span class="dl">&quot;</span></span>
+    d = desc ? <span class="s"><span class="dl">&quot;</span><span class="il"><span class="idl">#{</span>desc<span class="idl">}</span></span><span class="k">: r</span><span class="dl">&quot;</span></span> : <span class="s"><span class="dl">'</span><span class="k">R</span><span class="dl">'</span></span>
+
+    puts <span class="s"><span class="dl">&quot;</span><span class="il"><span class="idl">#{</span>d<span class="idl">}</span></span><span class="k">eached </span><span class="il"><span class="idl">#{</span>m<span class="idl">}</span></span><span class="k">line </span><span class="dl">#</span><span class="gv">$1</span><span class="k"> of file </span><span class="dl">#</span><span class="gv">$`</span><span class="dl">&quot;</span></span>
+    <span class="c"># [$`, $1.to_i, $3.to_sym,  desc]</span>
+  <span class="r">end</span> 
+  <span class="r">alias</span> <span class="fu">oo</span> <span class="fu">o</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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/oo">github wiki</a></td></tr></table> <h3 title="require 'zucker/qq'" id="qq">qq</h3>
+         <table class="cube_table"
+                id="qq_cube"
+                title="require 'zucker/qq'"> <tr><th>Summary</th>    <td>The <code>q</code> method does the same like <code>p</code>, but puts out multiple arguments on the same line.</td></tr><tr><th>Methods/Usage</th>    <td><h5>q, qq</h5><pre class="usage source" style="display:block">q <span class="s"><span class="dl">&quot;</span><span class="k">zucker</span><span class="dl">&quot;</span></span>, <span class="s"><span class="dl">'</span><span class="dl">'</span></span>, {<span class="i">6</span>=&gt;<span class="i">7</span>}, <span class="i">5</span>, <span class="fl">2.3</span>, <span class="sy">:o</span> <span class="c"># outputs &quot;zucker&quot;  &quot;&quot;  {6=&gt;7}  5  2.3  :o</span>
+</pre></td></tr><tr><th>Information</th>    <td>Inspired by <a href="http://github.com/rdp/sane/blob/master/lib/sane/pps.rb">rdp</a>.</td></tr><tr><th>Specification</th>    <td> <span id="show_qq_spec">(<a href="javascript:show('qq_spec')">show</a>)</span>
+         <pre class="source" id="qq_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/qq</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">q</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 same as p for a single arg</span><span class="dl">'</span></span> <span class="r">do</span>
+    capture_stdout{p <span class="rx"><span class="dl">/</span><span class="k">some object</span><span class="dl">/</span></span>}.should ==
+    capture_stdout{q <span class="rx"><span class="dl">/</span><span class="k">some object</span><span class="dl">/</span></span>}
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">&quot;</span><span class="k">should output the same as p but for multiple args one one line, values separated by two spaces</span><span class="dl">&quot;</span></span> <span class="r">do</span>
+    capture_stdout <span class="r">do</span>
+      q <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>.chop.should ==
+    capture_stdout <span class="r">do</span>
+      p <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>.chop.gsub( <span class="s"><span class="dl">&quot;</span><span class="ch">\n</span><span class="dl">&quot;</span></span>, <span class="s"><span class="dl">'</span><span class="k">  </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_qq_source">(<a href="javascript:show('qq_source')">show</a>)</span>
+         <pre class="source" id="qq_source">require <span class="s"><span class="dl">'</span><span class="k">zucker</span><span class="dl">'</span></span>
+
+<span class="r">module</span> <span class="cl">Kernel</span>
+  private
+
+  <span class="r">def</span> <span class="fu">q</span>(*args)
+    puts args.map( &amp;<span class="sy">:inspect</span> )*<span class="s"><span class="dl">'</span><span class="k">  </span><span class="dl">'</span></span> <span class="r">unless</span> args.empty?
+  <span class="r">end</span>
+  <span class="r">alias</span> <span class="fu">qq</span> <span class="fu">q</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><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/qq">github wiki</a></td></tr></table> <h3 title="require 'zucker/regexp_visualize'" id="regexp_visualize">regexp_visualize</h3>
+         <table class="cube_table"
+                id="regexp_visualize_cube"
+                title="require 'zucker/regexp_visualize'"> <tr><th>Summary</th>    <td>Test your regex against a string, handy for the command line.</td></tr><tr><th>Methods/Usage</th>    <td><h5>Regexp#visualize, Regexp#vis</h5><pre class="usage source" style="display:block"><span class="c"># regex = /\b([A-Z0-9._%+-]+)@([A-Z0-9.-]+\.[A-Z]{2,4})\b/i</span>
+regex.vis <span class="s"><span class="dl">'</span><span class="k">I do not contain an email address.</span><span class="dl">'</span></span>
+<span class="c"># no match</span>
+regex.vis <span class="s"><span class="dl">'</span><span class="k">I contain an email address: mail@example.com</span><span class="dl">'</span></span>
+<span class="c"># I contain an email address:  &gt;mail@example.com&lt; </span>
+regex.vis <span class="s"><span class="dl">'</span><span class="k">mail@example.com</span><span class="dl">'</span></span>, <span class="i">1</span>
+<span class="c"># 1:  &gt;mail&lt; @example.com</span>
+regex.vis <span class="s"><span class="dl">'</span><span class="k">mail@example.com</span><span class="dl">'</span></span>, <span class="i">2</span>
+<span class="c"># 2: mail@ &gt;example.com&lt; </span>
+regex.vis <span class="s"><span class="dl">'</span><span class="k">mail@example.com</span><span class="dl">'</span></span>, <span class="i">3</span>
+<span class="c"># 3: no match</span>
+regex.vis <span class="s"><span class="dl">'</span><span class="k">mail@example.com</span><span class="dl">'</span></span>, [<span class="i">0</span>,<span class="i">1</span>,<span class="i">2</span>]
+<span class="c"># 0:  &gt;mail@example.com&lt; </span>
+<span class="c"># 1:  &gt;mail&lt; @example.com</span>
+<span class="c"># 2: mail@ &gt;example.com&lt; </span>
+</pre></td></tr><tr><th>Specification</th>    <td> <span id="show_regexp_visualize_spec">(<a href="javascript:show('regexp_visualize_spec')">show</a>)</span>
+         <pre class="source" id="regexp_visualize_spec">require <span class="s"><span class="dl">'</span><span class="k">zucker/regexp_visualize</span><span class="dl">'</span></span>
+
+describe <span class="s"><span class="dl">'</span><span class="k">Regexp#visualize</span><span class="dl">'</span></span> <span class="r">do</span>
+  let <span class="sy">:regex</span> <span class="r">do</span> <span class="rx"><span class="dl">/</span><span class="ch">\b</span><span class="k">([A-Z0-9._%+-]+)@([A-Z0-9.-]+</span><span class="ch">\.</span><span class="k">[A-Z]{2,4})</span><span class="ch">\b</span><span class="dl">/</span><span class="mod">i</span></span> <span class="r">end</span> <span class="c"># regex from regular-expressions.info/email.html</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should display a string where &gt;and&lt; mark the found regex</span><span class="dl">'</span></span> <span class="r">do</span>
+    capture_stdout <span class="r">do</span>
+      regex.vis <span class="s"><span class="dl">'</span><span class="k">I do not contain an email address.</span><span class="dl">'</span></span>
+    <span class="r">end</span>.chomp.should == <span class="s"><span class="dl">'</span><span class="k">no match</span><span class="dl">'</span></span>
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should display &quot;no match&quot; if the regex could not be matched</span><span class="dl">'</span></span> <span class="r">do</span>
+    capture_stdout <span class="r">do</span>
+      regex.vis <span class="s"><span class="dl">'</span><span class="k">I contain an email address: mail@example.com</span><span class="dl">'</span></span>
+    <span class="r">end</span>.chomp.should == <span class="s"><span class="dl">'</span><span class="k">I contain an email address:  &gt;mail@example.com&lt; </span><span class="dl">'</span></span>
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should display a string where &gt;and&lt; mark the found regex group if group identifier is given as arg2</span><span class="dl">'</span></span> <span class="r">do</span>
+    capture_stdout <span class="r">do</span>
+      regex.vis <span class="s"><span class="dl">'</span><span class="k">mail@example.com</span><span class="dl">'</span></span>, <span class="i">1</span>
+    <span class="r">end</span>.chomp.should == <span class="s"><span class="dl">'</span><span class="k">1:  &gt;mail&lt; @example.com</span><span class="dl">'</span></span>
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should display &quot;group identifier: no match&quot; the arg2 group could not be matched</span><span class="dl">'</span></span> <span class="r">do</span>
+    capture_stdout <span class="r">do</span>
+      regex.vis <span class="s"><span class="dl">'</span><span class="k">mail@example.com</span><span class="dl">'</span></span>, <span class="i">3</span>
+    <span class="r">end</span>.chomp.should == <span class="s"><span class="dl">'</span><span class="k">3: no match</span><span class="dl">'</span></span>
+  <span class="r">end</span>
+
+  it <span class="s"><span class="dl">'</span><span class="k">should also take an array of group identfiers as arg2</span><span class="dl">'</span></span> <span class="r">do</span>
+    capture_stdout <span class="r">do</span>
+      regex.vis <span class="s"><span class="dl">'</span><span class="k">mail@example.com</span><span class="dl">'</span></span>, [<span class="i">0</span>,<span class="i">1</span>,<span class="i">2</span>]
+    <span class="r">end</span>.chomp.should == <span class="s"><span class="dl">&quot;</span><span class="k">0:  &gt;mail@example.com&lt; </span><span class="ch">\n</span><span class="dl">&quot;</span></span>\
+                        <span class="s"><span class="dl">&quot;</span><span class="k">1:  &gt;mail&lt; @example.com</span><span class="ch">\n</span><span class="dl">&quot;</span></span>\
+                        <span class="s"><span class="dl">&quot;</span><span class="k">2: mail@ &gt;example.com&lt; </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_regexp_visualize_source">(<a href="javascript:show('regexp_visualize_source')">show</a>)</span>
+         <pre class="source" id="regexp_visualize_source"><span class="r">class</span> <span class="cl">Regexp</span>
+  <span class="r">def</span> <span class="fu">visualize</span>(string, groups = <span class="pc">nil</span>)
+    <span class="r">if</span> <span class="pc">self</span> =~ string
+      <span class="r">if</span> !groups
+        puts <span class="gv">$`</span> + <span class="s"><span class="dl">'</span><span class="k"> &gt;</span><span class="dl">'</span></span> + <span class="gv">$&amp;</span> + <span class="s"><span class="dl">'</span><span class="k">&lt; </span><span class="dl">'</span></span> + <span class="gv">$'</span>
+      <span class="r">else</span>
+        Array( groups ).each{ |group|
+          <span class="r">begin</span>
+            gr_string = string.dup
+            gr_string[ <span class="gv">$~</span>.end( group ),   <span class="i">0</span> ] = <span class="s"><span class="dl">'</span><span class="k">&lt; </span><span class="dl">'</span></span>
+            gr_string[ <span class="gv">$~</span>.begin( group ), <span class="i">0</span> ] = <span class="s"><span class="dl">'</span><span class="k"> &gt;</span><span class="dl">'</span></span>
+            puts group.to_s + <span class="s"><span class="dl">'</span><span class="k">: </span><span class="dl">'</span></span> + gr_string
+          <span class="r">rescue</span> <span class="co">IndexError</span>
+            puts group.to_s + <span class="s"><span class="dl">'</span><span class="k">: no match</span><span class="dl">'</span></span>
+          <span class="r">end</span>
+        }
+      <span class="r">end</span>
+    <span class="r">else</span>
+      puts <span class="s"><span class="dl">'</span><span class="k">no match</span><span class="dl">'</span></span>
+    <span class="r">end</span>
+
+    <span class="pc">nil</span>
+  <span class="r">end</span>
+
+  <span class="r">alias</span> <span class="fu">vis</span> <span class="fu">visualize</span>
+<span class="r">end</span></pre> </td></tr><tr><th>Compatibility</th>    <td>1.9, 1.8</td></tr><tr><th>Discussion</th>    <td><a href="http://wiki.github.com/janlelis/zucker/regexp_visualize">github wiki</a></td></tr></table>
+        </div> 
+      <h2>Extras</h2>
+      <p class="text">
+        You can activate some additional aliases for Zucker functionality by executing:
+        <code class="scode">Zucker.more_aliases! # => [:copy, :n, :init, :returning, :lib?, :RV, :RE]</code>
+      </p>
+
+      <h2>Changelog</h2>
+      <div class="cubes">
+        <pre class="scode">2011-01-22 | <a href="http://rubyzucker.info/9/">Zucker 9</a>
+* removed history versions (sorry, it caused too much gem/rdoc troubles)
+* add file cube: File.delete! and File.gsub
+* debug pack improvements
+  * binding: typos + return nil
+  * cc: support for ripl + return nil
+  * mm: also show eigenclass for modules + nicer displaying + return nil
+  * added Regexp#visualize
+* removed optional sandbox param
+* renamed xxx2proc to xxx_to_proc
+* changed rakefile/rspec/gemspec structure
+* more minor fixes and improvements
+
+
+2010-10-06 | <a href="http://rubyzucker.info/8/">Zucker 8</a>
+* fixed a little alias_for bug
+* disabled rdoc creation when installing (in favour of the custom docs)
+* changed Binding#inspect to Binding.variables (was too verbose and dangerous)
+
+
+2010-10-03 | <a href="http://rubyzucker.info/7/">Zucker 7</a>
+* fixed critical OS.windows? bug
+
+
+2010-10-03 | <a href="http://rubyzucker.info/6/">Zucker 6</a>
+* no new cubes
+* bugfix for OS.posix?
+* small changes + bugfixes + doc improvements
+* added two user methods to Info
+* changed egonil semantics ( using method_missing, see http://rbjl.net/26/catch_nil.rb )
+* bugfix for vv
+
+
+2010-09-04 | <a href="http://rubyzucker.info/5/">Zucker 5</a>
+* debug edition -  added two debug helpers: oo (output line, method, file) and cc (output method callstack)
+* renamed cube D to dd add added more debug aliases (for mm and binding)
+* fixed __SPECIAL_VARS__ in info and kernel cube and some minor bugfixes
+* Zucker.activate_more_aliases! option
+* added Hash#&amp;
+* added aliases: File.filename (for basename), Dir.join and Dir.split (for File.join, split)
+* added a flexible requiring mechansim in zucker.rb (no api changes)
+* restructered packages
+* added rake tasks for releasing
+* improved RubyVersion constant (cleaner and more flexible)
+
+
+2010-09-01 | <a href="http://rubyzucker.info/4/">Zucker 4</a>
+* fixed Binding#inspect
+* added RubyEngine constant
+* added RubyVersion constant
+* added OS constant
+* added q debug method (like p but on one line)
+* added String#-
+
+
+2010-08-14 | <a href="http://rubyzucker.info/3/">Zucker 3</a>
+* added tap cube
+* added Object#not
+* added alias_for for an alternative alias syntax
+* added String#constantize (improved AS version)
+* improved Info module
+* made Array#sum Rails compatibile
+* improved docs
+* changed directory layout (no changes for requiring)
+* more small changes
+
+
+2010-08-08 | <a href="http://rubyzucker.info/2/">Zucker 2</a>
+* added info cube
+* added chaining for array2proc
+* fixed Hash.zip
+* fixed instance_variables_from binding for 1.9
+* more specs
+
+
+2010-08-06 | <a href="http://rubyzucker.info/1/">Zucker 1</a>
+* initial release
+
+
+2010-08-05 | <a href="http://rubyzucker.info/rubyzucker.pdf">Zucker 0</a>
+* pre-release for rug-b talk
+
+</pre>
+      </div>
+<br/>
+    </div>
+  <div id="foot">
+    <div id="smile"><a href="http://rbjl.net">J-_-L</a></div>
+    This is the Ruby Zucker 9 documentation (2011-01-22).
+    The current version is always available at <a href="http://rubyzucker.info">rubyzucker.info</a>.
+    Source at <a href="http://github.com/janlelis/zucker">github</a>.
+    Ruby Logo CC-BY-SA Yukihiro Matsumoto.
+  </div>
+
+</body>
+</html>
+