Replaced hscommon.path with pathlib

Removed hscommon.path and hscommon.io and adapted the
rest of hscommon's code to make tests pass.

hscommon/tests/conflict_test.py

@@ -6,8 +6,8 @@
 # which should be included with this package. The terms are also available at 
 # http://www.hardcoded.net/licenses/bsd_license
 
+from pathlib import Path
 from ..conflict import *
-from ..path import Path
 from ..testutil import eq_
 
 class TestCase_GetConflictedName:
@@ -61,44 +61,44 @@ class TestCase_move_copy:
     def pytest_funcarg__do_setup(self, request):
         tmpdir = request.getfuncargvalue('tmpdir')
         self.path = Path(str(tmpdir))
-        io.open(self.path + 'foo', 'w').close()
-        io.open(self.path + 'bar', 'w').close()
-        io.mkdir(self.path + 'dir')
+        self.path['foo'].touch()
+        self.path['bar'].touch()
+        self.path['dir'].mkdir()
     
     def test_move_no_conflict(self, do_setup):
-        smart_move(self.path + 'foo', self.path + 'baz')
-        assert io.exists(self.path + 'baz')
-        assert not io.exists(self.path + 'foo')
+        smart_move(self.path['foo'], self.path['baz'])
+        assert self.path['baz'].exists()
+        assert not self.path['foo'].exists()
     
     def test_copy_no_conflict(self, do_setup): # No need to duplicate the rest of the tests... Let's just test on move
-        smart_copy(self.path + 'foo', self.path + 'baz')
-        assert io.exists(self.path + 'baz')
-        assert io.exists(self.path + 'foo')
+        smart_copy(self.path['foo'], self.path['baz'])
+        assert self.path['baz'].exists()
+        assert self.path['foo'].exists()
     
     def test_move_no_conflict_dest_is_dir(self, do_setup):
-        smart_move(self.path + 'foo', self.path + 'dir')
-        assert io.exists(self.path + ('dir', 'foo'))
-        assert not io.exists(self.path + 'foo')
+        smart_move(self.path['foo'], self.path['dir'])
+        assert self.path['dir/foo'].exists()
+        assert not self.path['foo'].exists()
     
     def test_move_conflict(self, do_setup):
-        smart_move(self.path + 'foo', self.path + 'bar')
-        assert io.exists(self.path + '[000] bar')
-        assert not io.exists(self.path + 'foo')
+        smart_move(self.path['foo'], self.path['bar'])
+        assert self.path['[000] bar'].exists()
+        assert not self.path['foo'].exists()
     
     def test_move_conflict_dest_is_dir(self, do_setup):
-        smart_move(self.path + 'foo', self.path + 'dir')
-        smart_move(self.path + 'bar', self.path + 'foo')
-        smart_move(self.path + 'foo', self.path + 'dir')
-        assert io.exists(self.path + ('dir', 'foo'))
-        assert io.exists(self.path + ('dir', '[000] foo'))
-        assert not io.exists(self.path + 'foo')
-        assert not io.exists(self.path + 'bar')
+        smart_move(self.path['foo'], self.path['dir'])
+        smart_move(self.path['bar'], self.path['foo'])
+        smart_move(self.path['foo'], self.path['dir'])
+        assert self.path['dir/foo'].exists()
+        assert self.path['dir/[000] foo'].exists()
+        assert not self.path['foo'].exists()
+        assert not self.path['bar'].exists()
     
     def test_copy_folder(self, tmpdir):
         # smart_copy also works on folders
         path = Path(str(tmpdir))
-        io.mkdir(path + 'foo')
-        io.mkdir(path + 'bar')
-        smart_copy(path + 'foo', path + 'bar') # no crash
-        assert io.exists(path + '[000] bar')
+        path['foo'].mkdir()
+        path['bar'].mkdir()
+        smart_copy(path['foo'], path['bar']) # no crash
+        assert path['[000] bar'].exists()
     

hscommon/tests/currency_test.py

@@ -9,7 +9,6 @@
 from datetime import date
 import sqlite3 as sqlite
 
