Add support for python 3.8 and Sublime Text 4

Sublime Text 4 comes with a new plugin_host based on python 3.8.

This commit adds an `.python-version` file to opt-in to python 3.8 and
updates the `send2trash` library for compatibility reasons with the new
interpreter.

Author: DeathAxe

.python-version

@@ -0,0 +1 @@
+3.8

libs/send2trash/LICENSE

@@ -0,0 +1,10 @@
+Copyright (c) 2017, Virgil Dupras
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+    * Neither the name of Hardcoded Software Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

libs/send2trash/__init__.py

@@ -1,14 +1,21 @@
-# Copyright 2010 Hardcoded Software (http://www.hardcoded.net)
+# 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
+# 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
 
-if sys.platform == "darwin":
+from .exceptions import TrashPermissionError
+
+if sys.platform == 'darwin':
     from .plat_osx import send2trash
-elif sys.platform == "win32":
+elif sys.platform == 'win32':
     from .plat_win import send2trash
 else:
-    from .plat_other import send2trash
+    try:
+        # If we can use gio, let's use it
+        from .plat_gio import send2trash
+    except ImportError:
+        # Oh well, let's fallback to our own Freedesktop trash implementation
+        from .plat_other import send2trash

libs/send2trash/compat.py

@@ -0,0 +1,20 @@
+# Copyright 2017 Virgil Dupras
+
+# 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
+import os
+
+PY3 = sys.version_info[0] >= 3
+if PY3:
+    text_type = str
+    binary_type = bytes
+    if os.supports_bytes_environ:
+        # environb will be unset under Windows, but then again we're not supposed to use it.
+        environb = os.environb
+else:
+    text_type = unicode
+    binary_type = str
+    environb = os.environ

libs/send2trash/exceptions.py

@@ -0,0 +1,25 @@
+import errno
+from .compat import PY3
+
+if PY3:
+    _permission_error = PermissionError
+else:
+    _permission_error = OSError
+
+class TrashPermissionError(_permission_error):
+    """A permission error specific to a trash directory.
+
+    Raising this error indicates that permissions prevent us efficiently
+    trashing a file, although we might still have permission to delete it.
+    This is *not* used when permissions prevent removing the file itself:
+    that will be raised as a regular PermissionError (OSError on Python 2).
+
+    Application code that catches this may try to simply delete the file,
+    or prompt the user to decide, or (on Freedesktop platforms), move it to
+    'home trash' as a fallback. This last option probably involves copying the
+    data between partitions, devices, or network drives, so we don't do it as
+    a fallback.
+    """
+    def __init__(self, filename):
+        _permission_error.__init__(self, errno.EACCES, "Permission denied",
+                                   filename)

libs/send2trash/plat_osx.py

@@ -1,14 +1,18 @@
-# Copyright 2010 Hardcoded Software (http://www.hardcoded.net)
+# Copyright 2017 Virgil Dupras
 
 # 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
 
+from __future__ import unicode_literals
+
 from ctypes import cdll, byref, Structure, c_char, c_char_p
 from ctypes.util import find_library
 
-Foundation = cdll.LoadLibrary(find_library("Foundation"))
-CoreServices = cdll.LoadLibrary(find_library("CoreServices"))
+from .compat import binary_type
+
+Foundation = cdll.LoadLibrary(find_library('Foundation'))
+CoreServices = cdll.LoadLibrary(find_library('CoreServices'))
 
 GetMacOSStatusCommentString = Foundation.GetMacOSStatusCommentString
 GetMacOSStatusCommentString.restype = c_char_p
@@ -24,20 +28,17 @@
 kFSFileOperationDoNotMoveAcrossVolumes = 0x04
 kFSFileOperationSkipPreflight = 0x08
 
-
 class FSRef(Structure):
-    _fields_ = [("hidden", c_char * 80)]
-
+    _fields_ = [('hidden', c_char * 80)]
 
 def check_op_result(op_result):
     if op_result:
-        msg = GetMacOSStatusCommentString(op_result).decode("utf-8")
+        msg = GetMacOSStatusCommentString(op_result).decode('utf-8')
         raise OSError(msg)
 
-
 def send2trash(path):
-    if not isinstance(path, bytes):
-        path = path.encode("utf-8")
+    if not isinstance(path, binary_type):
+        path = path.encode('utf-8')
     fp = FSRef()
     opts = kFSPathMakeRefDoNotFollowLeafSymlink
     op_result = FSPathMakeRefWithOptions(path, opts, byref(fp), None)

