Changing API to maintain consistency

Fixes #30, #26

Make Join(...) less opinionated

Making Join() simpler so that it simply uses strings.Join() to join the
paths together. This will help with really weird cases where cleaning
the resulting path might create an incorrect result.

I am creating a Clean() function that will allow people to still clean
the path if they really want. We shouldn't enforce people to use it.

Fixing test

Author: LandonTClipp

path.go

@@ -158,8 +158,8 @@ func (p *Path) RemoveAll() error {
 	return p.Fs().RemoveAll(p.String())
 }
 
-// Rename renames a file
-func (p *Path) Rename(newname string) error {
+// RenameStr renames a file
+func (p *Path) RenameStr(newname string) error {
 	if err := p.Fs().Rename(p.String(), newname); err != nil {
 		return err
 	}
@@ -169,10 +169,9 @@ func (p *Path) Rename(newname string) error {
 	return nil
 }
 
-// RenamePath is the same as Rename except the argument is a Path object. The attributes
-// of the path object is retained and does not inherit anything from target.
-func (p *Path) RenamePath(target *Path) error {
-	return p.Rename(target.String())
+// Rename renames a file
+func (p *Path) Rename(target *Path) error {
+	return p.RenameStr(target.String())
 }
 
 // Stat returns the os.FileInfo of the given path
@@ -392,7 +391,7 @@ func (p *Path) Join(elems ...string) *Path {
 	for _, path := range elems {
 		paths = append(paths, path)
 	}
-	return NewPathAfero(filepath.Join(paths...), p.Fs())
+	return NewPathAfero(strings.Join(paths, p.Sep), p.Fs())
 }
 
 // JoinPath is the same as Join() except it accepts a path object
@@ -451,6 +450,13 @@ func (p *Path) RelativeTo(other *Path) (*Path, error) {
 	return NewPathAfero(strings.Join(relativePath, "/"), p.Fs()), nil
 }
 
+// RelativeToStr computes a relative version of path to the other path. For instance,
+// if the object is /path/to/foo.txt and you provide /path/ as the argment, the
+// returned Path object will represent to/foo.txt.
+func (p *Path) RelativeToStr(other string) (*Path, error) {
+	return p.RelativeTo(NewPathAfero(other, p.Fs()))
+}
+
 // Lstat lstat's the path if the underlying afero filesystem supports it. If
 // the filesystem does not support afero.Lstater, or if the filesystem implements
 // afero.Lstater but returns false for the "lstat called" return value.
@@ -474,6 +480,14 @@ func (p *Path) Lstat() (os.FileInfo, error) {
 // * filesystem-specific functions *
 // *********************************
 
+// SymlinkStr symlinks to the target location. This will fail if the underlying
+// afero filesystem does not implement afero.Linker.
+//
+// THIS METHOD IS NOT TYPE SAFE.
+func (p *Path) SymlinkStr(target string) error {
+	return p.Symlink(NewPathAfero(target, p.Fs()))
+}
+
 // Symlink symlinks to the target location. This will fail if the underlying
 // afero filesystem does not implement afero.Linker.
 //
@@ -539,7 +553,7 @@ func (p *Path) DeepEquals(other *Path) (bool, error) {
 		return false, err
 	}
 
-	return selfResolved.Equals(otherResolved), nil
+	return selfResolved.Clean().Equals(otherResolved.Clean()), nil
 }
 
 // Equals returns whether or not the object's path is identical
@@ -589,6 +603,12 @@ func (p *Path) Glob(pattern string) ([]*Path, error) {
 	return Glob(p.Fs(), p.Join(pattern).String())
 }
 
+// Clean returns a new object that is a lexically-cleaned
+// version of Path.
+func (p *Path) Clean() *Path {
+	return NewPathAfero(filepath.Clean(p.String()), p.Fs())
+}
+
 // Mtime returns the modification time of the given path.
 func (p *Path) Mtime() (time.Time, error) {
 	stat, err := p.Stat()

path_test.go

@@ -118,7 +118,7 @@ func (p *PathSuite) TestRenameString() {
 
 	newPath := p.tmpdir.Join("file2.txt")
 
-	err := file.RenamePath(newPath)
+	err := file.Rename(newPath)
 	assert.NoError(p.T(), err)
 	assert.Equal(p.T(), file.String(), p.tmpdir.Join("file2.txt").String())
 
@@ -265,15 +265,20 @@ func (p *PathSuite) TestIsSymlink() {
 }
 
 func (p *PathSuite) TestResolveAll() {
-	require.NoError(p.T(), p.tmpdir.Join("mnt", "nfs", "data", "users", "home", "LandonTClipp").MkdirAll())
+	home := p.tmpdir.Join("mnt", "nfs", "data", "users", "home", "LandonTClipp")
+	require.NoError(p.T(), home.MkdirAll())
 	require.NoError(p.T(), p.tmpdir.Join("mnt", "nfs", "symlinks").MkdirAll())
 	require.NoError(p.T(), p.tmpdir.Join("mnt", "nfs", "symlinks", "home").Symlink(NewPath("../data/users/home")))
 	require.NoError(p.T(), p.tmpdir.Join("home").Symlink(NewPath("./mnt/nfs/symlinks/home")))
 
 	resolved, err := p.tmpdir.Join("home/LandonTClipp").ResolveAll()
-	p.NoError(err)
-	resolvedParts := resolved.Parts()
-	p.Equal("mnt/nfs/data/users/home/LandonTClipp", strings.Join(resolvedParts[len(resolvedParts)-6:], resolved.Sep))
+	p.T().Log(resolved.String())
+	require.NoError(p.T(), err)
+
+	homeResolved, err := home.ResolveAll()
+	require.NoError(p.T(), err)
+
+	p.Equal(homeResolved.Clean().String(), resolved.Clean().String())
 }
 
 func (p *PathSuite) TestResolveAllAbsolute() {
@@ -396,7 +401,7 @@ func TestPath_Join(t *testing.T) {
 			a := afero.NewMemMapFs()
 			p := NewPathAfero(tt.fields, a)
 			want := NewPathAfero(tt.want, a)
-			if got := p.Join(tt.args.elems...); !reflect.DeepEqual(got, want) {
+			if got := p.Join(tt.args.elems...).Clean(); !reflect.DeepEqual(got, want) {
 				t.Errorf("Path.Join() = %v, want %v", got, want)
 			}
 		})