-from .. import io
 from ..testutil import eq_, assert_almost_equal
 from ..currency import Currency, RatesDB, CAD, EUR, USD
 
@@ -64,7 +63,7 @@ def test_db_with_connection():
 
 def test_corrupt_db(tmpdir):
     dbpath = str(tmpdir.join('foo.db'))
-    fh = io.open(dbpath, 'w')
+    fh = open(dbpath, 'w')
     fh.write('corrupted')
     fh.close()
     db = RatesDB(dbpath) # no crash. deletes the old file and start a new db

hscommon/tests/path_test.py

@@ -1,209 +0,0 @@
-# Created By: Virgil Dupras
-# Created On: 2006/02/21
-# Copyright 2013 Hardcoded Software (http://www.hardcoded.net)
-
-# This software is licensed under the "BSD" License as described in the "LICENSE" file, 
-# which should be included with this package. The terms are also available at 
-# http://www.hardcoded.net/licenses/bsd_license
-
-import sys
-
-from pytest import raises, mark
-
-from ..path import *
-from ..testutil import eq_
-
-def pytest_funcarg__force_ossep(request):
-    monkeypatch = request.getfuncargvalue('monkeypatch')
-    monkeypatch.setattr(os, 'sep', '/')
-
-def test_empty(force_ossep):
-    path = Path('')
-    eq_('',str(path))
-    eq_(0,len(path))
-    path = Path(())
-    eq_('',str(path))
-    eq_(0,len(path))
-
-def test_single(force_ossep):
-    path = Path('foobar')
-    eq_('foobar',path)
-    eq_(1,len(path))
-
-def test_multiple(force_ossep):
-    path = Path('foo/bar')
-    eq_('foo/bar',path)
-    eq_(2,len(path))
-
-def test_init_with_tuple_and_list(force_ossep):
-    path = Path(('foo','bar'))
-    eq_('foo/bar',path)
-    path = Path(['foo','bar'])
-    eq_('foo/bar',path)
-
-def test_init_with_invalid_value(force_ossep):
-    try:
-        path = Path(42)
-        self.fail()
-    except TypeError:
-        pass
-
-def test_access(force_ossep):
-    path = Path('foo/bar/bleh')
-    eq_('foo',path[0])
-    eq_('foo',path[-3])
-    eq_('bar',path[1])
-    eq_('bar',path[-2])
-    eq_('bleh',path[2])
-    eq_('bleh',path[-1])
-
-def test_slicing(force_ossep):
-    path = Path('foo/bar/bleh')
-    subpath = path[:2]
-    eq_('foo/bar',subpath)
-    assert isinstance(subpath,Path)
-
-def test_deal_with_empty_components(force_ossep):
-    """Keep ONLY a leading space, which means we want a leading slash.
-    """
-    eq_('foo//bar',str(Path(('foo','','bar'))))
-    eq_('/foo/bar',str(Path(('','foo','bar'))))
-    eq_('foo/bar',str(Path('foo/bar/')))
-
-def test_old_compare_paths(force_ossep):
-    eq_(Path('foobar'),Path('foobar'))
-    eq_(Path('foobar/'),Path('foobar\\','\\'))
-    eq_(Path('/foobar/'),Path('\\foobar\\','\\'))
-    eq_(Path('/foo/bar'),Path('\\foo\\bar','\\'))
-    eq_(Path('/foo/bar'),Path('\\foo\\bar\\','\\'))
-    assert Path('/foo/bar') != Path('\\foo\\foo','\\')
-    #We also have to test __ne__
-    assert not (Path('foobar') != Path('foobar'))
-    assert Path('/a/b/c.x') != Path('/a/b/c.y')
-
-def test_old_split_path(force_ossep):
-    eq_(Path('foobar'),('foobar',))
-    eq_(Path('foo/bar'),('foo','bar'))
-    eq_(Path('/foo/bar/'),('','foo','bar'))
-    eq_(Path('\\foo\\bar','\\'),('','foo','bar'))
-
-def test_representation(force_ossep):
-    eq_("('foo', 'bar')",repr(Path(('foo','bar'))))
-
-def test_add(force_ossep):
-    eq_('foo/bar/bar/foo',Path(('foo','bar')) + Path('bar/foo'))
-    eq_('foo/bar/bar/foo',Path('foo/bar') + 'bar/foo')
-    eq_('foo/bar/bar/foo',Path('foo/bar') + ('bar','foo'))
-    eq_('foo/bar/bar/foo',('foo','bar') + Path('bar/foo'))
-    eq_('foo/bar/bar/foo','foo/bar' + Path('bar/foo'))
-    #Invalid concatenation
-    try:
-        Path(('foo','bar')) + 1
-        self.fail()
-    except TypeError:
-        pass
-
-def test_path_slice(force_ossep):
-    foo = Path('foo')
-    bar = Path('bar')
-    foobar = Path('foo/bar')
-    eq_('bar',foobar[foo:])
-    eq_('foo',foobar[:bar])
-    eq_('foo/bar',foobar[bar:])
-    eq_('foo/bar',foobar[:foo])
-    eq_((),foobar[foobar:])
-    eq_((),foobar[:foobar])
-    abcd = Path('a/b/c/d')
-    a = Path('a')
-    b = Path('b')
-    c = Path('c')
-    d = Path('d')
-    z = Path('z')
-    eq_('b/c',abcd[a:d])
-    eq_('b/c/d',abcd[a:d+z])
-    eq_('b/c',abcd[a:z+d])
-    eq_('a/b/c/d',abcd[:z])
-
-def test_add_with_root_path(force_ossep):
-    """if I perform /a/b/c + /d/e/f, I want /a/b/c/d/e/f, not /a/b/c//d/e/f
-    """
-    eq_('/foo/bar',str(Path('/foo') + Path('/bar')))
-
-def test_create_with_tuple_that_have_slash_inside(force_ossep, monkeypatch):
-    eq_(('','foo','bar'), Path(('/foo','bar')))
-    monkeypatch.setattr(os, 'sep', '\\')
-    eq_(('','foo','bar'), Path(('\\foo','bar')))
-
-def test_auto_decode_os_sep(force_ossep, monkeypatch):
-    """Path should decode any either / or os.sep, but always encode in os.sep.
-    """
-    eq_(('foo\\bar','bleh'),Path('foo\\bar/bleh'))
-    monkeypatch.setattr(os, 'sep', '\\')
-    eq_(('foo','bar/bleh'),Path('foo\\bar/bleh'))
-    path = Path('foo/bar')
-    eq_(('foo','bar'),path)
-    eq_('foo\\bar',str(path))
-
-def test_contains(force_ossep):
-    p = Path(('foo','bar'))
-    assert Path(('foo','bar','bleh')) in p
-    assert Path(('foo','bar')) in p
-    assert 'foo' in p
-    assert 'bleh' not in p
-    assert Path('foo') not in p
-
-def test_windows_drive_letter(force_ossep):
-    p = Path(('c:',))
-    eq_('c:\\',str(p))
-
-def test_root_path(force_ossep):
-    p = Path('/')
-    eq_('/',str(p))
-
-def test_str_encodes_unicode_to_getfilesystemencoding(force_ossep):
-    p = Path(('foo','bar\u00e9'))
-    eq_('foo/bar\u00e9'.encode(sys.getfilesystemencoding()), p.tobytes())
-
-def test_unicode(force_ossep):
-    p = Path(('foo','bar\u00e9'))
-    eq_('foo/bar\u00e9',str(p))
-
-def test_str_repr_of_mix_between_non_ascii_str_and_unicode(force_ossep):
-    u = 'foo\u00e9'
-    encoded = u.encode(sys.getfilesystemencoding())
-    p = Path((encoded,'bar'))
-    print(repr(tuple(p)))
-    eq_('foo\u00e9/bar'.encode(sys.getfilesystemencoding()), p.tobytes())
-
-def test_Path_of_a_Path_returns_self(force_ossep):
-    #if Path() is called with a path as value, just return value.
-    p = Path('foo/bar')
-    assert Path(p) is p
-
-@mark.xfail(reason="pytest's capture mechanism is flaky, I have to investigate")
-def test_log_unicode_errors(force_ossep, monkeypatch, capsys):
-    # When an there's a UnicodeDecodeError on path creation, log it so it can be possible
-    # to debug the cause of it.
-    monkeypatch.setattr(sys, 'getfilesystemencoding', lambda: 'ascii')
-    with raises(UnicodeDecodeError):
-        Path(['', b'foo\xe9'])
-    out, err = capsys.readouterr()
-    assert repr(b'foo\xe9') in err
-
-def test_has_drive_letter(monkeypatch):
-    monkeypatch.setattr(os, 'sep', '\\')
-    p = Path('foo\\bar')
-    assert not p.has_drive_letter()
-    p = Path('C:\\')
-    assert p.has_drive_letter()
-    p = Path('z:\\foo')
-    assert p.has_drive_letter()
-
-def test_remove_drive_letter(monkeypatch):
-    monkeypatch.setattr(os, 'sep', '\\')
-    p = Path('foo\\bar')
-    eq_(p.remove_drive_letter(), Path('foo\\bar'))
-    p = Path('C:\\')
-    eq_(p.remove_drive_letter(), Path(''))
-    p = Path('z:\\foo')
-    eq_(p.remove_drive_letter(), Path('foo'))