libs/send2trash/plat_other.py

@@ -1,4 +1,4 @@
-# Copyright 2010 Hardcoded Software (http://www.hardcoded.net)
+# Copyright 2017 Virgil Dupras
 
 # 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
@@ -14,57 +14,77 @@
 # For external volumes this implementation will raise an exception if it can't
 # find or create the user's trash directory.
 
-# import sys
+from __future__ import unicode_literals
+
+import errno
+import sys
 import os
 import os.path as op
 from datetime import datetime
 import stat
-import shutil
-from urllib.parse import quote
-
-FILES_DIR = "files"
-INFO_DIR = "info"
-INFO_SUFFIX = ".trashinfo"
+try:
+    from urllib.parse import quote
+except ImportError:
+    # Python 2
+    from urllib import quote
+
+from .compat import text_type, environb
+from .exceptions import TrashPermissionError
+
+try:
+    fsencode = os.fsencode   # Python 3
+    fsdecode = os.fsdecode
+except AttributeError:
+    def fsencode(u):         # Python 2
+        return u.encode(sys.getfilesystemencoding())
+    def fsdecode(b):
+        return b.decode(sys.getfilesystemencoding())
+    # The Python 3 versions are a bit smarter, handling surrogate escapes,
+    # but these should work in most cases.
+
+FILES_DIR = b'files'
+INFO_DIR = b'info'
+INFO_SUFFIX = b'.trashinfo'
 
 # Default of ~/.local/share [3]
-XDG_DATA_HOME = op.expanduser(os.environ.get("XDG_DATA_HOME", "~/.local/share"))
-HOMETRASH = op.join(XDG_DATA_HOME, "Trash")
+XDG_DATA_HOME = op.expanduser(environb.get(b'XDG_DATA_HOME', b'~/.local/share'))
+HOMETRASH_B = op.join(XDG_DATA_HOME, b'Trash')
+HOMETRASH = fsdecode(HOMETRASH_B)
 
 uid = os.getuid()
-TOPDIR_TRASH = ".Trash"
-TOPDIR_FALLBACK = ".Trash-" + str(uid)
-
+TOPDIR_TRASH = b'.Trash'
+TOPDIR_FALLBACK = b'.Trash-' + text_type(uid).encode('ascii')
 
 def is_parent(parent, path):
-    path = op.realpath(path)  # In case it's a symlink
+    path = op.realpath(path) # In case it's a symlink
+    if isinstance(path, text_type):
+        path = fsencode(path)
     parent = op.realpath(parent)
+    if isinstance(parent, text_type):
+        parent = fsencode(parent)
     return path.startswith(parent)
 
-
 def format_date(date):
     return date.strftime("%Y-%m-%dT%H:%M:%S")
 
-
 def info_for(src, topdir):
-    # ...it MUST not include a ".."" directory, and for files not "under" that
+    # ...it MUST not include a ".." directory, and for files not "under" that
     # directory, absolute pathnames must be used. [2]
     if topdir is None or not is_parent(topdir, src):
         src = op.abspath(src)
     else:
         src = op.relpath(src, topdir)
 
-    info = "[Trash Info]\n"
+    info  = "[Trash Info]\n"
     info += "Path=" + quote(src) + "\n"
     info += "DeletionDate=" + format_date(datetime.now()) + "\n"
     return info
 
-
 def check_create(dir):
     # use 0700 for paths [3]
     if not op.exists(dir):
         os.makedirs(dir, 0o700)
 
-
 def trash_move(src, dst, topdir=None):
     filename = op.basename(src)
     filespath = op.join(dst, FILES_DIR)
@@ -73,32 +93,26 @@ def trash_move(src, dst, topdir=None):
 
     counter = 0
     destname = filename
-    while op.exists(op.join(filespath, destname)) or op.exists(
-        op.join(infopath, destname + INFO_SUFFIX)
-    ):
+    while op.exists(op.join(filespath, destname)) or op.exists(op.join(infopath, destname + INFO_SUFFIX)):
         counter += 1
-        destname = "%s %s%s" % (base_name, counter, ext)
+        destname = base_name + b' ' + text_type(counter).encode('ascii') + ext
 
     check_create(filespath)
     check_create(infopath)
