v8.3.4

HISTORY.rst

@@ -3,6 +3,42 @@ History
 -------
 
 
+8.3.4 (2019-03-30)
+++++++++++++++++++
+
+- Upgrade wakatime-cli to v10.8.2.
+- Detect go.mod files as Go language.
+  `jetbrains-wakatime#119 <https://github.com/wakatime/jetbrains-wakatime/issues/119>`_
+- Detect C++ language from all C++ file extensions.
+  `vscode-wakatime#87 <https://github.com/wakatime/vscode-wakatime/issues/87>`_
+- Add ssl_certs_file arg and config for custom ca bundles.
+  `#164 <https://github.com/wakatime/wakatime/issues/164>`_
+- Fix bug causing random project names when hide project names enabled.
+  `vscode-wakatime#162 <https://github.com/wakatime/vscode-wakatime/issues/61>`_
+- Add support for UNC network shares without drive letter mapped on Winows.
+  `#162 <https://github.com/wakatime/wakatime/issues/162>`_
+
+
+8.3.3 (2018-12-19)
+++++++++++++++++++
+
+- Upgrade wakatime-cli to v10.6.1.
+- Correctly parse include_only_with_project_file when set to false.
+  `wakatime#161 <https://github.com/wakatime/wakatime/issues/161>`_
+- Support language argument for non-file entity types.
+- Send 25 heartbeats per API request.
+- New category "Writing Tests".
+  `wakatime#156 <https://github.com/wakatime/wakatime/issues/156>`_
+- Fix bug caused by git config section without any submodule option defined.
+  `wakatime#152 <https://github.com/wakatime/wakatime/issues/152>`_
+
+
+8.3.2 (2018-10-06)
+++++++++++++++++++
+
+- Send buffered heartbeats to API every 30 seconds.
+
+
 8.3.1 (2018-10-05)
 ++++++++++++++++++
 
@@ -77,10 +113,10 @@ History
 - Upgrade wakatime-cli to v10.1.2.
 - Detect dependencies from Swift, Objective-C, TypeScript and JavaScript files.
 - Categorize .mjs files as JavaScript.
-  `#wakatime121 <https://github.com/wakatime/wakatime/issues/121>`_
+  `wakatime#121 <https://github.com/wakatime/wakatime/issues/121>`_
 - Detect dependencies from Elm, Haskell, Haxe, Kotlin, Rust, and Scala files.
 - Improved Matlab vs Objective-C language detection.
-  `#wakatime129 <https://github.com/wakatime/wakatime/issues/129>`_
+  `wakatime#129 <https://github.com/wakatime/wakatime/issues/129>`_
 
 
 8.0.6 (2018-01-04)

LICENSE

@@ -1,7 +1,6 @@
 BSD 3-Clause License
 
-Copyright (c) 2014 by the respective authors (see AUTHORS file).
-All rights reserved.
+Copyright (c) 2014 Alan Hamlett.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:

WakaTime.py

