v11.0.6

HISTORY.rst

@@ -3,6 +3,36 @@ History
 -------
 
 
+11.0.6 (2022-06-08)
+++++++++++++++++++
+
+- Fix call to log helper.
+  `#113 <https://github.com/wakatime/sublime-wakatime/issues/113>`_
+
+
+11.0.5 (2022-04-29)
+++++++++++++++++++
+
+- Bugfix to not overwrite global urlopener in embedded Python.
+  `#110 <https://github.com/wakatime/sublime-wakatime/issues/110>`_
+- Chmod wakatime-cli to be executable after updating on non-Windows platforms.
+
+
+11.0.4 (2022-01-06)
+++++++++++++++++++
+
+- Copy wakatime-cli when symlink fails on Windows.
+  `vim-wakatime#122 <https://github.com/wakatime/vim-wakatime/issues/122>`_
+- Fix lineno, cursorpos, and lines-in-file arguments.
+
+
+11.0.3 (2021-12-31)
+++++++++++++++++++
+
+- Bugfix to not delete old wakatime-cli until finished downloading new version.
+  `#107 <https://github.com/wakatime/sublime-wakatime/issues/107>`_
+
+
 11.0.2 (2021-11-17)
 ++++++++++++++++++
 

WakaTime.py

@@ -8,7 +8,7 @@ Website:     https://wakatime.com/
 ==========================================================="""
 
 
-__version__ = '11.0.2'
+__version__ = '11.0.6'
 
 
 import sublime
@@ -18,6 +18,7 @@ import json
 import os
 import platform
 import re
+import shutil
 import ssl
 import subprocess
 import sys
@@ -39,9 +40,9 @@ try:
 except ImportError:
     from configparser import ConfigParser, Error as ConfigParserError
 try:
-    from urllib2 import urlopen, urlretrieve, ProxyHandler, build_opener, install_opener, HTTPError
+    from urllib2 import Request, urlopen, HTTPError
 except ImportError:
-    from urllib.request import urlopen, urlretrieve, ProxyHandler, build_opener, install_opener
+    from urllib.request import Request, urlopen
     from urllib.error import HTTPError
 
 
@@ -105,14 +106,14 @@ class Popen(subprocess.Popen):
     """Patched Popen to prevent opening cmd window on Windows platform."""
 
     def __init__(self, *args, **kwargs):
-        startupinfo = kwargs.get('startupinfo')
-        if is_win or True:
+        if is_win:
+            startupinfo = kwargs.get('startupinfo')
             try:
                 startupinfo = startupinfo or subprocess.STARTUPINFO()
                 startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
             except AttributeError:
                 pass
-        kwargs['startupinfo'] = startupinfo
+            kwargs['startupinfo'] = startupinfo
         super(Popen, self).__init__(*args, **kwargs)
 
 
@@ -416,10 +417,16 @@ def append_heartbeat(entity, timestamp, is_write, view, project, folders):
         'entity': entity,
         'timestamp': timestamp,
         'is_write': is_write,
-        'cursorpos': view.sel()[0].begin() if view.sel() else None,
         'project': project,
         'folders': folders,
+        'lines_in_file': view.rowcol(view.size())[0] + 1,
     }
+    selections = view.sel()
+    if selections:
+        rowcol = view.rowcol(selections[0].begin())
+        row, col = rowcol[0] + 1, rowcol[1] + 1
+        heartbeat['lineno'] = row
+        heartbeat['cursorpos'] = col
     HEARTBEATS.put_nowait(heartbeat)
 
     # make this heartbeat the LAST_HEARTBEAT
@@ -492,7 +499,8 @@ class SendHeartbeatsThread(threading.Thread):
         self.send_heartbeats()
 
     def build_heartbeat(self, entity=None, timestamp=None, is_write=None,
-                        cursorpos=None, project=None, folders=None):
+                        lineno=None, cursorpos=None, lines_in_file=None,
+                        project=None, folders=None):
         """Returns a dict for passing to wakatime-cli as arguments."""
 
         heartbeat = {
@@ -508,8 +516,12 @@ class SendHeartbeatsThread(threading.Thread):
             if project_name:
                 heartbeat['alternate_project'] = project_name
 
+        if lineno is not None:
+            heartbeat['lineno'] = lineno
         if cursorpos is not None:
             heartbeat['cursorpos'] = cursorpos
+        if lines_in_file is not None:
+            heartbeat['lines-in-file'] = lines_in_file
 
         return heartbeat
 
@@ -528,8 +540,12 @@ class SendHeartbeatsThread(threading.Thread):
             cmd.append('--write')
         if heartbeat.get('alternate_project'):
             cmd.extend(['--alternate-project', heartbeat['alternate_project']])
+        if heartbeat.get('lineno') is not None:
+            cmd.extend(['--lineno', '{0}'.format(heartbeat['lineno'])])
         if heartbeat.get('cursorpos') is not None:
             cmd.extend(['--cursorpos', '{0}'.format(heartbeat['cursorpos'])])
+        if heartbeat.get('lines_in_file') is not None:
+            cmd.extend(['--lines-in-file', '{0}'.format(heartbeat['lines_in_file'])])
         for pattern in self.ignore:
             cmd.extend(['--exclude', pattern])
         for pattern in self.include:
@@ -623,21 +639,24 @@ class DownloadCLI(threading.Thread):
     def run(self):
         log(INFO, 'Downloading wakatime-cli...')
 
+        if os.path.isdir(os.path.join(RESOURCES_FOLDER, 'wakatime-cli')):
+            shutil.rmtree(os.path.join(RESOURCES_FOLDER, 'wakatime-cli'))
+
         if not os.path.exists(RESOURCES_FOLDER):
             os.makedirs(RESOURCES_FOLDER)
 
-        if isCliInstalled():
-            try:
-                os.remove(getCliLocation())
-            except:
-                log(DEBUG, traceback.format_exc())
-
         try:
             url = cliDownloadUrl()
             log(DEBUG, 'Downloading wakatime-cli from {url}'.format(url=url))
             zip_file = os.path.join(RESOURCES_FOLDER, 'wakatime-cli.zip')
             download(url, zip_file)
 
+            if isCliInstalled():
+                try:
+                    os.remove(getCliLocation())
+                except:
+                    log(DEBUG, traceback.format_exc())
+
             log(INFO, 'Extracting wakatime-cli...')
             with ZipFile(zip_file) as zf:
                 zf.extractall(RESOURCES_FOLDER)
@@ -652,6 +671,8 @@ class DownloadCLI(threading.Thread):
         except:
             log(DEBUG, traceback.format_exc())
 
+        createSymlink()
+
         log(INFO, 'Finished extracting wakatime-cli.')
 
 
@@ -725,10 +746,7 @@ def getLatestCliVersion():
     try:
         configs = parseConfigFile(INTERNAL_CONFIG_FILE)
         if configs:
-            if configs.has_option('internal', 'cli_version'):
-                last_version = configs.get('internal', 'cli_version')
-            if last_version and configs.has_option('internal', 'cli_version_last_modified'):
-                last_modified = configs.get('internal', 'cli_version_last_modified')
+            last_modified, last_version = lastModifiedAndVersion(configs)
     except:
         log(DEBUG, traceback.format_exc())
 
@@ -762,6 +780,17 @@ def getLatestCliVersion():
         return None
 
 
+def lastModifiedAndVersion(configs):
+    last_modified, last_version = None, None
+    if configs.has_option('internal', 'cli_version'):
+        last_version = configs.get('internal', 'cli_version')
+    if last_version and configs.has_option('internal', 'cli_version_last_modified'):
+        last_modified = configs.get('internal', 'cli_version_last_modified')
+    if last_modified and last_version and extractVersion(last_version):
+        return last_modified, last_version
+    return None, None
+
+
 def extractVersion(text):
     pattern = re.compile(r"([0-9]+\.[0-9]+\.[0-9]+)")
     match = pattern.search(text)
@@ -818,80 +847,130 @@ def reportMissingPlatformSupport(osname, arch):
 
 
 def request(url, last_modified=None):
+    req = Request(url)
+    req.add_header('User-Agent', 'github.com/wakatime/sublime-wakatime')
+
     proxy = SETTINGS.get('proxy')
     if proxy:
-        opener = build_opener(ProxyHandler({
-            'http': proxy,
-            'https': proxy,
-        }))
-    else:
-        opener = build_opener()
+        req.set_proxy(proxy, 'https')
 
-    headers = [('User-Agent', 'github.com/wakatime/sublime-wakatime')]
     if last_modified:
-        headers.append(('If-Modified-Since', last_modified))
-
-    opener.addheaders = headers
-
-    install_opener(opener)
+        req.add_header('If-Modified-Since', last_modified)
 
     try:
-        resp = urlopen(url)
+        resp = urlopen(req)
         headers = dict(resp.getheaders()) if is_py2 else resp.headers
         return headers, resp.read(), resp.getcode()
     except HTTPError as err:
         if err.code == 304:
             return None, None, 304
         if is_py2:
-            ssl._create_default_https_context = ssl._create_unverified_context
-            try:
-                resp = urlopen(url)
-                headers = dict(resp.getheaders()) if is_py2 else resp.headers
-                return headers, resp.read(), resp.getcode()
-            except HTTPError as err2:
-                if err2.code == 304:
-                    return None, None, 304
-                log(DEBUG, err.read().decode())
-                log(DEBUG, err2.read().decode())
-                raise
-            except IOError:
-                raise
+            with SSLCertVerificationDisabled():
+                try:
+                    resp = urlopen(req)
+                    headers = dict(resp.getheaders()) if is_py2 else resp.headers
+                    return headers, resp.read(), resp.getcode()
+                except HTTPError as err2:
+                    if err2.code == 304:
+                        return None, None, 304
+                    log(DEBUG, err.read().decode())
+                    log(DEBUG, err2.read().decode())
+                    raise
+                except IOError:
+                    raise
         log(DEBUG, err.read().decode())
         raise
     except IOError:
         if is_py2:
-            ssl._create_default_https_context = ssl._create_unverified_context
-            try:
-                resp = urlopen(url)
-                headers = dict(resp.getheaders()) if is_py2 else resp.headers
-                return headers, resp.read(), resp.getcode()
-            except HTTPError as err:
-                if err.code == 304:
-                    return None, None, 304
-                log(DEBUG, err.read().decode())
-                raise
-            except IOError:
-                raise
+            with SSLCertVerificationDisabled():
+                try:
+                    resp = urlopen(url)
+                    headers = dict(resp.getheaders()) if is_py2 else resp.headers
+                    return headers, resp.read(), resp.getcode()
+                except HTTPError as err:
+                    if err.code == 304:
+                        return None, None, 304
+                    log(DEBUG, err.read().decode())
+                    raise
+                except IOError:
+                    raise
         raise
 
 
 def download(url, filePath):
+    req = Request(url)
+    req.add_header('User-Agent', 'github.com/wakatime/sublime-wakatime')
+
     proxy = SETTINGS.get('proxy')
     if proxy:
-        opener = build_opener(ProxyHandler({
-            'http': proxy,
-            'https': proxy,
-        }))
-    else:
-        opener = build_opener()
-    opener.addheaders = [('User-Agent', 'github.com/wakatime/sublime-wakatime')]
+        req.set_proxy(proxy, 'https')
 
-    install_opener(opener)
+    with open(filePath, 'wb') as fh:
+        try:
+            resp = urlopen(req)
+            fh.write(resp.read())
+        except HTTPError as err:
+            if err.code == 304:
+                return None, None, 304
+            if is_py2:
+                with SSLCertVerificationDisabled():
+                    try:
+                        resp = urlopen(req)
+                        fh.write(resp.read())
+                        return
+                    except HTTPError as err2:
+                        log(DEBUG, err.read().decode())
+                        log(DEBUG, err2.read().decode())
+                        raise
+                    except IOError:
+                        raise
+            log(DEBUG, err.read().decode())
+            raise
+        except IOError:
+            if is_py2:
+                with SSLCertVerificationDisabled():
+                    try:
+                        resp = urlopen(url)
+                        fh.write(resp.read())
+                        return
+                    except HTTPError as err:
+                        log(DEBUG, err.read().decode())
+                        raise
+                    except IOError:
+                        raise
+            raise
+
+
+def is_symlink(path):
+    try:
+        return os.is_symlink(path)
+    except:
+        return False
+
+
+def createSymlink():
+    link = os.path.join(RESOURCES_FOLDER, 'wakatime-cli')
+    if is_win:
+        link = link + '.exe'
+    elif os.path.exists(link) and is_symlink(link):
+        return  # don't re-create symlink on Unix-like platforms
 
     try:
-        urlretrieve(url, filePath)
-    except IOError:
-        if is_py2:
-            ssl._create_default_https_context = ssl._create_unverified_context
-            urlretrieve(url, filePath)
-        raise
+        os.symlink(getCliLocation(), link)
+    except:
+        try:
+            shutil.copy2(getCliLocation(), link)
+            if not is_win:
+                os.chmod(link, 509)  # 755
+        except:
+            log(WARNING, traceback.format_exc())
+
+
+class SSLCertVerificationDisabled(object):
+
+    def __enter__(self):
+        self.original_context = ssl._create_default_https_context
+        ssl._create_default_https_context = ssl._create_unverified_context
+
+    def __exit__(self, *args, **kwargs):
+        ssl._create_default_https_context = self.original_context