hscommon/tests/util_test.py

@@ -9,10 +9,9 @@
 from io import StringIO
 
 from pytest import raises
+from pathlib import Path
 
 from ..testutil import eq_
-from .. import io
-from ..path import Path
 from ..util import *
 
 def test_nonone():
@@ -215,34 +214,34 @@ class TestCase_delete_if_empty:
     def test_is_empty(self, tmpdir):
         testpath = Path(str(tmpdir))
         assert delete_if_empty(testpath)
-        assert not io.exists(testpath)
+        assert not testpath.exists()
     
     def test_not_empty(self, tmpdir):
         testpath = Path(str(tmpdir))
-        io.mkdir(testpath + 'foo')
+        testpath['foo'].mkdir()
         assert not delete_if_empty(testpath)
-        assert io.exists(testpath)
+        assert testpath.exists()
     
     def test_with_files_to_delete(self, tmpdir):
         testpath = Path(str(tmpdir))
-        io.open(testpath + 'foo', 'w')
-        io.open(testpath + 'bar', 'w')
+        testpath['foo'].touch()
+        testpath['bar'].touch()
         assert delete_if_empty(testpath, ['foo', 'bar'])
-        assert not io.exists(testpath)
+        assert not testpath.exists()
     
     def test_directory_in_files_to_delete(self, tmpdir):
         testpath = Path(str(tmpdir))
