facets 2.3.0 → 2.4.0

data/NOTES

@@ -1,29 +1,60 @@
-Facets 2.3.0 has been released.
+= Release Notes
 
-Facets 2.3 makes some nice internal reorganization, rather
-then just the split between core/ and more/, we have added
-class/ and mixin/. This helps a great deal in working
-with the library. If does not effect the end-user in anyway
-however --even so we felt it enough to warrent a minor
-version bump rather than just a tiny.
+Facets 2.4 is a major step forward for Facets. It is perhaps
+the release that 2.0 should have been, but of course it took
+the actual 2.0 release to make 2.4 possible. Some annoyances
+you may have encountered in updating your code to 2.0 are now
+fixed. And from 2.4 on, Facets will now be settling down into
+simple refinement release cycles.
+
+The main change under the hood is to bring everything up to
+the top lib/facets/ directory. No longer are the libraries
+sorted by category. I had done so for a long time to make
+it easier to track the various libs, but in the end it was
+only making it more diffcult to deal with build tools and 
+packaging.
+
+For the end-user, the largest change is a new emphisis on:
+
+  require 'facets'
+
+This is better than cherry-picking methods. It may seem counter-
+intuitive, but it actually proves more advantantages to do this
+for the sake of interoperability than the practice of cherry-picking.
+The reason is simply because others may have cherry-picked different
+methods, and those distinctions go unaccounted and untested.
+
+Also with this release, to bolster the use of require 'facets',
+some lack-luster extensions have been deprecated and namespace usage
+has been improved. In addition, we are getting very close to full
+ActiveSupport, and Ruby 1.9, interoperability. Expect this
+to be complete in the next minor release or two.
+
+This is still a bit of an early release. There remain a few 
+libraries to adjust for the new design considerations, but I
+wanted to get this new design out as soon as possible so others
+could adjust their code sooner rather than later. I'll be catching
+up on the CHANGES list over the next few minor release.
+
+== As of 2.3
 
 Amoung other changes with this release, cloneable.rb is
 now a true deep dup/clone mixin; tracepoint.rb returns
-to the library; and ...
+to the library.
 
-As of 2.2.1:
+== As of 2.2.1:
 
 This release get rid of the underlying methods subdir.
 All method redirects are now in core, to ensure
 there are no more name clashes.
 
-As of 2.2.0:
+== As of 2.2.0:
 
 This release provides improved rdocs and prepares facets for
 use with RUby 1.9. It also adds Matthew Harris' duration.rb
 library. Bug thanks to Matthew!
 
-As of 2.1.0: 
+== As of 2.1.0: 
 
 Major changes include a new and much-improved command.rb,
 a new BiCrypt class for simple two-way crypotgraphy,

data/README

@@ -16,7 +16,19 @@ The "more" additions are a collection of classes, modules and light meta-systems
 
 == Documentation
 
-Note that Facets has special documentation needs due to it's extensive bredth. For this reason, rdocs are not automatically built by RubyGems on install. To find documentation, please see http://facets.rubyforge.org/learn.html. If you need off-line docs, there is a separate package available on the Files page of the Facets RubyForge project site.
+Facets has special documentation needs due to it's extensive bredth. For this reason, RDocs are not automatically generated when installing via RubyGems. Unfortunatgely this also prevents RI docs from being created. Hopefully we can remedy this in the future. In the mean time you can manually create them by navigating to the package directory (either the gem or tgz) and running 'rdoc --ri-site' (recommended destination).
+
+Online documentaiton is available at http://facets.rubyforge.org/learn.html. There is a "Quick Doc" feature that can be a bit more convenient then the usual RDocs. Prior to 2.3.1 off-line docs had to be downloaded via a separate package, but this is no longer the case. I've seen past the stigma of not including documentation along with the package itself (the extra 500K isn't even a floppy disk folks!), so you will find them in the doc/ directory of whatever package you have choosen to install. In fact, a good package installer should give you the option to install those in the appropriate place in your system (eg. in /usr/share/doc/facets/).
+
+
+== RELEASE NOTES
+
+Please see NOTES file.
+
+
+== Changes
+
+Please see CHANGES file.
 
 
 == Installation
@@ -66,11 +78,6 @@ Facets holds to the notion that the more we can reasonably integrate into a comm
     * One-stop Shop and Installation
 
 
-== Status
-
-The current status of Facets is very good. While some libs could still use some "finishing" work, all are highly API stable and functional.
-
-
 == Usage
 
 For detailed usage of any given method or module please refer to the API RDocs.
@@ -110,18 +117,6 @@ Using a Facets/MORE library of modules, classes or microframeworks is essentiall
 Again, for details pertaining to the functionality of each feature, please see the API Docs.
 
 
-# PLEASE IGNORE THIS FOR NOW
-
-It is possible to eliminate the need for the 'facets/' prefix on requires if the Facets libpaths are added to the LOAD_PATH. But this isn't as straight-forward as it is for most libraries b/c of the layout of Facets library.
-
-  require 'facets-topload'
-  require 'basicobject'
-
-Understand that on the off chance that another library has the same name as one of Facets' everything will still work fine. You will just not be able to use the prefixless shortcut to require it.
-
-# END IGNORE.
-
-
 == Method File Names
 
 Operator method redirect files are stored using English names. For instance for Proc#* is 'proc/op_mul'.
@@ -192,17 +187,12 @@ The Ruby license is a dual license that also provides for use of the GPL. Comple
 Acknowledgments and Copyrights for particular snippets of borrowed code are given in their respective source. All licenses are either compatible with the Ruby license (namely the GPL) or the original author has given permission for inclusion of their code under such license.
 
 
-== Pitch
-
-  ALL YOUR BASE ARE BELONG TO RUBY!
 
+ALL YOUR BASE ARE BELONG TO RUBY!
 
-----
 
-[1] A lot of mental anguish went into finding this good project name Ruby Facets. Of course, in the end only one name can take the honor. Other good names which were considered: Calibre, Florida and California, Warchest w/ Atomix, Downs & Ace, Trix & Atomx and even Pillbox & Pills (a _why suggestion). Then the names that almost won out and were used for a good while: Nano Methods and Mega Modules --great names but a little too "fad". Finally let's not forget even older "working" titles that were used along the way: Raspberry, ABC, Succ and the very original Tomslib.
+Ruby Facets, Copyright (c)2005,2006,2007,2008 Thomas Sawyer
 