@@ -7,7 +7,7 @@ Website:     https://wakatime.com/
 ==========================================================="""
 
 
-__version__ = '8.3.1'
+__version__ = '8.3.4'
 
 
 import sublime
@@ -110,7 +110,6 @@ class Popen(subprocess.Popen):
 
 
 # globals
-HEARTBEAT_FREQUENCY = 2
 ST_VERSION = int(sublime.version())
 PLUGIN_DIR = os.path.dirname(os.path.realpath(__file__))
 API_CLIENT = os.path.join(PLUGIN_DIR, 'packages', 'wakatime', 'cli.py')
@@ -121,8 +120,11 @@ LAST_HEARTBEAT = {
     'file': None,
     'is_write': False,
 }
+LAST_HEARTBEAT_SENT_AT = 0
 PYTHON_LOCATION = None
 HEARTBEATS = queue.Queue()
+HEARTBEAT_FREQUENCY = 2  # minutes between logging heartbeat when editing same file
+SEND_BUFFER_SECONDS = 30  # seconds between sending buffered heartbeats to API
 
 
 # Log Levels
@@ -451,11 +453,18 @@ def append_heartbeat(entity, timestamp, is_write, view, project, folders):
     }
 
     # process the queue of heartbeats in the future
-    seconds = 4
-    set_timeout(process_queue, seconds)
+    set_timeout(lambda: process_queue(timestamp), SEND_BUFFER_SECONDS)
 
 
-def process_queue():
+def process_queue(timestamp):
+    global LAST_HEARTBEAT_SENT_AT
+
+    # Prevent sending heartbeats more often than SEND_BUFFER_SECONDS
+    now = int(time.time())
+    if timestamp != LAST_HEARTBEAT['time'] and LAST_HEARTBEAT_SENT_AT > now - SEND_BUFFER_SECONDS:
+        return
+    LAST_HEARTBEAT_SENT_AT = now
+
     try:
         heartbeat = HEARTBEATS.get_nowait()
     except queue.Empty:

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', '4', '1')
+__version_info__ = ('10', '8', '2')
 __version__ = '.'.join(__version_info__)
 __author__ = 'Alan Hamlett'
 __author_email__ = 'alan@wakatime.com'

packages/wakatime/api.py

@@ -99,12 +99,16 @@ def send_heartbeats(heartbeats, args, configs, use_ntlm_proxy=False):
             should_try_ntlm = '\\' in args.proxy
             proxies['https'] = args.proxy
 
+    ssl_verify = not args.nosslverify
+    if args.ssl_certs_file and ssl_verify:
+        ssl_verify = args.ssl_certs_file
+
     # send request to api
     response, code = None, None
     try:
         response = session.post(api_url, data=request_body, headers=headers,
                                 proxies=proxies, timeout=timeout,
-                                verify=not args.nosslverify)
+                                verify=ssl_verify)
     except RequestException:
         if should_try_ntlm:
             return send_heartbeats(heartbeats, args, configs, use_ntlm_proxy=True)

packages/wakatime/arguments.py

@@ -89,8 +89,8 @@ def parse_arguments():
                         help='Category of this heartbeat activity. Can be ' +
                              '"coding", "building", "indexing", ' +
                              '"debugging", "running tests", ' +
-                             '"manual testing", "browsing", ' +
-                             '"code reviewing" or "designing". ' +
+                             '"writing tests", "manual testing", ' +
+                             '"code reviewing", "browsing", or "designing". ' +
                              'Defaults to "coding".')
     parser.add_argument('--proxy', dest='proxy', action=StoreWithoutQuotes,
                         help='Optional proxy configuration. Supports HTTPS '+
@@ -103,6 +103,10 @@ def parse_arguments():
                         help='Disables SSL certificate verification for HTTPS '+
                              'requests. By default, SSL certificates are ' +
                              'verified.')
+    parser.add_argument('--ssl-certs-file', dest='ssl_certs_file',
+                        action=StoreWithoutQuotes,
+                        help='Override the bundled Python Requests CA certs ' +
+                             'file. By default, uses certifi for ca certs.')
     parser.add_argument('--project', dest='project', action=StoreWithoutQuotes,
                         help='Optional project name.')
     parser.add_argument('--alternate-project', dest='alternate_project',
@@ -275,7 +279,7 @@ def parse_arguments():
         except TypeError:  # pragma: nocover
             pass
     if not args.include_only_with_project_file and configs.has_option('settings', 'include_only_with_project_file'):
-        args.include_only_with_project_file = configs.get('settings', 'include_only_with_project_file')
+        args.include_only_with_project_file = configs.get('settings', 'include_only_with_project_file') == 'true'
     if not args.include:
         args.include = []
     if configs.has_option('settings', 'include'):
@@ -307,6 +311,8 @@ def parse_arguments():
                          'domain\\user:pass.')
     if configs.has_option('settings', 'no_ssl_verify'):
         args.nosslverify = configs.getboolean('settings', 'no_ssl_verify')
+    if configs.has_option('settings', 'ssl_certs_file'):
+        args.ssl_certs_file = configs.get('settings', 'ssl_certs_file')
     if not args.verbose and configs.has_option('settings', 'verbose'):
         args.verbose = configs.getboolean('settings', 'verbose')
     if not args.verbose and configs.has_option('settings', 'debug'):
@@ -335,7 +341,7 @@ def boolean_or_list(config_name, args, configs, alternative_names=[]):
     """Get a boolean or list of regexes from args and configs."""
 
     # when argument flag present, set to wildcard regex
-    for key in alternative_names:
+    for key in alternative_names + [config_name]:
         if hasattr(args, key) and getattr(args, key):
             setattr(args, config_name, ['.*'])
             return

packages/wakatime/constants.py

@@ -53,4 +53,4 @@ DEFAULT_SYNC_OFFLINE_ACTIVITY = 100
 Even when sending more heartbeats, this is the number of heartbeats sent per
 individual https request to the WakaTime API.
 """
-HEARTBEATS_PER_REQUEST = 50
+HEARTBEATS_PER_REQUEST = 25

packages/wakatime/dependencies/__init__.py

@@ -131,5 +131,5 @@ class DependencyParser(object):
         if self.parser:
             plugin = self.parser(self.source_file, lexer=self.lexer)
             dependencies = plugin.parse()
-            return list(set(dependencies))
+            return list(filter(bool, set(dependencies)))
         return []

packages/wakatime/heartbeat.py

@@ -70,6 +70,7 @@ class Heartbeat(object):
             'debugging',
             'running tests',
             'manual testing',
+            'writing tests',
             'browsing',
             'code reviewing',
             'designing',
@@ -248,6 +249,9 @@ class Heartbeat(object):
         if self.type != 'file':
             return
 
+        if not self.entity:
+            return
+
         if not is_win:
             return
 

packages/wakatime/project.py

@@ -69,6 +69,8 @@ def get_project_info(configs, heartbeat, data):
         project_name = data.get('project') or heartbeat.args.project
 
     hide_project = heartbeat.should_obfuscate_project()
+    if hide_project and project_name is not None:
+        return project_name, None
 
     if project_name is None or branch_name is None:
 

packages/wakatime/projects/git.py

@@ -87,10 +87,10 @@ class Git(BaseProject):
 
         disabled = self._configs.get('submodules_disabled')
 
+        if not disabled or disabled.strip().lower() == 'false':
+            return True
         if disabled.strip().lower() == 'true':
             return False
-        if disabled.strip().lower() == 'false':
-            return True
 
         for pattern in disabled.split("\n"):
             if pattern.strip():

packages/wakatime/stats.py

@@ -25,6 +25,7 @@ from .packages.pygments.lexers import (
     _fn_matches,
     basename,
     ClassNotFound,
+    CppLexer,
     find_lexer_class,
     get_lexer_by_name,
 )
@@ -41,31 +42,28 @@ log = logging.getLogger('WakaTime')
 
 def get_file_stats(file_name, entity_type='file', lineno=None, cursorpos=None,
                    plugin=None, language=None, local_file=None):
-    if entity_type != 'file':
-        stats = {
-            'language': None,
-            'dependencies': [],
-            'lines': None,
-            'lineno': lineno,
-            'cursorpos': cursorpos,
-        }
-    else:
-        language, lexer = standardize_language(language, plugin)
+    """Returns a hash of information about the entity."""
+
+    language = standardize_language(language, plugin)
+    stats = {
+        'language': language,
+        'dependencies': [],
+        'lines': None,
+        'lineno': lineno,
+        'cursorpos': cursorpos,
+    }
+
+    if entity_type == 'file':
+        lexer = get_lexer(language)
         if not language:
             language, lexer = guess_language(file_name, local_file)
-
-        language = use_root_language(language, lexer)
-
         parser = DependencyParser(local_file or file_name, lexer)
-        dependencies = parser.parse()
-
-        stats = {
-            'language': language,
-            'dependencies': dependencies,
+        stats.update({
+            'language': use_root_language(language, lexer),
+            'dependencies': parser.parse(),
             'lines': number_lines_in_file(local_file or file_name),
-            'lineno': lineno,
-            'cursorpos': cursorpos,
-        }
+        })
+
     return stats
 
 
@@ -171,6 +169,10 @@ def get_language_from_extension(file_name):
     """
 
     filepart, extension = os.path.splitext(file_name)
+    pathpart, filename = os.path.split(file_name)
+
+    if filename == 'go.mod':
+        return 'Go'
 
     if re.match(r'\.h.*$', extension, re.IGNORECASE) or re.match(r'\.c.*$', extension, re.IGNORECASE):
 
@@ -184,8 +186,12 @@ def get_language_from_extension(file_name):
             return 'Objective-C++'
 
         available_extensions = extensions_in_same_folder(file_name)
-        if '.cpp' in available_extensions:
-            return 'C++'
+
+        for ext in CppLexer.filenames:
+            ext = ext.lstrip('*')
+            if ext in available_extensions:
+                return 'C++'
+
         if '.c' in available_extensions:
             return 'C'
 
@@ -222,22 +228,21 @@ def number_lines_in_file(file_name):
 def standardize_language(language, plugin):
     """Maps a string to the equivalent Pygments language.
 
-    Returns a tuple of (language_str, lexer_obj).
+    Returns the standardized language string.
     """
 
     if not language:
-        return None, None
+        return None
 
     # standardize language for this plugin
     if plugin:
         plugin = plugin.split(' ')[-1].split('/')[0].split('-')[0]
         standardized = get_language_from_json(language, plugin)
         if standardized is not None:
-            return standardized, get_lexer(standardized)
+            return standardized
 
     # standardize language against default languages
-    standardized = get_language_from_json(language, 'default')
-    return standardized, get_lexer(standardized)
+    return get_language_from_json(language, 'default')
 
 
 def get_lexer(language):

packages/wakatime/utils.py

@@ -26,6 +26,7 @@ log = logging.getLogger('WakaTime')
 
 BACKSLASH_REPLACE_PATTERN = re.compile(r'[\\/]+')
 WINDOWS_DRIVE_PATTERN = re.compile(r'^[a-z]:/')
+WINDOWS_NETWORK_MOUNT_PATTERN = re.compile(r'^\\{2}[a-z]+', re.IGNORECASE)
 
 
 def should_exclude(entity, include, exclude):
@@ -77,10 +78,16 @@ def format_file_path(filepath):
     """Formats a path as absolute and with the correct platform separator."""
 
     try:
+        is_windows_network_mount = WINDOWS_NETWORK_MOUNT_PATTERN.match(filepath)
         filepath = os.path.realpath(os.path.abspath(filepath))
         filepath = re.sub(BACKSLASH_REPLACE_PATTERN, '/', filepath)
-        if WINDOWS_DRIVE_PATTERN.match(filepath):
+        is_windows_drive = WINDOWS_DRIVE_PATTERN.match(filepath)
+        if is_windows_drive:
             filepath = filepath.capitalize()
+        if is_windows_network_mount:
+            # Add back a / to the front, since the previous modifications
+            # will have replaced any double slashes with single
+            filepath = '/' + filepath
     except:
         pass
     return filepath