rubypath 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f4d517017d2e21a8fc5e59485e285f19cede540d
-  data.tar.gz: d978363e7ce770913f83b02c13ab41799f04e6b3
+  metadata.gz: b6a50c0dd1eea579ab534a5b321a38265bd9c4f6
+  data.tar.gz: ad371190f1cc868eeba76d652302445f515dddfb
 SHA512:
-  metadata.gz: e9b2defbdf58415d76e6d2cb8d4902eca1845ba71d1ffb237ebbd11699eb11bead4317735286dadb53c31d07cb72165d4afecc2d3de0ccf142ec586d2f609d1a
-  data.tar.gz: 7f54b7a30c7a56af8ecd10943672b7ba550cd526d8b51874772b683bc3118ef9aadcca16fc7487288447f35f1f83b4c41a072e751cbbd81c46e5d52f2beb10e9
+  metadata.gz: 97edfdceb6a0bea7103f0f1923a36b9c1fdba7a604672910c7162886c701475b6bdb1975875d3d4bd42f75663e7f46ec34114d9a22208fa07b9528b33f40e82b
+  data.tar.gz: c4dbb1749cbc28cb73411cf387f39b10bf78a114f1b3d883b32d8ef13514e17878fc66f4a75b32a947443dbfb639e2a576fade52fb41481bc1e0248ec40581c3

data/README.md

