v1.6.4

HISTORY.rst

@@ -3,6 +3,38 @@ History
 -------
 
 
+1.6.4 (2014-02-05)
+++++++++++++++++++
+
+- upgrade external wakatime package to v1.0.0
+- support for mercurial revision control
+
+
+1.6.3 (2014-01-15)
+++++++++++++++++++
+
+- upgrade common wakatime package to v0.5.3
+
+
+1.6.2 (2014-01-14)
+++++++++++++++++++
+
+- upgrade common wakatime package to v0.5.2
+
+
+1.6.1 (2013-12-13)
+++++++++++++++++++
+
+- upgrade common wakatime package to v0.5.1
+- second line in .wakatime-project now sets branch name
+
+
+1.6.0 (2013-12-13)
+++++++++++++++++++
+
+- upgrade common wakatime package to v0.5.0
+
+
 1.5.2 (2013-12-03)
 ++++++++++++++++++
 

WakaTime.py

@@ -5,7 +5,7 @@ Maintainer:  WakaTi.me <support@wakatime.com>
 Website:     https://www.wakati.me/
 ==========================================================="""
 
-__version__ = '1.5.2'
+__version__ = '1.6.4'
 
 import sublime
 import sublime_plugin
@@ -59,10 +59,10 @@ def prompt_api_key():
                 sublime.save_settings(SETTINGS_FILE)
         window = sublime.active_window()
         if window:
-            window.show_input_panel('Enter your WakaTime api key:', '', got_key, None, None)
+            window.show_input_panel('[WakaTime] Enter your wakatime.com api key:', '', got_key, None, None)
             return True
         else:
-            print('Error: Could not prompt for api key because no window found.')
+            print('[WakaTime] Error: Could not prompt for api key because no window found.')
     return False
 
 
@@ -119,7 +119,7 @@ class SendActionThread(threading.Thread):
 
     def send(self):
         if not self.api_key:
-            print('missing api key')
+            print('[WakaTime] Error: missing api key.')
             return
         ua = 'sublime/%d sublime-wakatime/%s' % (ST_VERSION, __version__)
         cmd = [
@@ -140,7 +140,7 @@ class SendActionThread(threading.Thread):
                 print(cmd)
             code = wakatime.main(cmd)
             if code != 0:
-                print('Error: Response code %d from wakatime package' % code)
+                print('[WakaTime] Error: Response code %d from wakatime package.' % code)
         else:
             python = python_binary()
             if python:
@@ -153,7 +153,7 @@ class SendActionThread(threading.Thread):
                     with open(join(expanduser('~'), '.wakatime.log'), 'a') as stderr:
                         Popen(cmd, stderr=stderr)
             else:
-                print('Error: Unable to find python binary.')
+                print('[WakaTime] Error: Unable to find python binary.')
 
 
 def plugin_loaded():

packages/wakatime/AUTHORS

@@ -0,0 +1,15 @@
+WakaTime is written and maintained by Alan Hamlett and
+various contributors:
+
+
+Development Lead
+----------------
+
+- Alan Hamlett <alan.hamlett@gmail.com>
+
+
+Patches and Suggestions
+-----------------------
+
+- 3onyc <3onyc@x3tech.com>
+- userid <xixico@ymail.com>

packages/wakatime/HISTORY.rst

@@ -3,6 +3,37 @@ History
 -------
 
 
+1.0.0 (2014-02-05)
+++++++++++++++++++
+
+- detect project name and branch name from mercurial revision control
+
+
+0.5.3 (2014-01-15)
+++++++++++++++++++
+
+- bug fix for unicode in Python3
+
+
+0.5.2 (2014-01-14)
+++++++++++++++++++
+
+- minor bug fix for Subversion on non-English systems
+
+
+0.5.1 (2013-12-13)
+++++++++++++++++++
+
+- second line in .wakatime-project file now sets branch name
+
+
+0.5.0 (2013-12-13)
+++++++++++++++++++
+
+- Convert ~/.wakatime.conf to ~/.wakatime.cfg and use configparser format
+- new [projectmap] section in cfg file for naming projects based on folders
+
+
 0.4.10 (2013-11-13)
 +++++++++++++++++++
 

packages/wakatime/README.rst

@@ -1,9 +1,11 @@
 WakaTime
 ========
 
-Automatic time tracking for your text editor. This is the command line
+Fully automatic time tracking for your text editor.
-event appender for the WakaTime api. You shouldn't need to directly
+
-use this outside of a text editor plugin.
+This is the common interface for the WakaTime api. You shouldn't need to directly use this package unless you are creating a new plugin.
+
+Go to http://wakatime.com to install the plugin for your text editor.
 
 
 Installation

packages/wakatime/wakatime-cli.py

@@ -3,7 +3,7 @@
     wakatime-cli
     ~~~~~~~~~~~~
 
-    Action event appender for Wakati.Me, auto time tracking for text editors.
+    Command-line entry point.
 
     :copyright: (c) 2013 Alan Hamlett.
     :license: BSD, see LICENSE for more details.

packages/wakatime/wakatime/__init__.py

@@ -3,7 +3,8 @@
     wakatime
     ~~~~~~~~
 
-    Action event appender for Wakati.Me, auto time tracking for text editors.
+    Common interface to the WakaTime api.
+    http://wakatime.com
 
     :copyright: (c) 2013 Alan Hamlett.
     :license: BSD, see LICENSE for more details.
@@ -12,7 +13,7 @@
 from __future__ import print_function
 
 __title__ = 'wakatime'
-__version__ = '0.4.10'
+__version__ = '1.0.0'
 __author__ = 'Alan Hamlett'
 __license__ = 'BSD'
 __copyright__ = 'Copyright 2013 Alan Hamlett'
@@ -26,6 +27,15 @@ import re
 import sys
 import time
 import traceback
+try:
+    import ConfigParser as configparser
+except ImportError:
+    import configparser
+try:
+    from urllib2 import HTTPError, Request, urlopen
+except ImportError:
+    from urllib.error import HTTPError
+    from urllib.request import Request, urlopen
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), 'packages'))
@@ -35,11 +45,6 @@ from .stats import get_file_stats
 from .packages import argparse
 from .packages import simplejson as json
 from .packages import tzlocal
-try:
-    from urllib2 import HTTPError, Request, urlopen
-except ImportError:
-    from urllib.error import HTTPError
-    from urllib.request import Request, urlopen
 
 
 log = logging.getLogger(__name__)
@@ -52,48 +57,84 @@ class FileAction(argparse.Action):
         setattr(namespace, self.dest, values)
 
 
-def parseConfigFile(configFile):
+def upgradeConfigFile(configFile):
-    if not configFile:
+    """For backwards-compatibility, upgrade the existing config file
-        configFile = os.path.join(os.path.expanduser('~'), '.wakatime.conf')
+    to work with configparser and rename from .wakatime.conf to .wakatime.cfg.
+    """
 
-    # define default config values
+    if os.path.isfile(configFile):
-    configs = {
+        # if upgraded cfg file already exists, don't overwrite it
-        'api_key': None,
+        return
-        'ignore': [],
-        'verbose': False,
-    }
-
-    if not os.path.isfile(configFile):
-        return configs
 
+    oldConfig = os.path.join(os.path.expanduser('~'), '.wakatime.conf')
     try:
-        with open(configFile) as fh:
+        configs = {
-            for line in fh:
+            'ignore': [],
+        }
+
+        with open(oldConfig) as fh:
+            for line in fh.readlines():
                 line = line.split('=', 1)
                 if len(line) == 2 and line[0].strip() and line[1].strip():
-                    line[0] = line[0].strip()
+                    if line[0].strip() == 'ignore':
-                    line[1] = line[1].strip()
+                        configs['ignore'].append(line[1].strip())
-                    if line[0] in configs:
-                        if isinstance(configs[line[0]], list):
-                            configs[line[0]].append(line[1])
-                        elif isinstance(configs[line[0]], bool):
-                            configs[line[0]] = True if line[1].lower() == 'true' else False
-                        else:
-                            configs[line[0]] = line[1]
                     else:
-                        configs[line[0]] = line[1]
+                        configs[line[0].strip()] = line[1].strip()
+
+        with open(configFile, 'w') as fh:
+            fh.write("[settings]\n")
+            for name, value in configs.items():
+                if isinstance(value, list):
+                    fh.write("%s=\n" % name)
+                    for item in value:
+                        fh.write("    %s\n" % item)
+                else:
+                    fh.write("%s = %s\n" % (name, value))
+
+        os.remove(oldConfig)
     except IOError:
-        print('Error: Could not read from config file ~/.wakatime.conf')
+        pass
+
+
+def parseConfigFile(configFile):
+    """Returns a configparser.SafeConfigParser instance with configs
+    read from the config file. Default location of the config file is
+    at ~/.wakatime.cfg.
+    """
+
+    if not configFile:
+        configFile = os.path.join(os.path.expanduser('~'), '.wakatime.cfg')
+
+    upgradeConfigFile(configFile)
+
+    configs = configparser.SafeConfigParser()
+    try:
+        with open(configFile) as fh:
+            try:
+                configs.readfp(fh)
+            except configparser.Error:
+                print(traceback.format_exc())
+                return None
+    except IOError:
+        if not os.path.isfile(configFile):
+            print('Error: Could not read from config file ~/.wakatime.conf')
     return configs
 
 
 def parseArguments(argv):
+    """Parse command line arguments and configs from ~/.wakatime.cfg.
+    Command line arguments take precedence over config file settings.
+    Returns instances of ArgumentParser and SafeConfigParser.
+    """
+
     try:
         sys.argv
     except AttributeError:
         sys.argv = argv
+
+    # define supported command line arguments
     parser = argparse.ArgumentParser(
-            description='Wakati.Me event api appender')
+            description='Common interface for the WakaTime api.')
     parser.add_argument('--file', dest='targetFile', metavar='file',
             action=FileAction, required=True,
             help='absolute path to file for current action')
@@ -119,27 +160,45 @@ def parseArguments(argv):
     parser.add_argument('--verbose', dest='verbose', action='store_true',
             help='turns on debug messages in log file')
     parser.add_argument('--version', action='version', version=__version__)
+
+    # parse command line arguments
     args = parser.parse_args(args=argv[1:])
+
+    # use current unix epoch timestamp by default
     if not args.timestamp:
         args.timestamp = time.time()
 
-    # set arguments from config file
+    # parse ~/.wakatime.cfg file
     configs = parseConfigFile(args.config)
+    if configs is None:
+        return args, configs
+
+    # update args from configs
     if not args.key:
-        default_key = configs.get('api_key')
+        default_key = None
+        if configs.has_option('settings', 'api_key'):
+            default_key = configs.get('settings', 'api_key')
         if default_key:
             args.key = default_key
         else:
             parser.error('Missing api key')
-    for pattern in configs.get('ignore', []):
+    if not args.ignore:
-        if not args.ignore:
+        args.ignore = []
-            args.ignore = []
+    if configs.has_option('settings', 'ignore'):
-        args.ignore.append(pattern)
+        try:
-    if not args.verbose and 'verbose' in configs:
+            for pattern in configs.get('settings', 'ignore').split("\n"):
-        args.verbose = configs['verbose']
+                if pattern.strip() != '':
-    if not args.logfile and 'logfile' in configs:
+                    args.ignore.append(pattern)
-        args.logfile = configs['logfile']
+        except TypeError:
-    return args
+            pass
+    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'):
+        args.verbose = configs.getboolean('settings', 'debug')
+    if not args.logfile and configs.has_option('settings', 'logfile'):
+        args.logfile = configs.get('settings', 'logfile')
+
+    return args, configs
 
 
 def should_ignore(fileName, patterns):
@@ -233,28 +292,39 @@ def send_action(project=None, branch=None, stats={}, key=None, targetFile=None,
 def main(argv=None):
     if not argv:
         argv = sys.argv
-    args = parseArguments(argv)
+
+    args, configs = parseArguments(argv)
+    if configs is None:
+        return 103 # config file parsing error
+
     setup_logging(args, __version__)
+
     ignore = should_ignore(args.targetFile, args.ignore)
     if ignore is not False:
         log.debug('File ignored because matches pattern: %s' % ignore)
         return 0
+
     if os.path.isfile(args.targetFile):
-        branch = None
+
-        name = None
         stats = get_file_stats(args.targetFile)
-        project = find_project(args.targetFile)
+
+        project = find_project(args.targetFile, configs=configs)
+        branch = None
+        project_name = None
         if project:
             branch = project.branch()
-            name = project.name()
+            project_name = project.name()
+
         if send_action(
-                project=name,
+                project=project_name,
                 branch=branch,
                 stats=stats,
                 **vars(args)
             ):
-            return 0
+            return 0 # success
-        return 102
+
+        return 102 # api error
+
     else:
         log.debug('File does not exist; ignoring this action.')
-    return 101
+        return 0

packages/wakatime/wakatime/project.py

@@ -12,25 +12,34 @@
 import logging
 import os
 
-from .projects.wakatime import WakaTime
 from .projects.git import Git
 from .projects.mercurial import Mercurial
+from .projects.projectmap import ProjectMap
 from .projects.subversion import Subversion
+from .projects.wakatime import WakaTime
 
 
 log = logging.getLogger(__name__)
 
+
+# List of plugin classes to find a project for the current file path.
+# Project plugins will be processed with priority in the order below.
 PLUGINS = [
     WakaTime,
+    ProjectMap,
     Git,
     Mercurial,
     Subversion,
 ]
 
 
-def find_project(path):
+def find_project(path, configs=None):
     for plugin in PLUGINS:
-        project = plugin(path)
+        plugin_name = plugin.__name__.lower()
+        plugin_configs = None
+        if configs and configs.has_section(plugin_name):
+            plugin_configs = dict(configs.items(plugin_name))
+        project = plugin(path, configs=plugin_configs)
         if project.process():
             return project
     return None

packages/wakatime/wakatime/projects/base.py

@@ -22,18 +22,19 @@ class BaseProject(object):
     be found for the current path.
     """
 