-        io.mkdir(testpath + 'foo')
+        testpath['foo'].mkdir()
         assert not delete_if_empty(testpath, ['foo'])
-        assert io.exists(testpath)
+        assert testpath.exists()
     
     def test_delete_files_to_delete_only_if_dir_is_empty(self, tmpdir):
         testpath = Path(str(tmpdir))
-        io.open(testpath + 'foo', 'w')
-        io.open(testpath + 'bar', 'w')
+        testpath['foo'].touch()
+        testpath['bar'].touch()
         assert not delete_if_empty(testpath, ['foo'])
-        assert io.exists(testpath)
-        assert io.exists(testpath + 'foo')
+        assert testpath.exists()
+        assert testpath['foo'].exists()
     
     def test_doesnt_exist(self):
         # When the 'path' doesn't exist, just do nothing.
@@ -250,8 +249,8 @@ class TestCase_delete_if_empty:
     
     def test_is_file(self, tmpdir):
         # When 'path' is a file, do nothing.
-        p = Path(str(tmpdir)) + 'filename'
-        io.open(p, 'w').close()
+        p = Path(str(tmpdir))['filename']
+        p.touch()
         delete_if_empty(p) # no crash
     
     def test_ioerror(self, tmpdir, monkeypatch):
@@ -259,7 +258,7 @@ class TestCase_delete_if_empty:
         def do_raise(*args, **kw):
             raise OSError()
         
-        monkeypatch.setattr(io, 'rmdir', do_raise)
+        monkeypatch.setattr(Path, 'rmdir', do_raise)
         delete_if_empty(Path(str(tmpdir))) # no crash