@@ -6,7 +6,7 @@
 [![Dependency Status](http://img.shields.io/gemnasium/jgraichen/rubypath.svg)](https://gemnasium.com/jgraichen/rubypath)
 [![RubyDoc Documentation](http://img.shields.io/badge/rubydoc-here-blue.svg)](http://rubydoc.info/github/jgraichen/rubypath/master/frames)
 
-*Ruby Path* introduces a global `Path` class unifying most `File`, `Dir`, `FileUtils`, `Pathname` and `IO` operations with a flexible and powerful Object-Interface and still adding new useful methods and functions like mocking a while file system for fast and reliable testing.
+*Ruby Path* introduces a global `Path` class unifying most `File`, `Dir`, `FileUtils`, `Pathname` and `IO` operations with a flexible and powerful Object-Interface and still adding new useful methods and functions like mocking a whole file system for fast and reliable testing.
 
 ## Installation
 
@@ -79,9 +79,17 @@ See full API documentation here: http://rubydoc.info/gems/rubypath/Path
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+3. Add specs testing SYS *and* MOCK file system
+4. Commit your specs (`git commit -am 'Add specs for feature'`)
+5. Add our changes for SYS *and* MOCK file system
+6. Commit your changes (`git commit -am 'Add some feature'`)
+7. Push to the branch (`git push origin my-new-feature`)
+8. Create new Pull Request
+
+### ToDos
+
+* Add missing methods
+* Improve MOCK FS implementation
 
 ## License
 

data/doc/file.README.html

@@ -63,7 +63,13 @@
 
     <div id="content"><div id='filecontents'><h1>Ruby Path</h1>
 
-<p><em>Ruby Path</em> introduces a global <code>Path</code> class unifying most <code>File</code>, <code>Dir</code>, <code>FileUtils</code>, <code>Pathname</code> and <code>IO</code> operations with a flexible and powerful Object-Interface and still adding new useful methods and functions like mocking a while file system for fast and reliable testing.</p>
+<p><a href="http://badge.fury.io/rb/rubypath"><img src="https://badge.fury.io/rb/rubypath.svg" alt="Gem Version"></a>
+<a href="https://travis-ci.org/jgraichen/rubypath"><img src="http://img.shields.io/travis/jgraichen/rubypath/master.svg" alt="Build Status"></a>
+<a href="https://coveralls.io/r/jgraichen/rubypath"><img src="http://img.shields.io/coveralls/jgraichen/rubypath/master.svg" alt="Coverage Status"></a>
+<a href="https://gemnasium.com/jgraichen/rubypath"><img src="http://img.shields.io/gemnasium/jgraichen/rubypath.svg" alt="Dependency Status"></a>
+<a href="http://rubydoc.info/github/jgraichen/rubypath/master/frames"><img src="http://img.shields.io/badge/rubydoc-here-blue.svg" alt="RubyDoc Documentation"></a></p>
+
+<p><em>Ruby Path</em> introduces a global <code>Path</code> class unifying most <code>File</code>, <code>Dir</code>, <code>FileUtils</code>, <code>Pathname</code> and <code>IO</code> operations with a flexible and powerful Object-Interface and still adding new useful methods and functions like mocking a whole file system for fast and reliable testing.</p>
 
 <h2>Installation</h2>
 
@@ -71,18 +77,83 @@
 
 <h2>Usage</h2>
 
-<p>TODO</p>
+<p>Using <code>Path</code> with file and directory methods:</p>
+
+<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_base'>base</span> <span class='op'>=</span> <span class='const'>Path</span> <span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>/path/to/base</span><span class='tstring_end'>&#39;</span></span>
+<span class='id identifier rubyid_src'>src</span>  <span class='op'>=</span> <span class='id identifier rubyid_base'>base</span><span class='period'>.</span><span class='id identifier rubyid_mkpath'>mkpath</span> <span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>project/src</span><span class='tstring_end'>&#39;</span></span>
+<span class='id identifier rubyid_src'>src</span><span class='period'>.</span><span class='id identifier rubyid_touch'>touch</span> <span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>Rakefile</span><span class='tstring_end'>&#39;</span></span>
+<span class='id identifier rubyid_src'>src</span><span class='period'>.</span><span class='id identifier rubyid_mkdir'>mkdir</span><span class='lparen'>(</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>lib</span><span class='tstring_end'>&#39;</span></span><span class='rparen'>)</span><span class='period'>.</span><span class='id identifier rubyid_mkdir'>mkdir</span><span class='lparen'>(</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>mylib</span><span class='tstring_end'>&#39;</span></span><span class='rparen'>)</span><span class='period'>.</span><span class='id identifier rubyid_touch'>touch</span><span class='lparen'>(</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>version.rb</span><span class='tstring_end'>&#39;</span></span><span class='rparen'>)</span>
+<span class='comment'>#=&gt; &lt;Path &#39;/path/to/base/project/src/lib/mylib/version.rb&#39;
+</span></code></pre>
+
+<p>Using IO:</p>
+
+<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_src'>src</span><span class='period'>.</span><span class='id identifier rubyid_write'>write</span> <span class='tstring'><span class='tstring_beg'>&quot;</span><span class='tstring_content'>module Mylib\n  VERSION = &#39;0.1.0&#39;\nend</span><span class='tstring_end'>&quot;</span></span>
+
+<span class='id identifier rubyid_src'>src</span><span class='period'>.</span><span class='id identifier rubyid_lookup'>lookup</span><span class='lparen'>(</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>project.yml</span><span class='tstring_end'>&#39;</span></span><span class='rparen'>)</span><span class='period'>.</span><span class='id identifier rubyid_read'>read</span>
+<span class='comment'>#=&gt; &quot;...&quot;
+</span></code></pre>
+
+<h3>Mock FS in tests</h3>
+
+<p>Wrap specific or just all specs in a virtual filesystem:</p>
+
+<pre class="code ruby"><code class="ruby"><span class='comment'># spec_helper.rb
+</span>
+<span class='id identifier rubyid_config'>config</span><span class='period'>.</span><span class='id identifier rubyid_around'>around</span><span class='lparen'>(</span><span class='symbol'>:each</span><span class='rparen'>)</span> <span class='kw'>do</span> <span class='op'>|</span><span class='id identifier rubyid_example'>example</span><span class='op'>|</span>
+  <span class='const'>Path</span><span class='op'>::</span><span class='const'>Backend</span><span class='period'>.</span><span class='id identifier rubyid_mock'>mock</span> <span class='label'>root:</span> <span class='symbol'>:tmp</span><span class='comma'>,</span> <span class='op'>&amp;</span><span class='id identifier rubyid_example'>example</span>
+<span class='kw'>end</span>
+</code></pre>
+
+<p>Supported options for <code>:root</code> are <code>:tmp</code> using the real filesystem but scoping all actions into a temporary directory similar to chroot or a custom defined path to use as &quot;chroot&quot; directory. This mode does not allow to stub users, home directories and some attributes.</p>
+
+<p>If not <code>:root</code> is specified a completely virtual in-memory filesystem will be used. This backend allows to even specify available users and home directories, the current user etc.</p>
+
+<p>You can then define a specific scenario in your specs:</p>
+
+<pre class="code ruby"><code class="ruby">    <span class='id identifier rubyid_before'>before</span> <span class='kw'>do</span>
+      <span class='const'>Path</span><span class='period'>.</span><span class='id identifier rubyid_mock'>mock</span> <span class='kw'>do</span> <span class='op'>|</span><span class='id identifier rubyid_root'>root</span><span class='comma'>,</span> <span class='id identifier rubyid_backend'>backend</span><span class='op'>|</span>
+        <span class='id identifier rubyid_backend'>backend</span><span class='period'>.</span><span class='id identifier rubyid_cwd'>cwd</span>          <span class='op'>=</span> <span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>/root</span><span class='tstring_end'>&#39;</span></span>
+        <span class='id identifier rubyid_backend'>backend</span><span class='period'>.</span><span class='id identifier rubyid_current_user'>current_user</span> <span class='op'>=</span> <span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>test</span><span class='tstring_end'>&#39;</span></span>
+        <span class='id identifier rubyid_backend'>backend</span><span class='period'>.</span><span class='id identifier rubyid_homes'>homes</span>        <span class='op'>=</span> <span class='lbrace'>{</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>test</span><span class='tstring_end'>&#39;</span></span> <span class='op'>=&gt;</span> <span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>/home/test</span><span class='tstring_end'>&#39;</span></span><span class='rbrace'>}</span>
+
+        <span class='id identifier rubyid_home'>home</span> <span class='op'>=</span> <span class='id identifier rubyid_root'>root</span><span class='period'>.</span><span class='id identifier rubyid_mkpath'>mkpath</span><span class='lparen'>(</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>/home/test</span><span class='tstring_end'>&#39;</span></span><span class='rparen'>)</span>
+        <span class='id identifier rubyid_home'>home</span><span class='period'>.</span><span class='id identifier rubyid_mkfile'>mkfile</span><span class='lparen'>(</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>src/test.txt</span><span class='tstring_end'>&#39;</span></span><span class='rparen'>)</span><span class='period'>.</span><span class='id identifier rubyid_write'>write</span> <span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>CONTENT</span><span class='tstring_end'>&#39;</span></span>
+        <span class='id identifier rubyid_home'>home</span><span class='period'>.</span><span class='id identifier rubyid_mkfile'>mkfile</span><span class='lparen'>(</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>src/test.html</span><span class='tstring_end'>&#39;</span></span><span class='rparen'>)</span><span class='period'>.</span><span class='id identifier rubyid_write'>write</span> <span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>&lt;html&gt;&lt;head&gt;&lt;title&gt;&lt;/title&gt;...</span><span class='tstring_end'>&#39;</span></span>
+      <span class='kw'>end</span>
+    <span class='kw'>end</span>
+
+    <span class='id identifier rubyid_it'>it</span> <span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>should mock all FS</span><span class='tstring_end'>&#39;</span></span> <span class='kw'>do</span>
+      <span class='id identifier rubyid_base'>base</span> <span class='op'>=</span> <span class='const'>Path</span><span class='lparen'>(</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>~test</span><span class='tstring_end'>&#39;</span></span><span class='rparen'>)</span><span class='period'>.</span><span class='id identifier rubyid_expand'>expand</span>
+      <span class='id identifier rubyid_expect'>expect</span><span class='lparen'>(</span><span class='id identifier rubyid_base'>base</span><span class='period'>.</span><span class='id identifier rubyid_join'>join</span><span class='lparen'>(</span><span class='qwords_beg'>%w(</span><span class='tstring_content'>src</span><span class='words_sep'> </span><span class='tstring_content'>test.txt</span><span class='words_sep'>)</span><span class='rparen'>)</span><span class='period'>.</span><span class='id identifier rubyid_read'>read</span><span class='rparen'>)</span><span class='period'>.</span><span class='id identifier rubyid_to'>to</span> <span class='id identifier rubyid_eq'>eq</span> <span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>CONTENT</span><span class='tstring_end'>&#39;</span></span>
+
+      <span class='id identifier rubyid_files'>files</span> <span class='op'>=</span> <span class='id identifier rubyid_base'>base</span><span class='period'>.</span><span class='id identifier rubyid_glob'>glob</span><span class='lparen'>(</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>**/*</span><span class='tstring_end'>&#39;</span></span><span class='rparen'>)</span><span class='period'>.</span><span class='id identifier rubyid_select'>select</span><span class='lbrace'>{</span><span class='op'>|</span><span class='id identifier rubyid_p'>p</span><span class='op'>|</span> <span class='id identifier rubyid_p'>p</span><span class='period'>.</span><span class='id identifier rubyid_file?'>file?</span> <span class='rbrace'>}</span>
+      <span class='id identifier rubyid_expect'>expect</span><span class='lparen'>(</span><span class='id identifier rubyid_files'>files</span><span class='period'>.</span><span class='id identifier rubyid_size'>size</span><span class='rparen'>)</span><span class='period'>.</span><span class='id identifier rubyid_to'>to</span> <span class='id identifier rubyid_eq'>eq</span> <span class='int'>2</span>
+    <span class='kw'>end</span>
+</code></pre>
+
+<p>See full API documentation here: <a href="http://rubydoc.info/gems/rubypath/Path">http://rubydoc.info/gems/rubypath/Path</a></p>
 
 <h2>Contributing</h2>
 
 <ol>
 <li>Fork it</li>
 <li>Create your feature branch (<code>git checkout -b my-new-feature</code>)</li>
+<li>Add specs testing SYS <em>and</em> MOCK file system</li>
+<li>Commit your specs (<code>git commit -am &#39;Add specs for feature&#39;</code>)</li>
+<li>Add our changes for SYS <em>and</em> MOCK file system</li>
 <li>Commit your changes (<code>git commit -am &#39;Add some feature&#39;</code>)</li>
 <li>Push to the branch (<code>git push origin my-new-feature</code>)</li>
 <li>Create new Pull Request</li>
 </ol>
 
+<h3>ToDos</h3>
+
+<ul>
+<li>Add missing methods</li>
+<li>Improve MOCK FS implementation</li>
+</ul>
+
 <h2>License</h2>
 
 <p>Copyright (C) 2014 Jan Graichen</p>
@@ -95,7 +166,7 @@
 </div></div>
 
     <div id="footer">
-  Generated on Wed Apr 16 20:25:34 2014 by
+  Generated on Sun Apr 27 13:05:43 2014 by
   <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
   0.8.7.3 (ruby-2.1.1).
 </div>

data/lib/rubypath/backend/mock.rb

@@ -164,6 +164,47 @@ class Path::Backend
       lookup!(path).mode
     end
 
+    def unlink(path)
+      node = lookup_parent!(path)
+      file = node.lookup ::File.basename path
+      case file
+        when Dir
+          raise Errno::EISDIR.new path
+        when File
+          node.children.delete(file)
+        when nil
+          raise Errno::ENOENT.new path
+        else
+          raise ArgumentError.new "Unknown node #{node.inspect} for #unlink."
+      end
+    end
+
+    def rmtree(path)
+      node = lookup path
+      case node
+        when Dir, File
+          lookup_parent!(path).children.delete(node)
+        when nil
+          nil
+        else
+          raise ArgumentError.new "Unknown node #{node.inspect} for #rmtree."
+      end
+    end
+    alias_method :safe_rmtree, :rmtree
+
+    def rmtree!(path)
+      node = lookup path
+      case node
+        when Dir, File
+          lookup_parent!(path).children.delete(node)
+        when nil
+          raise Errno::ENOENT.new path
+        else
+          raise ArgumentError.new "Unknown node #{node.inspect} for #rmtree."
+      end
+    end
+    alias_method :safe_rmtree!, :rmtree!
+
     # @!group Internal Virtual File System
 
     # Return root node.

data/lib/rubypath/backend/sys.rb

@@ -137,5 +137,25 @@ class Path::Backend
     def chmod(path, mode)
       fs path, ::File, :chmod, mode, r(path)
     end
+
+    def unlink(path)
+      fs path, ::File, :unlink, r(path)
+    end
+
+    def rmtree(path)
+      fs path, ::FileUtils, :rm_r, r(path), force: true
+    end
+
+    def rmtree!(path)
+      fs path, ::FileUtils, :rm_r, r(path)
+    end
+
+    def safe_rmtree(path)
+      fs path, ::FileUtils, :rm_r, r(path), force: true, secure: true
+    end
+
+    def safe_rmtree!(path)
+      fs path, ::FileUtils, :rm_r, r(path), secure: true
+    end
   end
 end

data/lib/rubypath/backend.rb

@@ -64,6 +64,11 @@ class Path
     delegate :set_umask
     delegate :mode
     delegate :chmod
+    delegate :unlink
+    delegate :rmtree
+    delegate :rmtree!
+    delegate :safe_rmtree
+    delegate :safe_rmtree!
   end
 
   private

data/lib/rubypath/comparison.rb

@@ -9,13 +9,10 @@ class Path
   # @return [Boolean] True if object represents same path.
   #
   def eql?(other)
-    case other
-      when String
-        internal_path.eql? other
-      when Path
-        internal_path.eql? other.path
-      else
-        Path.new(other).eql?(self) if Path.like? other
+    if other.is_a?(Path)
+      cleanpath.internal_path == other.cleanpath.internal_path
+    else
+      Path.new(other).eql?(self) if Path.like?(other)
     end
   end
   alias_method :==, :eql?

data/lib/rubypath/dir_operations.rb

@@ -31,6 +31,8 @@ class Path
     end
   end
 
+  # @!group Directory Operations
+
   # Create directory.
   #
   # Given arguments will be joined with current path before directory is
@@ -80,6 +82,76 @@ class Path
     Path.glob(::File.join(escaped_glob_path, pattern), flags, &block)
   end
 
+  # Removes file or directory. If it's a directory it will be removed
+  # recursively.
+  #
+  # WARNING: This method causes local vulnerability if one of parent
+  # directories or removing directory tree are world writable (including
+  # `/tmp`, whose permission is 1777), and the current process has strong
+  # privilege such as Unix super user (root), and the system has symbolic link.
+  # For secure removing see {#safe_rmtree}.
+  #
+  # @return [Path] Path to removed file or directory.
+  #
+  def rmtree(*args)
+    with_path(*args) do |path|
+      invoke_backend :rmtree, internal_path
+      Path path
+    end
+  end
+  alias_method :rm_rf, :rmtree
+
+  # Removes file or directory. If it's a directory it will be removed
+  # recursively.
+  #
+  # This method uses #{FileUtils#remove_entry_secure} to avoid TOCTTOU
+  # (time-of-check-to-time-of-use) local security vulnerability of {#rmtree}.
+  # {#rmtree} causes security hole when:
+  #
+  # * Parent directory is world writable (including `/tmp`).
+  # * Removing directory tree includes world writable directory.
+  # * The system has symbolic link.
+  #
+  # @return [Path] Path to removed file or directory.
+  #
+  def safe_rmtree(*args)
+    with_path(*args) do |path|
+      invoke_backend :safe_rmtree, internal_path
+      Path path
+    end
+  end
+
+  # Removes file or directory. If it's a directory it will be removed
+  # recursively.
+  #
+  # This method behaves exactly like {#rmtree} but will raise exceptions
+  # e.g. when file does not exist.
+  #
+  # @return [Path] Path to removed file or directory.
+  #
+  def rmtree!(*args)
+    with_path(*args) do |path|
+      invoke_backend :rmtree!, internal_path
+      Path path
+    end
+  end
+  alias_method :rm_r, :rmtree!
+
+  # Removes file or directory. If it's a directory it will be removed
+  # recursively.
+  #
+  # This method behaves exactly like {#safe_rmtree} but will raise exceptions
+  # e.g. when file does not exist.
+  #
+  # @return [Path] Path to removed file or directory.
+  #
+  def safe_rmtree!(*args)
+    with_path(*args) do |path|
+      invoke_backend :safe_rmtree!, internal_path
+      Path path
+    end
+  end
+
   private
 
   def escaped_glob_path

data/lib/rubypath/file_operations.rb

@@ -17,6 +17,10 @@ class Path
   #   Path('/path/to/file.txt').touch
   #   #=> <Path:"/path/to/file.txt">
   #
+  # @example
+  #   Path('/path/to').touch('file.txt')
+  #   #=> <Path:"/path/to/file.txt">
+  #
   # @return [Path] Path to touched file.
   #
   def touch(*args)
@@ -26,6 +30,28 @@ class Path
     end
   end
 
+  # Removes file at current path.
+  #
+  # Raise an error if file does not exists or is a directory.
+  #
+  # @example
+  #   Path('/file.txt').touch.unlink
+  #   #=> <Path /file.txt>
+  #
+  # @example
+  #   Path('/file.txt').touch
+  #   Path('/').unlink('file.txt')
+  #   #=> <Path /file.txt>
+  #
+  # @return [Path] Unlinked path.
+  #
+  def unlink(*args)
+    with_path(*args) do |path|
+      invoke_backend :unlink, path
+      Path path
+    end
+  end
+
   # Create a file at pointed location and all missing parent directories.
   #
   # Given arguments will be joined with current path before directories and

data/lib/rubypath/path_operations.rb

@@ -280,9 +280,26 @@ class Path
   end
   alias_method :relative_path_from, :relative_from
 
-  protected
-
+  # Return cleaned path with all dot components removed.
+  #
+  # No file system will accessed and not symlinks will be resolved.
+  #
+  # @example
+  #   Path('./file.txt').cleanpath
+  #   #=> <Path file.txt>
+  #
+  # @example
+  #   Path('path/to/another/../file/../../txt').cleanpath
+  #   #=> <Path path/txt>
+  #
+  # @return [Path] Cleaned path.
+  #
   def cleanpath
-    Path Pathname.new(self).cleanpath
+    path = Pathname.new(self).cleanpath
+    if path == internal_path
+      self
+    else
+      Path path
+    end
   end
 end

data/lib/rubypath/version.rb

@@ -1,8 +1,8 @@
 class Path
   module VERSION
     MAJOR = 0
-    MINOR = 2
-    PATCH = 1
+    MINOR = 3
+    PATCH = 0
     STAGE = nil
     STRING = [MAJOR, MINOR, PATCH, STAGE].reject(&:nil?).join('.').freeze
 

data/spec/rubypath/comparison_spec.rb

@@ -11,10 +11,20 @@ describe Path do
           expect(res).to be true
         end
 
-        it 'should compare paths (1)' do
+        it 'should compare paths (2)' do
           res = path.send described_method, Path('/path/to/another/file')
           expect(res).to be false
         end
+
+        it 'should compare clean paths (1)' do
+          res = path.send described_method, Path('/path/to/./file')
+          expect(res).to be true
+        end
+
+        it 'should compare clean paths (2)' do
+          res = path.send described_method, Path('/path/to/another/../file')
+          expect(res).to be true
+        end
       end
 
       context 'with String object' do
@@ -27,6 +37,16 @@ describe Path do
           res = path.send described_method, '/path/to/another/file'
           expect(res).to be false
         end
+
+        it 'should compare clean paths (1)' do
+          res = path.send described_method, '/path/to/./file'
+          expect(res).to be true
+        end
+
+        it 'should compare clean paths (2)' do
+          res = path.send described_method, '/path/to/another/../file'
+          expect(res).to be true
+        end
       end
 
       context 'with Pathname object' do
@@ -40,6 +60,17 @@ describe Path do
                           Pathname.new('/path/to/another/file')
           expect(res).to be false
         end
+
+        it 'should compare clean paths (1)' do
+          res = path.send described_method, Pathname.new('/path/to/./file')
+          expect(res).to be true
+        end
+
+        it 'should compare clean paths (2)' do
+          res = path.send described_method,
+                          Pathname.new('/path/to/another/../file')
+          expect(res).to be true
+        end
       end
     end
   end

data/spec/rubypath/dir_operations_spec.rb

@@ -39,6 +39,83 @@ describe Path do
         end
       end
 
+      shared_examples '#remove_recursive' do
+        context 'on existent file' do
+          before { path.mkfile }
+          it{ expect{ subject }.to change(path, :exist?).from(true).to(false) }
+        end
+
+        context 'on existent directory' do
+          before { path.mkpath }
+          it{ expect{ subject }.to change(path, :exist?).from(true).to(false) }
+        end
+
+        context 'on existent directory with children' do
+          before { path.mkfile('subdir/file') }
+          it{ expect{ subject }.to change(path, :exist?).from(true).to(false) }
+        end
+      end
+
+      describe_method :rmtree, aliases: [:rm_rf] do
+        let(:path) { Path '/path' }
+        subject { path.send(described_method) }
+
+        context 'on non-existent file' do
+          it { expect{ subject }.to_not raise_error }
+        end
+
+        it_behaves_like '#remove_recursive'
+      end
+
+      describe_method :safe_rmtree do
+        let(:path) { Path '/path' }
+        subject { path.send(described_method) }
+
+        it 'should use #remove_entry_secure' do
+          if backend_type == :sys
+            path.mkfile
+            expect(FileUtils).to receive(:remove_entry_secure).and_call_original
+            subject
+          end
+        end
+
+        context 'on non-existent file' do
+          it { expect{ subject }.to_not raise_error }
+        end
+
+        it_behaves_like '#remove_recursive'
+      end
+
+      describe_method :rmtree!, aliases: [:rm_r] do
+        let(:path) { Path '/path' }
+        subject { path.send(described_method) }
+
+        context 'on non-existent file' do
+          it { expect{ subject }.to raise_error Errno::ENOENT }
+        end
+
+        it_behaves_like '#remove_recursive'
+      end
+
+      describe_method :safe_rmtree! do
+        let(:path) { Path '/path' }
+        subject { path.send(described_method) }
+
+        it 'should use #remove_entry_secure' do
+          if backend_type == :sys
+            path.mkfile
+            expect(FileUtils).to receive(:remove_entry_secure).and_call_original
+            subject
+          end
+        end
+
+        context 'on non-existent file' do
+          it { expect{ subject }.to raise_error Errno::ENOENT }
+        end
+
+        it_behaves_like '#remove_recursive'
+      end
+
       describe '#glob' do
         it 'should delegate to class#glob' do
           expect(Path).to receive(:glob)
@@ -130,7 +207,7 @@ describe Path do
           end
 
           it 'should return list of Path objects' do
-            subject.each{|e| expect(e).to be_a Path }
+            subject.each{ |e| expect(e).to be_a Path }
           end
         end
 

data/spec/rubypath/file_operations_spec.rb

@@ -15,6 +15,45 @@ describe Path do
         end
       end
 
+      describe_method :unlink do
+        subject { path.send described_method }
+
+        context 'on non-existent file' do
+          it { expect{ subject }.to raise_error Errno::ENOENT }
+        end
+
+        context 'on existent file' do
+          before { path.mkfile }
+
+          it 'should unlink file' do
+            expect{ subject }.to change(path, :exist?).from(true).to(false)
+          end
+        end
+
+        context 'on existent directory' do
+          before { path.mkpath }
+
+          it { expect{ subject }.to raise_error Errno::EISDIR }
+        end
+
+        context 'with args' do
+          subject { path.send(described_method, 'file') }
+
+          context 'on non-existent file' do
+            it { expect{ subject }.to raise_error Errno::ENOENT }
+          end
+
+          context 'on existent file' do
+            before { path.mkfile('file') }
+
+            it 'should unlink file' do
+              expect{ subject }
+                .to change(path.join('file'), :exist?).from(true).to(false)
+            end
+          end
+        end
+      end
+
       describe_method :touch do
         let(:path) { Path '/rubypath' }
         let(:args) { Array.new }

data/spec/rubypath/identity_spec.rb

@@ -4,7 +4,7 @@ describe Path do
   describe 'Identity' do
     let(:str)  { '/path/to/file' }
     let(:args) { [str] }
-    let(:path) { described_class.new *args }
+    let(:path) { described_class.new(*args) }
     subject { path }
 
     describe_method :path, aliases: [:to_path, :to_str, :to_s] do

data/spec/rubypath/path_operations_spec.rb

@@ -8,7 +8,7 @@ describe Path do
     subject { path }
 
     describe_method :join do
-      subject { path.send described_method, *join_args}
+      subject { path.send(described_method, *join_args) }
 
       context 'with single string' do
         let(:join_args) { ['to/file.txt'] }
@@ -36,6 +36,35 @@ describe Path do
       end
     end
 
+    describe_method :cleanpath do
+      subject { path.send(described_method) }
+
+      context 'with out dot components' do
+        let(:path) { Path 'path/to/file.txt' }
+        it { should eq 'path/to/file.txt' }
+      end
+
+      context 'with leading dot' do
+        let(:path) { Path './file.txt' }
+        it { should eq 'file.txt' }
+      end
+
+      context 'with including dot' do
+        let(:path) { Path 'path/to/./file.txt' }
+        it { should eq 'path/to/file.txt' }
+      end
+
+      context 'with double dot' do
+        let(:path) { Path 'path/to/../file.txt' }
+        it { should eq 'path/file.txt' }
+      end
+
+      context 'with multiple dots' do
+        let(:path) { Path 'path/to/../../opath/to/./../file.txt' }
+        it { should eq 'opath/file.txt' }
+      end
+    end
+
     describe_method :each_component do
       let(:block) { nil }
       let(:opts) { Hash.new }
@@ -52,17 +81,17 @@ describe Path do
         let(:opts) { {empty: true} }
 
         it 'should also return empty path components' do
-          expect(subject.to_a).to eq ([''] + %w(path to templates dir) + [''])
+          expect(subject.to_a).to eq([''] + %w(path to templates dir) + [''])
         end
       end
 
       context 'with block' do
-        let(:block) { proc{|fn| fn} }
+        let(:block) { proc{|fn| fn } }
 
         it 'should yield components' do
-          expect {|b|
+          expect do |b|
             path.send described_method, &b
-          }.to yield_successive_args(*%w(path to templates dir))
+          end.to yield_successive_args(*%w(path to templates dir))
         end
 
         it { should eq path }
@@ -80,7 +109,8 @@ describe Path do
     describe_method :dirname, aliases: [:parent] do
       shared_examples 'dirname' do
         it 'should return parent directory' do
-          expect(Path(base, 'path/to/file').send(described_method)).to eq "#{base}path/to"
+          expect(Path(base, 'path/to/file').send(described_method))
+            .to eq "#{base}path/to"
         end
 
         context 'when hitting root' do
@@ -108,7 +138,8 @@ describe Path do
     end
 
     with_backends :mock, :sys do
-      describe_method :expand, aliases: [:expand_path, :absolute, :absolute_path] do
+      describe_method :expand, aliases: [:expand_path,
+                                         :absolute, :absolute_path] do
         let(:cwd) { '/working/dir' }
         let(:base) { cwd }
         let(:args) { Array.new }
@@ -120,7 +151,7 @@ describe Path do
           end
         end
 
-        around{|example| Path::Backend.mock &example }
+        around{|example| Path::Backend.mock(&example) }
 
         shared_examples '#expand' do
           subject { Path(path).send(described_method, *args) }
@@ -311,11 +342,13 @@ describe Path do
           it { should eq path }
 
           it 'should yield part paths' do
-            expect{|b| path.send described_method, &b }.to yield_successive_args *expected_paths
+            expect{|b| path.send(described_method, &b) }
+              .to yield_successive_args(*expected_paths)
           end
 
           it 'should yield Path objects' do
-            expect{|b| path.send described_method, &b }.to yield_successive_args *expected_paths.map{ Path }
+            expect{|b| path.send(described_method, &b) }
+              .to yield_successive_args(*expected_paths.map{ Path })
           end
         end
 
@@ -325,24 +358,26 @@ describe Path do
           it { should be_a Enumerator }
 
           it 'should yield part paths' do
-            expect{|b| subject.each &b }.to yield_successive_args *expected_paths
+            expect{|b| subject.each(&b) }
+              .to yield_successive_args(*expected_paths)
           end
 
           it 'should yield path objects' do
-            expect{|b| subject.each &b }.to yield_successive_args *expected_paths.map{ Path }
+            expect{|b| subject.each(&b) }
+              .to yield_successive_args(*expected_paths.map{ Path })
           end
         end
       end
 
       context 'with absolute path' do
         let(:path) { Path '/path/to/file.txt' }
-        let(:expected_paths) { %w(/path/to/file.txt /path/to /path /)}
+        let(:expected_paths) { %w(/path/to/file.txt /path/to /path /) }
         it_behaves_like 'ascend'
       end
 
       context 'with relative path' do
         let(:path) { Path 'path/to/file.txt' }
-        let(:expected_paths) { %w(path/to/file.txt path/to path .)}
+        let(:expected_paths) { %w(path/to/file.txt path/to path .) }
         it_behaves_like 'ascend'
       end
     end

data/spec/support/with_backend.rb

@@ -1,15 +1,17 @@
+#
 module WithBackend
-
   def with_backends(*args, &block)
     args.each do |backend|
       be = case backend
-      when :mock
-        lambda { |ex| Path::Backend.mock &ex }
-      when :sys
-        lambda { |ex| Path::Backend.mock(root: :tmp, &ex) }
-      else
-        raise ArgumentError.new 'Unknown backend.'
-      end
+             when :mock
+               ->(ex){ Path::Backend.mock(&ex) }
+             when :sys
+               ->(ex){ Path::Backend.mock(root: :tmp, &ex) }
+             else
+               raise ArgumentError.new 'Unknown backend.'
+           end
+
+      next if ENV["FS_#{backend.upcase}"] == '0'
 
       describe "with #{backend.upcase} FS" do
         let(:backend_type) { backend }
@@ -17,15 +19,19 @@ module WithBackend
           be.call(example)
         end
 
-        module_eval &block
+        module_eval(&block)
       end
     end
   end
   alias_method :with_backend, :with_backends
 
   def pending_backend(*args)
-    before { pending "Pending on #{backend_type} backend." if args.include? backend_type }
+    before do
+      if args.include? backend_type
+        pending "Pending on #{backend_type} backend."
+      end
+    end
   end
 
-  RSpec.configure{|c| c.extend WithBackend }
+  RSpec.configure{ |c| c.extend WithBackend }
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubypath
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Jan Graichen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-24 00:00:00.000000000 Z
+date: 2014-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler