Merge pull request #5 from tarsana/absolute-paths-detection

no need to specify if the path is absolute or relative

Author: webNeat

README.md

@@ -3,6 +3,7 @@
 [![Build Status](https://travis-ci.org/tarsana/io.svg?branch=master)](https://travis-ci.org/tarsana/io)
 [![Coverage Status](https://coveralls.io/repos/github/tarsana/io/badge.svg?branch=master)](https://coveralls.io/github/tarsana/io?branch=master)
 [![SensioLabsInsight](https://insight.sensiolabs.com/projects/63923f3f-955d-4058-bbd0-4730639709d4/mini.png)](https://insight.sensiolabs.com/projects/63923f3f-955d-4058-bbd0-4730639709d4)
+[![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://paypal.me/webneat)
 [![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)](https://github.com/tarsana/io/blob/master/LICENSE)
 
 Simple classes to handle Input/Output operations.
@@ -29,27 +30,27 @@ $fs = new Tarsana\IO\Filesystem('path/to/fs/root/directory');
 Maybe you need to check if a specific path is a file
 
 ```php
-if ($fs->isFile('relative/path'))
+if ($fs->isFile('path'))
 ```
 
 or a directory
 
 ```php
-if ($fs->isDir('relative/path'))
+if ($fs->isDir('path'))
 ```
 
 or you just want to know it exists, no matter it's a file or directory
 
 ```php
-if ($fs->isAny('relative/path'))
+if ($fs->isAny('path'))
 ```
 
 What if you need to check multiple paths at once ?
 
 ```php
-if ($fs->areFiles(['relative/path1', 'relative/path2', 'relative/path3']))
-if ($fs->areDirs(['relative/path1', 'relative/path2', 'relative/path3']))
-if ($fs->areAny(['relative/path1', 'relative/path2', 'relative/path3']))
+if ($fs->areFiles(['path1', 'path2', 'path3']))
+if ($fs->areDirs(['path1', 'path2', 'path3']))
+if ($fs->areAny(['path1', 'path2', 'path3']))
 ```
 
 But what if you want to know the type of a path without having to do multiple checks ?
@@ -103,22 +104,22 @@ $collection->names(); // array of names of the files and directories
 Well, to handle a file, you should get it first
 
 ```php
-$file = $fs->file('relative/path/to/file');
+$file = $fs->file('path/to/file');
 ```
 
 Notice that this will throw an exception if the file is not found. If you want to create it when missing; specify `true` in the second argument
 
 ```php
-$file = $fs->file('relative/path/to/file', true);
+$file = $fs->file('path/to/file', true);
 ```
 
 You can also get or create multiple files at once
 
 ```php
 $files = $fs->files([
-	'relative/path/to/file1',
-	'relative/path/to/file2',
-	'relative/path/to/file3'
+	'path/to/file1',
+	'path/to/file2',
+	'path/to/file3'
 ]); // specify the second argument as true if you want missing files to be created
 
 foreach ($files->asArray() as $file) {
@@ -157,12 +158,12 @@ Notice that all setters return the same instance to enable call chaining.
 Just like the file, you can get a directory like that
 
 ```php
-$dir = $fs->dir('relative/path/to/dir'); // throws exception if the directory not found
-$dir = $fs->dir('relative/path/to/dir', true); // creates the directory if not found
+$dir = $fs->dir('path/to/dir'); // throws exception if the directory not found
+$dir = $fs->dir('path/to/dir', true); // creates the directory if not found
 $dirs = $fs->dirs([
-	'relative/path/to/file1',
-	'relative/path/to/file2',
-	'relative/path/to/file3'
+	'path/to/file1',
+	'path/to/file2',
+	'path/to/file3'
 ]); // a collection containing directories
 ```
 

src/Filesystem.php

@@ -73,12 +73,11 @@ public function adapter()
      * if there are multiple matches and 'nothing' if no match found.
      *
      * @param  string  $pattern
-     * @param  boolean $isAbsolute
      * @return string
      */
-    public function whatIs($pattern, $isAbsolute = false)
+    public function whatIs($pattern)
     {
-        if (! $isAbsolute) {
+        if (! $this->adapter->isAbsolute($pattern)) {
             $pattern = $this->rootPath . $pattern;
         }
 
@@ -95,13 +94,12 @@ public function whatIs($pattern, $isAbsolute = false)
      * Checks if the given path is of the given type.
      *
      * @param  string  $path
-     * @param  boolean $isAbsolute
      * @param  string  $type
      * @return boolean
      */
-    protected function is($path, $isAbsolute, $type)
+    protected function is($path, $type)
     {
-        if (! $isAbsolute) {
+        if (! $this->adapter->isAbsolute($path)) {
             $path = $this->rootPath . $path;
         }
         switch ($type) {
@@ -126,14 +124,13 @@ protected function is($path, $isAbsolute, $type)
      * Checks if the given paths are all of the given type.
      *
      * @param  array   $paths
-     * @param  boolean $areAbsolute
      * @param  string  $type
      * @return boolean
      */
-    protected function are($paths, $areAbsolute, $type)
+    protected function are($paths, $type)
     {
         foreach ($paths as $path) {
-            if (! $this->is($path, $areAbsolute, $type)) {
+            if (! $this->is($path, $type)) {
                 return false;
             }
         }
@@ -144,145 +141,133 @@ protected function are($paths, $areAbsolute, $type)
      * Checks if the given path is a file.
      *
      * @param  string  $path
-     * @param  boolean $isAbsolute
      * @return boolean
      */
-    public function isFile($path, $isAbsolute = false)
+    public function isFile($path)
     {
-        return $this->is($path, $isAbsolute, 'file');
+        return $this->is($path, 'file');
     }
 
     /**
      * Checks if all the given path are files.
      *
      * @param  array   $paths
-     * @param  boolean $areAbsolute
      * @return boolean
      */
-    public function areFiles($paths, $areAbsolute = false)
+    public function areFiles($paths)
     {
-        return $this->are($paths, $areAbsolute, 'file');
+        return $this->are($paths, 'file');
     }
 
     /**
      * Checks if the given path is a directory.
      *
      * @param  string  $path
-     * @param  boolean $isAbsolute
      * @return boolean
      */
-    public function isDir($path, $isAbsolute = false)
+    public function isDir($path)
     {
-        return $this->is($path, $isAbsolute, 'dir');
+        return $this->is($path, 'dir');
     }
 
     /**
      * Checks if all the given paths are directories.
      *
      * @param  array   $paths
-     * @param  boolean $areAbsolute
      * @return boolean
      */
-    public function areDirs($paths, $areAbsolute = false)
+    public function areDirs($paths)
     {
-        return $this->are($paths, $areAbsolute, 'dir');
+        return $this->are($paths, 'dir');
     }
 
     /**
      * Checks if the given path is a file or directory.
      *
      * @param  string  $path
-     * @param  boolean $isAbsolute
      * @return boolean
      */
-    public function isAny($path, $isAbsolute = false)
+    public function isAny($path)
     {
-        return $this->is($path, $isAbsolute, 'any');
+        return $this->is($path, 'any');
     }
 
     /**
      * Checks if all the given paths are files or directories.
      *
      * @param  array   $paths
-     * @param  boolean $areAbsolute
      * @return boolean
      */
-    public function areAny($paths, $areAbsolute = false)
+    public function areAny($paths)
     {
-        return $this->are($paths, $areAbsolute, 'any');
+        return $this->are($paths, 'any');
     }
 
     /**
      * Checks if the given path is readable.
      *
      * @param  string  $path
-     * @param  boolean $isAbsolute
      * @return boolean
      */
-    public function isReadable($path, $isAbsolute = false)
+    public function isReadable($path)
     {
-        return $this->is($path, $isAbsolute, 'readable');
+        return $this->is($path, 'readable');
     }
 
     /**
      * Checks if all the given paths are readable.
      *
      * @param  string  $paths
-     * @param  boolean $areAbsolute
      * @return boolean
      */
-    public function areReadable($paths, $areAbsolute = false)
+    public function areReadable($paths)
     {
-        return $this->are($paths, $areAbsolute, 'readable');
+        return $this->are($paths, 'readable');
     }
 
     /**
      * Checks if the given path is writable.
      *
      * @param  string  $path
-     * @param  boolean $isAbsolute
      * @return boolean
      */
-    public function isWritable($path, $isAbsolute = false)
+    public function isWritable($path)
     {
-        return $this->is($path, $isAbsolute, 'writable');
+        return $this->is($path, 'writable');
     }
 
     /**
      * Checks if all the given paths are writable.
-        return $this->are($paths, $areAbsolute, 'readable');
+        return $this->are($paths, 'readable');
      *
      * @param  string  $paths
-     * @param  boolean $areAbsolute
      * @return boolean
      */
-    public function areWritable($paths, $areAbsolute = false)
+    public function areWritable($paths)
     {
-        return $this->are($paths, $areAbsolute, 'writable');
+        return $this->are($paths, 'writable');
     }
 
     /**
      * Checks if the given path is executable.
      *
      * @param  string  $path
-     * @param  boolean $isAbsolute
      * @return boolean
      */
-    public function isExecutable($path, $isAbsolute = false)
+    public function isExecutable($path)
     {
-        return $this->is($path, $isAbsolute, 'executable');
+        return $this->is($path, 'executable');
     }
 
     /**
      * Checks if all the given paths are executable.
      *
      * @param  string  $paths
-     * @param  boolean $areAbsolute
      * @return boolean
      */
-    public function areExecutable($paths, $areAbsolute = false)
+    public function areExecutable($paths)
     {
-        return $this->are($paths, $areAbsolute, 'executable');
+        return $this->are($paths, 'executable');
     }
 
     /**
@@ -291,14 +276,13 @@ public function areExecutable($paths, $areAbsolute = false)
      *
      * @param  string  $path
      * @param  boolean $createMissing
-     * @param  boolean $isAbsolute
      * @return Tarsana\IO\Filesystem\File
      *
      * @throws Tarsana\IO\Exceptions\FilesystemException
      */
-    public function file($path, $createMissing = false, $isAbsolute = false)
+    public function file($path, $createMissing = false)
     {
-        if (! $isAbsolute) {
+        if (! $this->adapter->isAbsolute($path)) {
             $path = $this->rootPath . $path;
         }
         if (! $createMissing && ! $this->isFile($path, true)) {
@@ -337,14 +321,13 @@ public function files($paths = false, $createMissing = false)
      *
      * @param  string  $path
      * @param  boolean $createMissing
-     * @param  boolean $isAbsolute
      * @return Tarsana\IO\Filesystem\Directory
      *
      * @throws Tarsana\IO\Exceptions\FilesystemException
      */
-    public function dir($path, $createMissing = false, $isAbsolute = false)
+    public function dir($path, $createMissing = false)
     {
-        if (! $isAbsolute) {
+        if (! $this->adapter->isAbsolute($path)) {
             $path = $this->rootPath . $path;
         }
         if (! $createMissing && ! $this->isDir($path, true)) {
@@ -381,12 +364,11 @@ public function dirs($paths = false, $createMissing = false)
      * and returns a collection containing them.
      *
      * @param  string  $pattern
-     * @param  boolean $isAbsolute
      * @return Tarsana\IO\Filesystem\Collection
      */
-    public function find($pattern, $isAbsolute = false)
+    public function find($pattern)
     {
-        if (! $isAbsolute) {
+        if (! $this->adapter->isAbsolute($pattern)) {
             $pattern = $this->rootPath . $pattern;
         }
         $list = new Collection;
@@ -404,12 +386,11 @@ public function find($pattern, $isAbsolute = false)
      * Removes a file or directory recursively.
      *
      * @param  string  $path
-     * @param  boolean $isAbsolute
      * @return Tarsana\IO\Filesystem
      */
-    public function remove($path, $isAbsolute = false)
+    public function remove($path)
     {
-        if (! $isAbsolute) {
+        if (! $this->adapter->isAbsolute($path)) {
             $path = $this->rootPath . $path;
         }
         if ($this->isFile($path, true)) {
@@ -430,13 +411,12 @@ public function remove($path, $isAbsolute = false)
      * Removes an array of files or directories.
      *
      * @param  array   $paths
-     * @param  boolean $areAbsolute
      * @return Tarsana\IO\Filesystem
      */
-    public function removeAll($paths, $areAbsolute = false)
+    public function removeAll($paths)
     {
         foreach ($paths as $path) {
-            $this->remove($path, $areAbsolute);
+            $this->remove($path);
         }
         return $this;
     }