upgrade wakatime-cli to v10.0.4

packages/wakatime/__about__.py

@@ -1,7 +1,7 @@
 __title__ = 'wakatime'
 __description__ = 'Common interface to the WakaTime api.'
 __url__ = 'https://github.com/wakatime/wakatime'
-__version_info__ = ('10', '0', '3')
+__version_info__ = ('10', '0', '4')
 __version__ = '.'.join(__version_info__)
 __author__ = 'Alan Hamlett'
 __author_email__ = 'alan@wakatime.com'

packages/wakatime/api.py

@@ -30,7 +30,7 @@ log = logging.getLogger('WakaTime')
 
 try:
     from .packages import requests
-except ImportError:
+except ImportError:  # pragma: nocover
     log.traceback(logging.ERROR)
     print(traceback.format_exc())
     log.error('Please upgrade Python to the latest version.')
@@ -138,50 +138,53 @@ def send_heartbeats(heartbeats, args, configs, use_ntlm_proxy=False):
     else:
         code = response.status_code if response is not None else None
         content = response.text if response is not None else None
-        try:
+
-            results = response.json() if response is not None else []
+        if _success(code):
-        except:
+            results = _get_results(response)
-            if log.isEnabledFor(logging.DEBUG):
+            _process_server_results(heartbeats, code, content, results, args, configs)
-                log.traceback(logging.WARNING)
+            session_cache.save(session)
-            results = []
+            return SUCCESS
-        if code == requests.codes.created or code == requests.codes.accepted:
+
+        if should_try_ntlm:
+            return send_heartbeats(heartbeats, args, configs, use_ntlm_proxy=True)
+
+        _handle_unsent_heartbeats(heartbeats, code, content, args, configs)
+
+    session_cache.delete()
+    return AUTH_ERROR if code == 401 else API_ERROR
+
+
+def _process_server_results(heartbeats, code, content, results, args, configs):
     log.debug({
         'response_code': code,
     })
 
     for i in range(len(results)):
         if len(heartbeats) <= i:
-                    log.debug('Results from server do not match heartbeats sent.')
+            log.warn('Results from api not matching heartbeats sent.')
             break
 
         try:
             c = results[i][1]
         except:
+            log.traceback(logging.WARNING)
             c = 0
         try:
             text = json.dumps(results[i][0])
         except:
-                    if log.isEnabledFor(logging.DEBUG):
             log.traceback(logging.WARNING)
             text = ''
-                handle_result([heartbeats[i]], c, text, args, configs)
+        if not _success(c):
+            _handle_unsent_heartbeats([heartbeats[i]], c, text, args, configs)
 
-            session_cache.save(session)
+    leftover = len(heartbeats) - len(results)
-            return SUCCESS
+    if leftover > 0:
-
+        log.warn('Missing {0} results from api.'.format(leftover))
-        if should_try_ntlm:
+        start = len(heartbeats) - leftover
-            return send_heartbeats(heartbeats, args, configs, use_ntlm_proxy=True)
+        _handle_unsent_heartbeats(heartbeats[start:], code, content, args, configs)
-        else:
-            handle_result(heartbeats, code, content, args, configs)
-
-    session_cache.delete()
-    return AUTH_ERROR if code == 401 else API_ERROR
 
 
-def handle_result(h, code, content, args, configs):
+def _handle_unsent_heartbeats(heartbeats, code, content, args, configs):
-    if code == requests.codes.created or code == requests.codes.accepted:
-        return
-
     if args.offline:
         if code == 400:
             log.error({
@@ -195,9 +198,23 @@ def handle_result(h, code, content, args, configs):
                     'response_content': content,
                 })
             queue = Queue(args, configs)
-            queue.push_many(h)
+            queue.push_many(heartbeats)
     else:
         log.error({
             'response_code': code,
             'response_content': content,
         })
+
+
+def _get_results(response):
+    results = []
+    if response is not None:
+        try:
+            results = response.json()
+        except:
+            log.traceback(logging.WARNING)
+    return results
+
+
+def _success(code):
+    return code == requests.codes.created or code == requests.codes.accepted

packages/wakatime/compat.py

@@ -96,5 +96,5 @@ except ImportError:  # pragma: nocover
 
 try:
     from .packages import simplejson as json
-except (ImportError, SyntaxError):
+except (ImportError, SyntaxError):  # pragma: nocover
     import json

packages/wakatime/configs.py

@@ -21,7 +21,7 @@ from .constants import CONFIG_FILE_PARSE_ERROR
 
 try:
     import configparser
-except ImportError:
+except ImportError:  # pragma: nocover
     from .packages import configparser
 
 

packages/wakatime/dependencies/jvm.py

@@ -43,7 +43,7 @@ class JavaParser(TokenParser):
             self._process_other(token, content)
 
     def _process_namespace(self, token, content):
-        if u(content) == u('import'):
+        if u(content).split() and u(content).split()[0] == u('import'):
             self.state = 'import'
 
         elif self.state == 'import':

packages/wakatime/heartbeat.py

@@ -41,6 +41,10 @@ class Heartbeat(object):
     user_agent = None
 
     def __init__(self, data, args, configs, _clone=None):
+        if not data:
+            self.skip = u('Skipping because heartbeat data is missing.')
+            return
+
         self.args = args
         self.configs = configs
 
@@ -62,7 +66,7 @@ class Heartbeat(object):
                 return
             if self.type == 'file':
                 self.entity = format_file_path(self.entity)
-            if self.type == 'file' and not os.path.isfile(self.entity):
+            if self.type == 'file' and (not self.entity or not os.path.isfile(self.entity)):
                 self.skip = u('File does not exist; ignoring this heartbeat.')
                 return
 
@@ -91,7 +95,6 @@ class Heartbeat(object):
         data = self.dict()
         data.update(attrs)
         heartbeat = Heartbeat(data, self.args, self.configs, _clone=True)
-        heartbeat.skip = self.skip
         return heartbeat
 
     def sanitize(self):

packages/wakatime/projects/git.py

@@ -123,6 +123,6 @@ class Git(BaseProject):
             subpath = line[len('gitdir: '):].strip()
             if os.path.isfile(os.path.join(path, subpath, 'config')) and \
                     os.path.isfile(os.path.join(path, subpath, 'HEAD')):
-                return os.path.join(path, subpath)
+                return os.path.realpath(os.path.join(path, subpath))
 
         return None