-    def __init__(self, path):
+    def __init__(self, path, configs=None):
         self.path = path
+        self._configs = configs
 
-    def type(self):
+    def project_type(self):
         """ Returns None if this is the base class.
         Returns the type of project if this is a
         valid project.
         """
-        type = self.__class__.__name__.lower()
+        project_type = self.__class__.__name__.lower()
-        if type == 'baseproject':
+        if project_type == 'baseproject':
-            type = None
+            project_type = None
-        return type
+        return project_type
 
     def process(self):
         """ Processes self.path into a project and

packages/wakatime/wakatime/projects/git.py

@@ -13,47 +13,47 @@ import logging
 import os
 
 from .base import BaseProject
-try:
-    from collections import OrderedDict
-except ImportError:
-    from ..packages.ordereddict import OrderedDict
 
 
 log = logging.getLogger(__name__)
 
 
+# str is unicode in Python3
+try:
+    unicode
+except NameError:
+    unicode = str
+
+
 class Git(BaseProject):
 
     def process(self):
-        self.config = self._find_config(self.path)
+        self.configFile = self._find_git_config_file(self.path)
-        if self.config:
+        return self.configFile is not None
-            return True
-        return False
 
     def name(self):
         base = self._project_base()
         if base:
-            return os.path.basename(base)
+            return unicode(os.path.basename(base))
         return None
 
     def branch(self):
-        branch = None
         base = self._project_base()
         if base:
             head = os.path.join(self._project_base(), '.git', 'HEAD')
             try:
-                with open(head) as f:
+                with open(head) as fh:
-                    branch = f.readline().strip().rsplit('/', 1)[-1]
+                    return unicode(fh.readline().strip().rsplit('/', 1)[-1])
             except IOError:
                 pass
-        return branch
-
-    def _project_base(self):
-        if self.config:
-            return os.path.dirname(os.path.dirname(self.config))
         return None
 
-    def _find_config(self, path):
+    def _project_base(self):
+        if self.configFile:
+            return os.path.dirname(os.path.dirname(self.configFile))
+        return None
+
+    def _find_git_config_file(self, path):
         path = os.path.realpath(path)
         if os.path.isfile(path):
             path = os.path.split(path)[0]
@@ -62,34 +62,4 @@ class Git(BaseProject):
         split_path = os.path.split(path)
         if split_path[1] == '':
             return None
-        return self._find_config(split_path[0])
+        return self._find_git_config_file(split_path[0])
-
-    def _parse_config(self):
-        sections = {}
-        try:
-            f = open(self.config, 'r')
-        except IOError as e:
-            log.exception("Exception:")
-        else:
-            with f:
-                section = None
-                for line in f.readlines():
-                    line = line.lstrip()
-                    if len(line) > 0 and line[0] == '[':
-                        section = line[1:].split(']', 1)[0]
-                        temp = section.split(' ', 1)
-                        section = temp[0].lower()
-                        if len(temp) > 1:
-                            section = ' '.join([section, temp[1]])
-                        sections[section] = {}
-                    else:
-                        try:
-                            (setting, value) = line.split('=', 1)
-                        except ValueError:
-                            setting = line.split('#', 1)[0].split(';', 1)[0]
-                            value = 'true'
-                        setting = setting.strip().lower()
-                        value = value.split('#', 1)[0].split(';', 1)[0].strip()
-                        sections[section][setting] = value
-                f.close()
-        return sections

packages/wakatime/wakatime/projects/mercurial.py

@@ -18,13 +18,41 @@ from .base import BaseProject
 log = logging.getLogger(__name__)
 
 
+# str is unicode in Python3
+try:
+    unicode
+except NameError:
+    unicode = str
+
+
 class Mercurial(BaseProject):
 
     def process(self):
-        return False
+        self.configDir = self._find_hg_config_dir(self.path)
+        return self.configDir is not None
 
     def name(self):
+        if self.configDir:
+            return unicode(os.path.basename(os.path.dirname(self.configDir)))
         return None
 
     def branch(self):
-        return None
+        if self.configDir:
+            branch_file = os.path.join(self.configDir, 'branch')
+            try:
+                with open(branch_file) as fh:
+                    return unicode(fh.readline().strip().rsplit('/', 1)[-1])
+            except IOError:
+                pass
+        return unicode('default')
+
+    def _find_hg_config_dir(self, path):
+        path = os.path.realpath(path)
+        if os.path.isfile(path):
+            path = os.path.split(path)[0]
+        if os.path.isdir(os.path.join(path, '.hg')):
+            return os.path.join(path, '.hg')
+        split_path = os.path.split(path)
+        if split_path[1] == '':
+            return None
+        return self._find_hg_config_dir(split_path[0])

packages/wakatime/wakatime/projects/projectmap.py

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+"""
+    wakatime.projects.projectmap
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Use the ~/.wakatime.cfg file to set custom project names by
+    recursively matching folder paths.
+    Project maps go under the [projectmap] config section.
+
+    For example:
+
+        [projectmap]
+        /home/user/projects/foo = new project name
+        /home/user/projects/bar = project2
+
+    Will result in file `/home/user/projects/foo/src/main.c` to have
+    project name `new project name`.
+
+    :copyright: (c) 2013 Alan Hamlett.
+    :license: BSD, see LICENSE for more details.
+"""
+
+import logging
+import os
+
+from .base import BaseProject
+
+
+log = logging.getLogger(__name__)
+
+
+# str is unicode in Python3
+try:
+    unicode
+except NameError:
+    unicode = str
+
+
+class ProjectMap(BaseProject):
+
+    def process(self):
+        if not self._configs:
+            return False
+
+        self.project = self._find_project(self.path)
+
+        return self.project is not None
+
+    def _find_project(self, path):
+        path = os.path.realpath(path)
+        if os.path.isfile(path):
+            path = os.path.split(path)[0]
+
+        if self._configs.get(path.lower()):
+            return self._configs.get(path.lower())
+        if self._configs.get('%s/' % path.lower()):
+            return self._configs.get('%s/' % path.lower())
+        if self._configs.get('%s\\' % path.lower()):
+            return self._configs.get('%s\\' % path.lower())
+
+        split_path = os.path.split(path)
+        if split_path[1] == '':
+            return None
+        return self._find_project(split_path[0])
+
+    def branch(self):
+        return None
+
+    def name(self):
+        if self.project:
+            return unicode(self.project)
+        return None

packages/wakatime/wakatime/projects/subversion.py

@@ -24,24 +24,31 @@ except ImportError:
 log = logging.getLogger(__name__)
 
 
+# str is unicode in Python3
+try:
+    unicode
+except NameError:
+    unicode = str
+
+
 class Subversion(BaseProject):
 
     def process(self):
         return self._find_project_base(self.path)
 
     def name(self):
-        return self.info['Repository Root'].split('/')[-1]
+        return unicode(self.info['Repository Root'].split('/')[-1])
 
     def branch(self):
-        branch = None
         if self.base:
-            branch = os.path.basename(self.base)
+            unicode(os.path.basename(self.base))
-        return branch
+        return None
 
     def _get_info(self, path):
         info = OrderedDict()
         stdout = None
         try:
+            os.environ['LANG'] = 'en_US'
             stdout, stderr = Popen([
                 'svn', 'info', os.path.realpath(path)
             ], stdout=PIPE, stderr=PIPE).communicate()

packages/wakatime/wakatime/projects/wakatime.py

@@ -4,7 +4,8 @@
     ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     Information from a .wakatime-project file about the project for
-    a given file.
+    a given file. First line of .wakatime-project sets the project
+    name. Second line sets the current branch name.
 
     :copyright: (c) 2013 Alan Hamlett.
     :license: BSD, see LICENSE for more details.
@@ -19,25 +20,37 @@ from .base import BaseProject
 log = logging.getLogger(__name__)
 
 
+# str is unicode in Python3
+try:
+    unicode
+except NameError:
+    unicode = str
+
+
 class WakaTime(BaseProject):
 
     def process(self):
         self.config = self._find_config(self.path)
+        self._project_name = None
+        self._project_branch = None
+
         if self.config:
+
+            try:
+                with open(self.config) as fh:
+                    self._project_name = unicode(fh.readline().strip())
+                    self._project_branch = unicode(fh.readline().strip())
+            except IOError as e:
+                log.exception("Exception:")
+
             return True
         return False
 
     def name(self):
-        project_name = None
+        return self._project_name
-        try:
-            with open(self.config) as fh:
-                project_name = fh.readline().strip()
-        except IOError as e:
-            log.exception("Exception:")
-        return project_name
 
     def branch(self):
-        return None
+        return self._project_branch
 
     def _find_config(self, path):
         path = os.path.realpath(path)

packages/wakatime/wakatime/stats.py

@@ -28,6 +28,7 @@ EXTENSIONS = {
     'j2': 'HTML',
     'markdown': 'Markdown',
     'md': 'Markdown',
+    'twig': 'Twig',
 }
 TRANSLATIONS = {
     'CSS+Genshi Text': 'CSS',