-----
+Do you Ruby? (http://ruby-lang.org)
 
-Copyright (c)2007 Thomas Sawyer
 
-Do you Ruby? (http://ruby-lang.org)

data/doc/History.txt

@@ -0,0 +1,73 @@
+= Facets History
+
+This is a record of some musings along the way in the creatiojn of Facets.
+It is not in any way all that important. Its' simply here to give some historical
+context to development and to provide and cues for recollection.
+
+== On the Name "Ruby Facets"
+
+A lot of mental anguish went into finding this good project name Ruby Facets. Of course, in the end only one name can take the honor. Other good names which were considered: Calibre, Florida and California, Warchest w/ Atomix, Downs & Ace, Trix & Atomx and even Pillbox & Pills (a _why suggestion). Then the names that almost won out and were used for a good while: Nano Methods and Mega Modules --great names but a little too "fad". Finally let's not forget even older "working" titles that were used along the way: Raspberry, ABC, Succ and the very original Tomslib.
+
+== Feature that May Return
+
+[EXTACTED FROM README]
+
+It is possible to eliminate the need for the 'facets/' prefix on requires if the Facets libpaths are added to the LOAD_PATH. But this isn't as straight-forward as it is for most libraries b/c of the layout of Facets library.
+
+  require 'facets-topload'
+  require 'basicobject'
+
+Understand that on the off chance that another library has the same name as one of Facets' everything will still work fine. You will just not be able to use the prefixless shortcut to require it.
+
+== Some convesion extemnsions that turned out to be bad.
+
+  class Symbol
+
+    # Same functionality as before, just a touch more efficient.
+    #
+    #--
+    # CHANGE transami@gmail.com - removed #freeze from #id2name
+    # BAD BAD. Somehow it breaks things. Very weired breaks too,
+    # like making Time#parse alwsy output Time.now _after_ first use.
+    #++
+
+    def to_s
+      @to_s || (@to_s = id2name)
+    end
+
+    # Symbol's really are just simplified strings.
+    # Thus #to_str seems quite reasonable.
+    # This uses the Kernal#String method.
+    #--
+    # Maybe just change to #to_s?
+    # BTW: This would be lots faster, I bet, if implemented in core.
+    #
+    # NOTE This causes Struct.new to bomb!
+    #++
+
+    def to_str
+      String( self )
+    end
+
+  end
+
+== String#to_a extension is too dangerous
+
+  class String
+
+    # Essentially makes #to_a an alias for split,
+    # with the excpetion that if no divider is given
+    # then the array is split on charaters, and
+    # NOT on the global input record divider ($/).
+    #
+    # WARNING There is a slight chance of
+    # incompatability with other libraries which
+    # depend on spliting with $/ (although doing
+    # so is a very bad idea!).
+
+    #def to_a(div=//,limit=0)
+    #  split(div,limit)
+    #end
+
+  end
+

data/doc/html/api.css

@@ -0,0 +1,79 @@
+body {
+  margin: 0;
+  padding: 0;
+  background: url(img/fade_red_down.png) repeat-x;
+}
+
+h1 {
+  font-size: 54px;
+  font-variant: small-caps;
+  background: transparent;
+  color: white;
+  margin: 0px 0px;
+  padding: 12px 15px 40px 0px;
+}
+
+h2 {
+  font-size: 24px;
+  /* font-variant: small-caps; */
+  margin: 40px 10px 10px -3px;
+  /* padding-left: 36px;
+  background: url(img/ruby.gif) -1px 0px no-repeat; */
+}
+
+p {
+  margin: 10px 0px;
+}
+
+ul {
+  margin: 0px 0px;
+  padding-left: 15px;
+}
+
+li {
+  list-style-type: disc;
+  list-style-image: url(’img/ruby.gif’);
+  text-indent: 5px;
+}
+
+img {
+  border: none;
+  margin: 2px;
+}
+
+pre {
+  background: black;
+  color: white;
+  font-family: monospace;
+  padding: 20px;
+}
+
+.content {
+  width: 84%;
+  margin: 0 auto;
+  border: 0px solid red;
+  padding-bottom: 30px;
+  background: transparent;
+  font-family: Micorsoft sans-serif, sans-serif;
+}
+
+.main {
+  background: url(img/ruby.png) -10px -60px no-repeat;
+}
+
+.nav {
+  position: absolute;
+  right: 10px;
+  top: 10px;
+  background: url(img/ruby.gif) no-repeat white;
+  color: red;
+  border: 2px solid red;
+  padding: 5px 5px 5px 36px;
+}
+
+.nav a {
+  color: red;
+  font-weight: bold;
+}
+
+

data/doc/html/api/core/classes/Array.html

@@ -0,0 +1,894 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html 
+     PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+  <head>
+    <title>Class: Array</title>
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+    <link rel="stylesheet" href=".././rdoc-style.css" type="text/css" media="screen" />
+
+    <script language="JavaScript" type="text/javascript">
+    // <![CDATA[
+
+        function toggleSource( id )
+        {
+          var elem
+          var link
+
+          if( document.getElementById )
+          {
+            elem = document.getElementById( id )
+            link = document.getElementById( "l_" + id )
+          }
+          else if ( document.all )
+          {
+            elem = eval( "document.all." + id )
+            link = eval( "document.all.l_" + id )
+          }
+          else
+            return false;
+
+          if( elem.style.display == "block" )
+          {
+            elem.style.display = "none"
+            link.innerHTML = "show source"
+          }
+          else
+          {
+            elem.style.display = "block"
+            link.innerHTML = "hide source"
+          }
+        }
+
+        function openCode( url )
+        {
+          window.open( url, "SOURCE_CODE", "resizable=yes,scrollbars=yes,toolbar=no,status=no,height=480,width=750" ).focus();
+        }
+      // ]]>
+    </script>
+  </head>
+
+  <body>
+  <table width="100%" border='0' cellpadding='0' cellspacing='0' class='banner'><tr>
+  <td class="file-title"><span class="file-title-prefix">Class</span><br />Array</td>
+  <td align="right">
+    <table cellspacing="0" cellpadding="2">
+      <tr valign="top">
+        <td>In:</td>
+        <td>
+<a href="../files/lib/facets/ruby_rb.html">lib/facets/ruby.rb</a>
+<a href="../files/lib/facets/blank_rb.html">lib/facets/blank.rb</a>
+<a href="../files/lib/facets/boolean_rb.html">lib/facets/boolean.rb</a>
+<a href="../files/lib/facets/to_hash_rb.html">lib/facets/to_hash.rb</a>
+<a href="../files/lib/facets/array/product_rb.html">lib/facets/array/product.rb</a>
+<a href="../files/lib/facets/array/not_empty_rb.html">lib/facets/array/not_empty.rb</a>
+<a href="../files/lib/facets/array/rotate_rb.html">lib/facets/array/rotate.rb</a>
+<a href="../files/lib/facets/array/conjoin_rb.html">lib/facets/array/conjoin.rb</a>
+<a href="../files/lib/facets/array/indexable_rb.html">lib/facets/array/indexable.rb</a>
+<a href="../files/lib/facets/array/merge_rb.html">lib/facets/array/merge.rb</a>
+<a href="../files/lib/facets/array/traverse_rb.html">lib/facets/array/traverse.rb</a>
+<a href="../files/lib/facets/array/select_rb.html">lib/facets/array/select.rb</a>
+<a href="../files/lib/facets/array/only_rb.html">lib/facets/array/only.rb</a>
+<a href="../files/lib/facets/array/delete_rb.html">lib/facets/array/delete.rb</a>
+<a href="../files/lib/facets/array/splice_rb.html">lib/facets/array/splice.rb</a>
+<a href="../files/lib/facets/array/stackable_rb.html">lib/facets/array/stackable.rb</a>
+<a href="../files/lib/facets/array/pad_rb.html">lib/facets/array/pad.rb</a>
+        </td>
+      </tr>
+    <tr>
+      <td>Parent:</td>
+      <td>
+        <a href="Object.html">
+Object
+         </a>
+     </td>
+   </tr>
+         </table>
+        </td>
+        </tr>
+      </table>
+ <!-- banner header -->
+
+  <div id="bodyContent">
+      <div id="content">
+
+
+
+
+  <div class="sectiontitle">Methods</div>
+  <ul>
+  <li><a href="#M000116">**</a></li>
+  <li><a href="#M000112">combination</a></li>
+  <li><a href="#M000120">conjoin</a></li>
+  <li><a href="#M000126">delete_unless</a></li>
+  <li><a href="#M000127">delete_values</a></li>
+  <li><a href="#M000128">delete_values_at</a></li>
+  <li><a href="#M000121">merge!</a></li>
+  <li><a href="#M000117">not_empty?</a></li>
+  <li><a href="#M000125">only</a></li>
+  <li><a href="#M000130">pad</a></li>
+  <li><a href="#M000131">pad!</a></li>
+  <li><a href="#M000113">permutation</a></li>
+  <li><a href="#M000111">product</a></li>
+  <li><a href="#M000118">rotate</a></li>
+  <li><a href="#M000119">rotate!</a></li>
+  <li><a href="#M000124">select!</a></li>
+  <li><a href="#M000129">splice</a></li>
+  <li><a href="#M000114">to_b</a></li>
+  <li><a href="#M000115">to_h</a></li>
+  <li><a href="#M000122">traverse</a></li>
+  <li><a href="#M000123">traverse!</a></li>
+  </ul>
+
+<div class="sectiontitle">Included Modules</div>
+<ul>
+  <li><a href="Indexable.html">Indexable</a></li>
+  <li><a href="Stackable.html">Stackable</a></li>
+</ul>
+
+
+
+
+
+<div class="sectiontitle">Public Instance methods</div>
+<div class="method">
+  <div class="title">
+    <a name="M000116"></a><b>**</b>(*enums, &amp;block)
+  </div>
+  <div class="description">
+  <p>
+Alias for <a href="Array.html#M000111">product</a>
+</p>
+  </div>
+</div>
+<div class="method">
+  <div class="title">
+    <a name="M000112"></a><b>combination</b>(k=2) {|s.values_at(*idx)| ...}
+  </div>
+  <div class="description">
+  <p>
+Yields the block to each unique <a
+href="Array.html#M000112">combination</a> of <em>n</em> elements.
+</p>
+<pre>
+  a = %w|a b c d|
+  a.combination(3)
+</pre>
+<p>
+produces
+</p>
+<pre>
+  [[&quot;a&quot;, &quot;b&quot;, &quot;c&quot;],
+   [&quot;a&quot;, &quot;b&quot;, &quot;d&quot;],
+   [&quot;a&quot;, &quot;c&quot;, &quot;d&quot;],
+   [&quot;b&quot;, &quot;c&quot;, &quot;d&quot;]]
+</pre>
+<p>
+CREDIT: Florian Gross
+</p>
+  </div>
+<div class="sourcecode">
+  <p class="source-link">[ <a href="javascript:toggleSource('M000112_source')" id="l_M000112_source">show source</a> ]</p>
+  <div id="M000112_source" class="dyn-source">
+<pre>
+<span class="ruby-comment cmt"># File lib/facets/ruby.rb, line 65</span>
+    <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">combination</span>(<span class="ruby-identifier">k</span>=<span class="ruby-value">2</span>)
+      <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">block_given?</span>
+        <span class="ruby-identifier">s</span> = <span class="ruby-identifier">to_a</span>
+        <span class="ruby-identifier">n</span> = <span class="ruby-identifier">s</span>.<span class="ruby-identifier">size</span>
+        <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">unless</span> (<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-identifier">n</span>) <span class="ruby-operator">===</span> <span class="ruby-identifier">k</span>
+        <span class="ruby-identifier">idx</span> = (<span class="ruby-value">0</span><span class="ruby-operator">...</span><span class="ruby-identifier">k</span>).<span class="ruby-identifier">to_a</span>
+        <span class="ruby-identifier">loop</span> <span class="ruby-keyword kw">do</span>
+          <span class="ruby-keyword kw">yield</span> <span class="ruby-identifier">s</span>.<span class="ruby-identifier">values_at</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">idx</span>)
+          <span class="ruby-identifier">i</span> = <span class="ruby-identifier">k</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>
+          <span class="ruby-identifier">i</span> <span class="ruby-operator">-=</span> <span class="ruby-value">1</span> <span class="ruby-keyword kw">while</span> <span class="ruby-identifier">idx</span>[<span class="ruby-identifier">i</span>] <span class="ruby-operator">==</span> <span class="ruby-identifier">n</span> <span class="ruby-operator">-</span> <span class="ruby-identifier">k</span> <span class="ruby-operator">+</span> <span class="ruby-identifier">i</span>
+          <span class="ruby-keyword kw">break</span> <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">i</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span>
+          <span class="ruby-identifier">idx</span>[<span class="ruby-identifier">i</span>] <span class="ruby-operator">+=</span> <span class="ruby-value">1</span>
+          (<span class="ruby-identifier">i</span> <span class="ruby-operator">+</span> <span class="ruby-value">1</span> <span class="ruby-operator">...</span> <span class="ruby-identifier">k</span>).<span class="ruby-identifier">each</span> {<span class="ruby-operator">|</span><span class="ruby-identifier">j</span><span class="ruby-operator">|</span> <span class="ruby-identifier">idx</span>[<span class="ruby-identifier">j</span>] = <span class="ruby-identifier">idx</span>[<span class="ruby-identifier">i</span>] <span class="ruby-operator">+</span> <span class="ruby-identifier">j</span> <span class="ruby-operator">-</span> <span class="ruby-identifier">i</span>}
+        <span class="ruby-keyword kw">end</span>
+      <span class="ruby-keyword kw">else</span>
+        <span class="ruby-identifier">to_enum</span>(<span class="ruby-identifier">:combination</span>, <span class="ruby-identifier">k</span>)
+      <span class="ruby-keyword kw">end</span>
+      <span class="ruby-comment cmt">#a = []</span>
+      <span class="ruby-comment cmt">#s = self</span>
+      <span class="ruby-comment cmt">#n = s.size</span>
+      <span class="ruby-comment cmt">#return unless (1..n) === k</span>
+      <span class="ruby-comment cmt">#dx = (0...k).to_a</span>
+      <span class="ruby-comment cmt">#loop do</span>
+      <span class="ruby-comment cmt">#  a &lt;&lt; s.values_at(*idx)</span>
+      <span class="ruby-comment cmt">#  i = k - 1</span>
+      <span class="ruby-comment cmt">#  i -= 1 while idx[i] == n - k + i</span>
+      <span class="ruby-comment cmt">#  break if i &lt; 0</span>
+      <span class="ruby-comment cmt">#  idx[i] += 1</span>
+      <span class="ruby-comment cmt">#  (i + 1 ... k).each {|j| idx[j] = idx[i] + j - i}</span>
+      <span class="ruby-comment cmt">#end</span>
+      <span class="ruby-comment cmt">#a</span>
+    <span class="ruby-keyword kw">end</span>
+</pre>
+  </div>
+</div>
+</div>
+<div class="method">
+  <div class="title">
+    <a name="M000120"></a><b>conjoin</b>(*args) {|i, *slice(i,2)| ...}
+  </div>
+  <div class="description">
+  <p>
+This is more advnaced form of join. It allows for fine control of
+separators.
+</p>
+<p>
+NOTE: The old version used to default it&#8216;s separator to &quot;,
+&quot; and default the terminating separator to &quot; and &quot;. This is
+no longer the case. You must specifically provide these parameters.
+</p>
+<pre>
+  [1,2,3].conjoin
+  =&gt; &quot;123&quot;
+
+  [1,2,3].conjoin(', ', ' and ')
+  =&gt; &quot;1, 2 and 3
+
+  [1,2,3].conjoin(', ', :last =&gt; ' or ')
+  =&gt; &quot;1, 2 or 3
+
+  [1,2,3].conjoin('; ', -1 =&gt; ' &amp; ')
+  =&gt; &quot;1; 2 &amp; 3
+
+  [1,2,3,4].conjoin{ |i, a, b| i % 2 == 0 ? '.' : '-' }
+  =&gt; &quot;1.2-3.4&quot;
+
+  [1,1,2,2].conjoin{ |i, a, b| a == b ? '=' : '!=' }
+  =&gt; &quot;1=1!=2=2&quot;
+
+ CREDIT: Trans
+</pre>
+  </div>
+<div class="sourcecode">
+  <p class="source-link">[ <a href="javascript:toggleSource('M000120_source')" id="l_M000120_source">show source</a> ]</p>
+  <div id="M000120_source" class="dyn-source">
+<pre>
+<span class="ruby-comment cmt"># File lib/facets/array/conjoin.rb, line 30</span>
+  <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">conjoin</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>, <span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
+    <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">first</span>.<span class="ruby-identifier">to_s</span> <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">size</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">2</span>
+
+    <span class="ruby-identifier">sep</span> = []
+
+    <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">block_given?</span>
+      (<span class="ruby-identifier">size</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>).<span class="ruby-identifier">times</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">i</span><span class="ruby-operator">|</span>
+        <span class="ruby-identifier">sep</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-keyword kw">yield</span>(<span class="ruby-identifier">i</span>, <span class="ruby-operator">*</span><span class="ruby-identifier">slice</span>(<span class="ruby-identifier">i</span>,<span class="ruby-value">2</span>))
+      <span class="ruby-keyword kw">end</span>
+    <span class="ruby-keyword kw">else</span>
+      <span class="ruby-identifier">options</span>   = (<span class="ruby-constant">Hash</span><span class="ruby-operator">===</span><span class="ruby-identifier">args</span>.<span class="ruby-identifier">last</span>) <span class="ruby-operator">?</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">pop</span> <span class="ruby-operator">:</span> {}
+      <span class="ruby-identifier">separator</span> = <span class="ruby-identifier">args</span>.<span class="ruby-identifier">shift</span> <span class="ruby-operator">||</span> <span class="ruby-value str">&quot;&quot;</span>
+      <span class="ruby-identifier">options</span>[<span class="ruby-value">-1</span>] = <span class="ruby-identifier">args</span>.<span class="ruby-identifier">shift</span> <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">empty?</span>
+
+      <span class="ruby-identifier">sep</span> = [<span class="ruby-identifier">separator</span>] <span class="ruby-operator">*</span> (<span class="ruby-identifier">size</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>)
+
+      <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">options</span>.<span class="ruby-identifier">key?</span>(<span class="ruby-identifier">:last</span>)
+        <span class="ruby-identifier">options</span>[<span class="ruby-value">-1</span>] = <span class="ruby-identifier">options</span>.<span class="ruby-identifier">delete</span>(<span class="ruby-identifier">:last</span>)
+      <span class="ruby-keyword kw">end</span>
+
+      <span class="ruby-identifier">options</span>[<span class="ruby-value">-1</span>] <span class="ruby-operator">||=</span> <span class="ruby-value str">&quot; and &quot;</span>
+
+      <span class="ruby-identifier">options</span>.<span class="ruby-identifier">each</span>{<span class="ruby-operator">|</span><span class="ruby-identifier">i</span>, <span class="ruby-identifier">s</span><span class="ruby-operator">|</span> <span class="ruby-identifier">sep</span>[<span class="ruby-identifier">i</span>] = <span class="ruby-identifier">s</span>}
+    <span class="ruby-keyword kw">end</span>
+    <span class="ruby-identifier">zip</span>(<span class="ruby-identifier">sep</span>).<span class="ruby-identifier">join</span>
+  <span class="ruby-keyword kw">end</span>
+</pre>
+  </div>
+</div>
+</div>
+<div class="method">
+  <div class="title">
+    <a name="M000126"></a><b>delete_unless</b>(&amp;block)
+  </div>
+  <div class="description">
+  <p>
+Inverse of delete_if.
+</p>
+<pre>
+  [1,2,3].delete_unless{ |x| x &lt; 2 }
+  =&gt; [1,2]
+
+ CREDIT: Daniel Schierbeck
+</pre>
+  </div>
+<div class="sourcecode">
+  <p class="source-link">[ <a href="javascript:toggleSource('M000126_source')" id="l_M000126_source">show source</a> ]</p>
+  <div id="M000126_source" class="dyn-source">
+<pre>
+<span class="ruby-comment cmt"># File lib/facets/array/delete.rb, line 10</span>
+  <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">delete_unless</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
+    <span class="ruby-identifier">delete_if</span> { <span class="ruby-operator">|</span><span class="ruby-identifier">element</span><span class="ruby-operator">|</span> <span class="ruby-keyword kw">not</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">element</span>) }
+  <span class="ruby-keyword kw">end</span>
+</pre>
+  </div>
+</div>
+</div>
+<div class="method">
+  <div class="title">
+    <a name="M000127"></a><b>delete_values</b>(*values)
+  </div>
+  <div class="description">
+  <p>
+Delete multiple values from array.
+</p>
+<pre>
+  a = [1,2,3,4]
+  a.delete_values(1,2)   #=&gt; [1,2]
+  a                      #=&gt; [3,4]
+</pre>
+<p>
+CREDIT: Trans
+</p>
+  </div>
+<div class="sourcecode">
+  <p class="source-link">[ <a href="javascript:toggleSource('M000127_source')" id="l_M000127_source">show source</a> ]</p>
+  <div id="M000127_source" class="dyn-source">
+<pre>
+<span class="ruby-comment cmt"># File lib/facets/array/delete.rb, line 22</span>
+  <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">delete_values</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">values</span>)
+    <span class="ruby-identifier">d</span> = []
+    <span class="ruby-identifier">values</span>.<span class="ruby-identifier">each</span>{ <span class="ruby-operator">|</span><span class="ruby-identifier">v</span><span class="ruby-operator">|</span> <span class="ruby-identifier">d</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">delete</span>(<span class="ruby-identifier">v</span>) }
+    <span class="ruby-identifier">d</span>
+  <span class="ruby-keyword kw">end</span>
+</pre>
+  </div>
+</div>
+</div>
+<div class="method">
+  <div class="title">
+    <a name="M000128"></a><b>delete_values_at</b>(*selectors)
+  </div>
+  <div class="description">
+  <p>
+Delete multiple values from array given indexes or index range.
+</p>
+<pre>
+  a = [1,2,3,4]
+  a.delete_values_at(1,2)   #=&gt; [2,3]
+  a                         #=&gt; [1,4]
+  a = [1,2,3,4]
+  a.delete_values_at(0..2)  #=&gt; [1,2,3]
+  a                         #=&gt; [4]
+</pre>
+<p>
+NOTE: It would be nice to see delete_at incorporate this funcitonaility.
+</p>
+<pre>
+ CREDIT: Trans
+</pre>
+  </div>
+<div class="sourcecode">
+  <p class="source-link">[ <a href="javascript:toggleSource('M000128_source')" id="l_M000128_source">show source</a> ]</p>
+  <div id="M000128_source" class="dyn-source">
+<pre>
+<span class="ruby-comment cmt"># File lib/facets/array/delete.rb, line 43</span>
+  <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">delete_values_at</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">selectors</span>)
+    <span class="ruby-identifier">idx</span> = []
+    <span class="ruby-identifier">selectors</span>.<span class="ruby-identifier">each</span>{ <span class="ruby-operator">|</span><span class="ruby-identifier">i</span><span class="ruby-operator">|</span>
+      <span class="ruby-keyword kw">case</span> <span class="ruby-identifier">i</span>
+      <span class="ruby-keyword kw">when</span> <span class="ruby-constant">Range</span>
+        <span class="ruby-identifier">idx</span>.<span class="ruby-identifier">concat</span>( <span class="ruby-identifier">i</span>.<span class="ruby-identifier">to_a</span> )
+      <span class="ruby-keyword kw">else</span>
+        <span class="ruby-identifier">idx</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">i</span>.<span class="ruby-identifier">to_i</span>
+      <span class="ruby-keyword kw">end</span>
+    }
+    <span class="ruby-identifier">idx</span>.<span class="ruby-identifier">uniq!</span>
+    <span class="ruby-identifier">dvals</span> = <span class="ruby-identifier">values_at</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">idx</span>)
+    <span class="ruby-identifier">idx</span> = (<span class="ruby-value">0</span><span class="ruby-operator">...</span><span class="ruby-identifier">size</span>).<span class="ruby-identifier">to_a</span> <span class="ruby-operator">-</span> <span class="ruby-identifier">idx</span>
+    <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">replace</span>( <span class="ruby-identifier">values_at</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">idx</span>) )
+    <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">dvals</span>
+  <span class="ruby-keyword kw">end</span>
+</pre>
+  </div>
+</div>
+</div>
+<div class="method">
+  <div class="title">
+    <a name="M000121"></a><b>merge!</b>( other )
+  </div>
+  <div class="description">
+  <p>
+In place merge.
+</p>
+<pre>
+  a = [1,2]
+  a.merge! [2,3]
+  a =&gt; [1,2,3]
+
+ CREDIT: Trans
+</pre>
+  </div>
+<div class="sourcecode">
+  <p class="source-link">[ <a href="javascript:toggleSource('M000121_source')" id="l_M000121_source">show source</a> ]</p>
+  <div id="M000121_source" class="dyn-source">
+<pre>
+<span class="ruby-comment cmt"># File lib/facets/array/merge.rb, line 11</span>
+  <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">merge!</span>( <span class="ruby-identifier">other</span> )
+    <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">replace</span>(<span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">merge</span>(<span class="ruby-identifier">other</span>))
+  <span class="ruby-keyword kw">end</span>
+</pre>
+  </div>
+</div>
+</div>
+<div class="method">
+  <div class="title">
+    <a name="M000117"></a><b>not_empty?</b>()
+  </div>
+  <div class="description">
+  <p>
+Not empty?
+</p>
+<pre>
+  [].not_empty?     #=&gt; false
+  [1,2].not_empty?  #=&gt; true
+</pre>
+  </div>
+<div class="sourcecode">
+  <p class="source-link">[ <a href="javascript:toggleSource('M000117_source')" id="l_M000117_source">show source</a> ]</p>
+  <div id="M000117_source" class="dyn-source">
+<pre>
+<span class="ruby-comment cmt"># File lib/facets/array/not_empty.rb, line 8</span>
+  <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">not_empty?</span>
+    <span class="ruby-operator">!</span><span class="ruby-identifier">empty?</span>
+  <span class="ruby-keyword kw">end</span>
+</pre>
+  </div>
+</div>
+</div>
+<div class="method">
+  <div class="title">
+    <a name="M000125"></a><b>only</b>()
+  </div>
+  <div class="description">
+  <p>
+Returns the <em><a href="Array.html#M000125">only</a></em> element in the
+array. Raises an IndexError if the array&#8216;s size is not 1.
+</p>
+<pre>
+  [5].only      # -&gt; 5
+  [1,2,3].only  # -&gt; IndexError
+  [].only       # -&gt; IndexError
+
+ CREDIT: Gavin Sinclair
+ CREDIT: Noah Gibbs
+</pre>
+  </div>
+<div class="sourcecode">
+  <p class="source-link">[ <a href="javascript:toggleSource('M000125_source')" id="l_M000125_source">show source</a> ]</p>
+  <div id="M000125_source" class="dyn-source">
+<pre>
+<span class="ruby-comment cmt"># File lib/facets/array/only.rb, line 13</span>
+  <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">only</span>
+    <span class="ruby-keyword kw">unless</span> <span class="ruby-identifier">size</span> <span class="ruby-operator">==</span> <span class="ruby-value">1</span>
+      <span class="ruby-identifier">raise</span> <span class="ruby-constant">IndexError</span>, <span class="ruby-value str">&quot;Array#only called on non-single-element array&quot;</span>
+    <span class="ruby-keyword kw">end</span>
+    <span class="ruby-identifier">first</span>
+  <span class="ruby-keyword kw">end</span>
+</pre>
+  </div>
+</div>
+</div>
+<div class="method">
+  <div class="title">
+    <a name="M000130"></a><b>pad</b>(len, val=nil)
+  </div>
+  <div class="description">
+  <p>
+Pad an array with a given <tt>value</tt> upto a given <tt>length</tt>.
+</p>
+<pre>
+  [0,1,2].pad(6,&quot;a&quot;)  #=&gt; [0,1,2,&quot;a&quot;,&quot;a&quot;,&quot;a&quot;]
+</pre>
+<p>
+If <tt>length</tt> is a negative number padding will be added to the
+beginning of the array.
+</p>
+<pre>
+  [0,1,2].pad(-6,&quot;a&quot;)  #=&gt; [&quot;a&quot;,&quot;a&quot;,&quot;a&quot;,0,1,2]
+
+ CREDIT: Richard Laugesen
+</pre>
+  </div>
+<div class="sourcecode">
+  <p class="source-link">[ <a href="javascript:toggleSource('M000130_source')" id="l_M000130_source">show source</a> ]</p>
+  <div id="M000130_source" class="dyn-source">
+<pre>
+<span class="ruby-comment cmt"># File lib/facets/array/pad.rb, line 14</span>
+  <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">pad</span>(<span class="ruby-identifier">len</span>, <span class="ruby-identifier">val</span>=<span class="ruby-keyword kw">nil</span>)
+    <span class="ruby-keyword kw">return</span> <span class="ruby-identifier">dup</span> <span class="ruby-keyword kw">if</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;=</span> <span class="ruby-identifier">len</span>.<span class="ruby-identifier">abs</span>
+    <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">len</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span>
+      <span class="ruby-constant">Array</span>.<span class="ruby-identifier">new</span>((<span class="ruby-identifier">len</span><span class="ruby-operator">+</span><span class="ruby-identifier">size</span>).<span class="ruby-identifier">abs</span>,<span class="ruby-identifier">val</span>) <span class="ruby-operator">+</span> <span class="ruby-keyword kw">self</span>
+    <span class="ruby-keyword kw">else</span>
+      <span class="ruby-keyword kw">self</span> <span class="ruby-operator">+</span> <span class="ruby-constant">Array</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">len</span><span class="ruby-operator">-</span><span class="ruby-identifier">size</span>,<span class="ruby-identifier">val</span>)
+    <span class="ruby-keyword kw">end</span>
+  <span class="ruby-keyword kw">end</span>
+</pre>
+  </div>
+</div>
+</div>
+<div class="method">
+  <div class="title">
+    <a name="M000131"></a><b>pad!</b>(len, val=nil)
+  </div>
+  <div class="description">
+  <p>
+Like <a href="Array.html#M000130">pad</a> but changes the array in place.
+</p>
+<pre>
+   a = [0,1,2]
+   a.pad!(6,&quot;x&quot;)
+   a  #=&gt; [0,1,2,&quot;x&quot;,&quot;x&quot;,&quot;x&quot;]
+
+ CREDIT: Richard Laugesen
+</pre>
+  </div>
+<div class="sourcecode">
+  <p class="source-link">[ <a href="javascript:toggleSource('M000131_source')" id="l_M000131_source">show source</a> ]</p>
+  <div id="M000131_source" class="dyn-source">
+<pre>
+<span class="ruby-comment cmt"># File lib/facets/array/pad.rb, line 31</span>
+  <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">pad!</span>(<span class="ruby-identifier">len</span>, <span class="ruby-identifier">val</span>=<span class="ruby-keyword kw">nil</span>)
+    <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">self</span> <span class="ruby-keyword kw">if</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">&gt;=</span> <span class="ruby-identifier">len</span>.<span class="ruby-identifier">abs</span>
+    <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">len</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span>
+      <span class="ruby-identifier">replace</span> <span class="ruby-constant">Array</span>.<span class="ruby-identifier">new</span>((<span class="ruby-identifier">len</span><span class="ruby-operator">+</span><span class="ruby-identifier">size</span>).<span class="ruby-identifier">abs</span>,<span class="ruby-identifier">val</span>) <span class="ruby-operator">+</span> <span class="ruby-keyword kw">self</span>
+    <span class="ruby-keyword kw">else</span>
+      <span class="ruby-identifier">concat</span> <span class="ruby-constant">Array</span>.<span class="ruby-identifier">new</span>(<span class="ruby-identifier">len</span><span class="ruby-operator">-</span><span class="ruby-identifier">size</span>,<span class="ruby-identifier">val</span>)
+    <span class="ruby-keyword kw">end</span>
+  <span class="ruby-keyword kw">end</span>
+</pre>
+  </div>
+</div>
+</div>
+<div class="method">
+  <div class="title">
+    <a name="M000113"></a><b>permutation</b>(n=size) {|[]| ...}
+  </div>
+  <div class="description">
+  <p>
+Permutation provids the possible orders of an enumerable. Each is indexed
+by a <a href="Array.html#M000113">permutation</a> number. The maximum
+number of arrangements is the factorial of the size of the array.
+</p>
+<pre>
+ CREDIT: Shin-ichiro Hara
+</pre>
+  </div>
+<div class="sourcecode">
+  <p class="source-link">[ <a href="javascript:toggleSource('M000113_source')" id="l_M000113_source">show source</a> ]</p>
+  <div id="M000113_source" class="dyn-source">
+<pre>
+<span class="ruby-comment cmt"># File lib/facets/ruby.rb, line 104</span>
+    <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">permutation</span>(<span class="ruby-identifier">n</span>=<span class="ruby-identifier">size</span>)
+      <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">size</span> <span class="ruby-operator">&lt;</span> <span class="ruby-identifier">n</span> <span class="ruby-keyword kw">or</span> <span class="ruby-identifier">n</span> <span class="ruby-operator">&lt;</span> <span class="ruby-value">0</span>
+      <span class="ruby-keyword kw">elsif</span> <span class="ruby-identifier">n</span> <span class="ruby-operator">==</span> <span class="ruby-value">0</span>
+        <span class="ruby-keyword kw">yield</span>([])
+      <span class="ruby-keyword kw">else</span>
+        <span class="ruby-keyword kw">self</span>[<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-value">-1</span>].<span class="ruby-identifier">permutation</span>(<span class="ruby-identifier">n</span> <span class="ruby-operator">-</span> <span class="ruby-value">1</span>) <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">x</span><span class="ruby-operator">|</span>
+          (<span class="ruby-value">0</span><span class="ruby-operator">...</span><span class="ruby-identifier">n</span>).<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">i</span><span class="ruby-operator">|</span>
+            <span class="ruby-keyword kw">yield</span>(<span class="ruby-identifier">x</span>[<span class="ruby-value">0</span><span class="ruby-operator">...</span><span class="ruby-identifier">i</span>] <span class="ruby-operator">+</span> [<span class="ruby-identifier">first</span>] <span class="ruby-operator">+</span> <span class="ruby-identifier">x</span>[<span class="ruby-identifier">i</span><span class="ruby-operator">..</span><span class="ruby-value">-1</span>])
+          <span class="ruby-keyword kw">end</span>
+        <span class="ruby-keyword kw">end</span>
+        <span class="ruby-keyword kw">self</span>[<span class="ruby-value">1</span><span class="ruby-operator">..</span><span class="ruby-value">-1</span>].<span class="ruby-identifier">permutation</span>(<span class="ruby-identifier">n</span>) <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">x</span><span class="ruby-operator">|</span>
+          <span class="ruby-keyword kw">yield</span>(<span class="ruby-identifier">x</span>)
+        <span class="ruby-keyword kw">end</span>
+      <span class="ruby-keyword kw">end</span>
+    <span class="ruby-keyword kw">end</span>
+</pre>
+  </div>
+</div>
+</div>
+<div class="method">
+  <div class="title">
+    <a name="M000111"></a><b>product</b>(*enums, &amp;block)
+  </div>
+  <div class="description">
+  <p>
+Provides the cross-<a href="Array.html#M000111">product</a> of two or more
+Enumerables. This is the class-level method. The instance method calls on
+this.
+</p>
+<pre>
+  Enumerable.cartesian_product([1,2], [4], [&quot;apple&quot;, &quot;banana&quot;])
+  #=&gt; [[1, 4, &quot;apple&quot;], [1, 4, &quot;banana&quot;], [2, 4, &quot;apple&quot;], [2, 4, &quot;banana&quot;]]
+
+  Enumerable.cartesian_product([1,2], [3,4])
+  #=&gt; [[1, 3], [1, 4], [2, 3], [2, 4]]
+
+  a = []
+  [1,2].cart([4,5]){|elem| a &lt;&lt; elem }
+  a  #=&gt; [[1, 4],[1, 5],[2, 4],[2, 5]]
+
+ CREDIT: Thomas Hafner
+</pre>
+  </div>
+<div class="aka">
+  This method is also aliased as
+  <a href="Array.html#M000116">**</a>
+</div>
+<div class="sourcecode">
+  <p class="source-link">[ <a href="javascript:toggleSource('M000111_source')" id="l_M000111_source">show source</a> ]</p>
+  <div id="M000111_source" class="dyn-source">
+<pre>
+<span class="ruby-comment cmt"># File lib/facets/ruby.rb, line 32</span>
+    <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">product</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">enums</span>, <span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
+      <span class="ruby-identifier">enums</span>.<span class="ruby-identifier">unshift</span> <span class="ruby-keyword kw">self</span>
+      <span class="ruby-identifier">result</span> = [[]]
+      <span class="ruby-keyword kw">while</span> [] <span class="ruby-operator">!=</span> <span class="ruby-identifier">enums</span>
+        <span class="ruby-identifier">t</span>, <span class="ruby-identifier">result</span> = <span class="ruby-identifier">result</span>, []
+        <span class="ruby-identifier">b</span>, <span class="ruby-operator">*</span><span class="ruby-identifier">enums</span> = <span class="ruby-identifier">enums</span>
+        <span class="ruby-identifier">t</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">a</span><span class="ruby-operator">|</span>
+          <span class="ruby-identifier">b</span>.<span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">n</span><span class="ruby-operator">|</span>
+            <span class="ruby-identifier">result</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">a</span> <span class="ruby-operator">+</span> [<span class="ruby-identifier">n</span>]
+          <span class="ruby-keyword kw">end</span>
+        <span class="ruby-keyword kw">end</span>
+      <span class="ruby-keyword kw">end</span>
+      <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">block_given?</span>
+        <span class="ruby-identifier">result</span>.<span class="ruby-identifier">each</span>{ <span class="ruby-operator">|</span><span class="ruby-identifier">e</span><span class="ruby-operator">|</span> <span class="ruby-identifier">block</span>.<span class="ruby-identifier">call</span>(<span class="ruby-identifier">e</span>) }
+      <span class="ruby-keyword kw">else</span>
+        <span class="ruby-identifier">result</span>
+      <span class="ruby-keyword kw">end</span>
+    <span class="ruby-keyword kw">end</span>
+</pre>
+  </div>
+</div>
+</div>
+<div class="method">
+  <div class="title">
+    <a name="M000118"></a><b>rotate</b>(n=1)
+  </div>
+  <div class="description">
+  <p>
+Rotates an array&#8216;s elements from back to front n times.
+</p>
+<pre>
+  [1,2,3].rotate      #=&gt; [3,1,2]
+  [3,1,2].rotate      #=&gt; [2,3,1]
+  [3,1,2].rotate      #=&gt; [1,2,3]
+  [1,2,3].rotate(3)   #=&gt; [1,2,3]
+</pre>
+<p>
+A negative parameter reverses the order from front to back.
+</p>
+<pre>
+  [1,2,3].rotate(-1)  #=&gt; [2,3,1]
+
+ CREDIT: Florian Gross
+ CREDIT: Thomas Sawyer
+</pre>
+  </div>
+<div class="sourcecode">
+  <p class="source-link">[ <a href="javascript:toggleSource('M000118_source')" id="l_M000118_source">show source</a> ]</p>
+  <div id="M000118_source" class="dyn-source">
+<pre>
+<span class="ruby-comment cmt"># File lib/facets/array/rotate.rb, line 17</span>
+  <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">rotate</span>(<span class="ruby-identifier">n</span>=<span class="ruby-value">1</span>)
+    <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">dup</span>.<span class="ruby-identifier">rotate!</span>(<span class="ruby-identifier">n</span>)
+  <span class="ruby-keyword kw">end</span>
+</pre>
+  </div>
+</div>
+</div>
+<div class="method">
+  <div class="title">
+    <a name="M000119"></a><b>rotate!</b>(n=1)
+  </div>
+  <div class="description">
+  <p>
+Same as <a href="Array.html#M000118">rotate</a>, but acts in place.
+</p>
+<pre>
+  a = [1,2,3]
+  a.rotate!
+  a  #=&gt; [3,1,2]
+
+ CREDIT: Florian Gross
+ CREDIT: Thomas Sawyer
+</pre>
+  </div>
+<div class="sourcecode">
+  <p class="source-link">[ <a href="javascript:toggleSource('M000119_source')" id="l_M000119_source">show source</a> ]</p>
+  <div id="M000119_source" class="dyn-source">
+<pre>
+<span class="ruby-comment cmt"># File lib/facets/array/rotate.rb, line 30</span>
+  <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">rotate!</span>(<span class="ruby-identifier">n</span>=<span class="ruby-value">1</span>)
+    <span class="ruby-identifier">n</span> = <span class="ruby-identifier">n</span>.<span class="ruby-identifier">to_int</span>
+    <span class="ruby-keyword kw">return</span> <span class="ruby-keyword kw">self</span> <span class="ruby-keyword kw">if</span> (<span class="ruby-identifier">n</span> <span class="ruby-operator">==</span> <span class="ruby-value">0</span> <span class="ruby-keyword kw">or</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">empty?</span>)
+    <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">n</span> <span class="ruby-operator">&gt;</span> <span class="ruby-value">0</span>
+      <span class="ruby-identifier">n</span>.<span class="ruby-identifier">abs</span>.<span class="ruby-identifier">times</span>{ <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">unshift</span>( <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">pop</span> ) }
+    <span class="ruby-keyword kw">else</span>
+      <span class="ruby-identifier">n</span>.<span class="ruby-identifier">abs</span>.<span class="ruby-identifier">times</span>{ <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">push</span>( <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">shift</span> ) }
+    <span class="ruby-keyword kw">end</span>
+    <span class="ruby-keyword kw">self</span>
+  <span class="ruby-keyword kw">end</span>
+</pre>
+  </div>
+</div>
+</div>
+<div class="method">
+  <div class="title">
+    <a name="M000124"></a><b>select!</b>( {|| ...}
+  </div>
+  <div class="description">
+  <p>
+As with select but modifies the <a href="Array.html">Array</a> in place.
+</p>
+<pre>
+  a = [1,2,3,4,5,6,7,8,9,10]
+  a.select!{ |e| e % 2 == 0 }
+  a  #=&gt; [2,4,6,8,10]
+
+ CREDIT: Gavin Sinclair
+</pre>
+  </div>
+<div class="sourcecode">
+  <p class="source-link">[ <a href="javascript:toggleSource('M000124_source')" id="l_M000124_source">show source</a> ]</p>
+  <div id="M000124_source" class="dyn-source">
+<pre>
+<span class="ruby-comment cmt"># File lib/facets/array/select.rb, line 11</span>
+  <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">select!</span>  <span class="ruby-comment cmt"># :yield:</span>
+    <span class="ruby-identifier">reject!</span>{ <span class="ruby-operator">|</span><span class="ruby-identifier">e</span><span class="ruby-operator">|</span> <span class="ruby-keyword kw">not</span> <span class="ruby-keyword kw">yield</span>(<span class="ruby-identifier">e</span>) }
+  <span class="ruby-keyword kw">end</span>
+</pre>
+  </div>
+</div>
+</div>
+<div class="method">
+  <div class="title">
+    <a name="M000129"></a><b>splice</b>(*args)
+  </div>
+  <div class="description">
+  <p>
+Splice acts a <a href="Array.html#M000112">combination</a> of slice! and
+store. If two arguments are given it calls store. If a single argument is
+give it calls slice!.
+</p>
+<pre>
+  a = [1,2,3]
+  a.splice(1)    #=&gt; 2
+  a              #=&gt; [1,3]
+
+  a = [1,2,3]
+  a.splice(1,4)  #=&gt; 4
+  a              #=&gt;[1,4,3]
+
+ CREDIT: Trans
+</pre>
+  </div>
+<div class="sourcecode">
+  <p class="source-link">[ <a href="javascript:toggleSource('M000129_source')" id="l_M000129_source">show source</a> ]</p>
+  <div id="M000129_source" class="dyn-source">
+<pre>
+<span class="ruby-comment cmt"># File lib/facets/array/splice.rb, line 17</span>
+  <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">splice</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
+    <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">args</span>.<span class="ruby-identifier">size</span> <span class="ruby-operator">==</span> <span class="ruby-value">1</span>
+      <span class="ruby-identifier">slice!</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
+    <span class="ruby-keyword kw">else</span>
+      <span class="ruby-identifier">store</span>(<span class="ruby-operator">*</span><span class="ruby-identifier">args</span>)
+    <span class="ruby-keyword kw">end</span>
+  <span class="ruby-keyword kw">end</span>
+</pre>
+  </div>
+</div>
+</div>
+<div class="method">
+  <div class="title">
+    <a name="M000114"></a><b>to_b</b>()
+  </div>
+  <div class="description">
+  <p>
+Boolean conversion for not empty?
+</p>
+  </div>
+<div class="sourcecode">
+  <p class="source-link">[ <a href="javascript:toggleSource('M000114_source')" id="l_M000114_source">show source</a> ]</p>
+  <div id="M000114_source" class="dyn-source">
+<pre>
+<span class="ruby-comment cmt"># File lib/facets/boolean.rb, line 60</span>
+  <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">to_b</span>
+    <span class="ruby-operator">!</span> <span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">empty?</span>
+  <span class="ruby-keyword kw">end</span>
+</pre>
+  </div>
+</div>
+</div>
+<div class="method">
+  <div class="title">
+    <a name="M000115"></a><b>to_h</b>(arrayed=nil)
+  </div>
+  <div class="description">
+  <p>
+Converts a two-element associative array into a hash.
+</p>
+<pre>
+  a = [ [:a,1], [:b,2] ]
+  a.to_h  #=&gt; { :a=&gt;1, :b=&gt;2 }
+</pre>
+<p>
+If <tt>arrayed</tt> is set it will maintain trailing arrays.
+</p>
+<pre>
+  a = [ [:a,1,2], [:b,3] ]
+  a.to_h(true)  #=&gt; { :a=&gt;[1,2], :b=&gt;[3] }
+</pre>
+<p>
+Note that the use of a values parameter has been deprecated because that
+functionality is as simple as:
+</p>
+<pre>
+  array1.zip(array2).to_h
+
+ CREDIT: Trans
+</pre>
+  </div>
+<div class="sourcecode">
+  <p class="source-link">[ <a href="javascript:toggleSource('M000115_source')" id="l_M000115_source">show source</a> ]</p>
+  <div id="M000115_source" class="dyn-source">
+<pre>
+<span class="ruby-comment cmt"># File lib/facets/to_hash.rb, line 20</span>
+  <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">to_h</span>(<span class="ruby-identifier">arrayed</span>=<span class="ruby-keyword kw">nil</span>)
+    <span class="ruby-identifier">h</span> = {}
+    <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">arrayed</span> <span class="ruby-comment cmt">#or (flatten.size % 2 == 1)</span>
+      <span class="ruby-comment cmt">#each{ |e| h[e.first] = e.slice(1..-1) }</span>
+      <span class="ruby-identifier">each</span>{ <span class="ruby-operator">|</span><span class="ruby-identifier">k</span>,<span class="ruby-operator">*</span><span class="ruby-identifier">v</span><span class="ruby-operator">|</span> <span class="ruby-identifier">h</span>[<span class="ruby-identifier">k</span>] = <span class="ruby-identifier">v</span> }
+    <span class="ruby-keyword kw">else</span>
+      <span class="ruby-comment cmt">#h = Hash[*flatten(1)] # TODO Use in 1.9 instead.</span>
+      <span class="ruby-identifier">ary</span> = []
+      <span class="ruby-identifier">each</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">a</span><span class="ruby-operator">|</span>
+        <span class="ruby-constant">Array</span><span class="ruby-operator">===</span><span class="ruby-identifier">a</span> <span class="ruby-value">? </span><span class="ruby-identifier">ary</span>.<span class="ruby-identifier">concat</span>(<span class="ruby-identifier">a</span>) <span class="ruby-operator">:</span> <span class="ruby-identifier">ary</span> <span class="ruby-operator">&lt;&lt;</span> <span class="ruby-identifier">a</span>
+      <span class="ruby-keyword kw">end</span>
+      <span class="ruby-identifier">h</span> = <span class="ruby-constant">Hash</span>[<span class="ruby-operator">*</span><span class="ruby-identifier">ary</span>]
+    <span class="ruby-keyword kw">end</span>
+    <span class="ruby-identifier">h</span>
+  <span class="ruby-keyword kw">end</span>
+</pre>
+  </div>
+</div>
+</div>
+<div class="method">
+  <div class="title">
+    <a name="M000122"></a><b>traverse</b>() {|item| ...}
+  </div>
+<div class="sourcecode">
+  <p class="source-link">[ <a href="javascript:toggleSource('M000122_source')" id="l_M000122_source">show source</a> ]</p>
+  <div id="M000122_source" class="dyn-source">
+<pre>
+<span class="ruby-comment cmt"># File lib/facets/array/traverse.rb, line 5</span>
+  <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">traverse</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
+    <span class="ruby-identifier">map</span> <span class="ruby-keyword kw">do</span> <span class="ruby-operator">|</span><span class="ruby-identifier">item</span><span class="ruby-operator">|</span>
+      <span class="ruby-keyword kw">if</span> <span class="ruby-identifier">item</span>.<span class="ruby-identifier">is_a?</span>(<span class="ruby-keyword kw">self</span>.<span class="ruby-identifier">class</span>)
+        <span class="ruby-identifier">item</span>.<span class="ruby-identifier">traverse</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
+      <span class="ruby-keyword kw">else</span>
+        <span class="ruby-keyword kw">yield</span> <span class="ruby-identifier">item</span>
+      <span class="ruby-keyword kw">end</span>
+    <span class="ruby-keyword kw">end</span>
+  <span class="ruby-keyword kw">end</span>
+</pre>
+  </div>
+</div>
+</div>
+<div class="method">
+  <div class="title">
+    <a name="M000123"></a><b>traverse!</b>(&amp;block)
+  </div>
+<div class="sourcecode">
+  <p class="source-link">[ <a href="javascript:toggleSource('M000123_source')" id="l_M000123_source">show source</a> ]</p>
+  <div id="M000123_source" class="dyn-source">
+<pre>
+<span class="ruby-comment cmt"># File lib/facets/array/traverse.rb, line 17</span>
+  <span class="ruby-keyword kw">def</span> <span class="ruby-identifier">traverse!</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>)
+    <span class="ruby-identifier">replace</span>(<span class="ruby-identifier">traverse</span>(<span class="ruby-operator">&amp;</span><span class="ruby-identifier">block</span>))
+  <span class="ruby-keyword kw">end</span>
+</pre>
+  </div>
+</div>
+</div>
+</div>
+
+  </div>
+
+    </body>
+</html>