-    try:
-        os.rename(src, op.join(filespath, destname))
-    except:
-        shutil.move(src, op.join(filespath, destname))
-    f = open(op.join(infopath, destname + INFO_SUFFIX), "w")
+
+    os.rename(src, op.join(filespath, destname))
+    f = open(op.join(infopath, destname + INFO_SUFFIX), 'w')
     f.write(info_for(src, topdir))
     f.close()
 
-
 def find_mount_point(path):
     # Even if something's wrong, "/" is a mount point, so the loop will exit.
     # Use realpath in case it's a symlink
-    path = op.realpath(path)  # Required to avoid infinite loop
+    path = op.realpath(path) # Required to avoid infinite loop
     while not op.ismount(path):
         path = op.split(path)[0]
     return path
 
-
 def find_ext_volume_global_trash(volume_root):
     # from [2] Trash directories (1) check for a .Trash dir with the right
     # permissions set.
@@ -112,61 +126,67 @@ def find_ext_volume_global_trash(volume_root):
     if not op.isdir(trash_dir) or op.islink(trash_dir) or not (mode & stat.S_ISVTX):
         return None
 
-    trash_dir = op.join(trash_dir, str(uid))
+    trash_dir = op.join(trash_dir, text_type(uid).encode('ascii'))
     try:
         check_create(trash_dir)
     except OSError:
         return None
     return trash_dir
 
-
 def find_ext_volume_fallback_trash(volume_root):
     # from [2] Trash directories (1) create a .Trash-$uid dir.
     trash_dir = op.join(volume_root, TOPDIR_FALLBACK)
-    # Try to make the directory, if we can't the OSError exception will escape
-    # be thrown out of send2trash.
-    check_create(trash_dir)
+    # Try to make the directory, if we lack permission, raise TrashPermissionError
+    try:
+        check_create(trash_dir)
+    except OSError as e:
+        if e.errno == errno.EACCES:
+            raise TrashPermissionError(e.filename)
+        raise
     return trash_dir
 
-
 def find_ext_volume_trash(volume_root):
     trash_dir = find_ext_volume_global_trash(volume_root)
     if trash_dir is None:
         trash_dir = find_ext_volume_fallback_trash(volume_root)
     return trash_dir
 
-
 # Pull this out so it's easy to stub (to avoid stubbing lstat itself)
 def get_dev(path):
     return os.lstat(path).st_dev
 
-
 def send2trash(path):
-    # if not isinstance(path, str):
-    #    path = str(path, sys.getfilesystemencoding())
-    # if not op.exists(path):
-    #    raise OSError("File not found: %s" % path)
+    if isinstance(path, text_type):
+        path_b = fsencode(path)
+    elif isinstance(path, bytes):
+        path_b = path
+    elif hasattr(path, '__fspath__'):
+        # Python 3.6 PathLike protocol
+        return send2trash(path.__fspath__())
+    else:
+        raise TypeError('str, bytes or PathLike expected, not %r' % type(path))
+
+    if not op.exists(path_b):
+        raise OSError("File not found: %s" % path)
     # ...should check whether the user has the necessary permissions to delete
     # it, before starting the trashing operation itself. [2]
-    # if not os.access(path, os.W_OK):
-    #    raise OSError("Permission denied: %s" % path)
+    if not os.access(path_b, os.W_OK):
+        raise OSError("Permission denied: %s" % path)
     # if the file to be trashed is on the same device as HOMETRASH we
     # want to move it there.
-    path_dev = get_dev(path)
+    path_dev = get_dev(path_b)
 
     # If XDG_DATA_HOME or HOMETRASH do not yet exist we need to stat the
     # home directory, and these paths will be created further on if needed.
-    trash_dev = get_dev(op.expanduser("~"))
+    trash_dev = get_dev(op.expanduser(b'~'))
 
-    if path_dev == trash_dev or (
-        os.path.exists(XDG_DATA_HOME) and os.path.exists(HOMETRASH)
-    ):
+    if path_dev == trash_dev:
         topdir = XDG_DATA_HOME
-        dest_trash = HOMETRASH
+        dest_trash = HOMETRASH_B
     else:
-        topdir = find_mount_point(path)
+        topdir = find_mount_point(path_b)
         trash_dev = get_dev(topdir)
         if trash_dev != path_dev:
             raise OSError("Couldn't find mount point for %s" % path)
         dest_trash = find_ext_volume_trash(topdir)
-    trash_move(path, dest_trash, topdir)
+    trash_move(path_b, dest_trash, topdir)