v1.4.8

HISTORY.rst

@@ -0,0 +1,206 @@
+
+History
+-------
+
+
+1.4.8 (2013-10-27)
+++++++++++++++++++
+
+- new setting to ignore files that match a regular expression pattern
+
+
+1.4.7 (2013-10-26)
+++++++++++++++++++
+
+- simplify some language lexer names into more common versions
+
+
+1.4.6 (2013-10-25)
+++++++++++++++++++
+
+- force some file extensions to be recognized as certain language
+
+
+1.4.5 (2013-10-14)
+++++++++++++++++++
+
+- remove support for subversion projects on Windows to prevent cmd window popups
+- ignore all errors from pygments library
+
+
+1.4.4 (2013-10-13)
+++++++++++++++++++
+
+- read git branch from .git/HEAD without running command line git client
+
+
+1.4.3 (2013-09-30)
+++++++++++++++++++
+
+- send olson timezone string to api for displaying logged time in user's zone
+
+
+1.4.2 (2013-09-30)
+++++++++++++++++++
+
+- print error code in Sublime's console if api request fails
+
+
+1.4.1 (2013-09-30)
+++++++++++++++++++
+
+- fix SSL support problem for Linux users
+
+
+1.4.0 (2013-09-22)
+++++++++++++++++++
+
+- log source code language type of files
+- log total number of lines in files
+- better python3 support
+
+
+1.3.7 (2013-09-07)
+++++++++++++++++++
+
+- fix relative import bug
+
+
+1.3.6 (2013-09-06)
+++++++++++++++++++
+
+- switch back to urllib2 instead of requests library in wakatime package
+
+
+1.3.5 (2013-09-05)
+++++++++++++++++++
+
+- send Sublime version with api requests for easier debugging
+
+
+1.3.4 (2013-09-04)
+++++++++++++++++++
+
+- upgraded wakatime package
+
+
+1.3.3 (2013-09-04)
+++++++++++++++++++
+
+- using requests package in wakatime package
+
+
+1.3.2 (2013-08-25)
+++++++++++++++++++
+
+- fix bug causing wrong file name detected
+- misc bug fixes
+
+
+1.3.0 (2013-08-15)
+++++++++++++++++++
+
+- detect git branches
+
+
+1.2.0 (2013-08-12)
+++++++++++++++++++
+
+- run wakatime package in new process when no SSL support in Sublime
+
+
+1.1.0 (2013-08-12)
+++++++++++++++++++
+
+- run wakatime package in main Sublime process
+
+
+1.0.1 (2013-08-09)
+++++++++++++++++++
+
+- no longer beta for Package Control versioning requirement
+
+
+0.4.2 (2013-08-08)
+++++++++++++++++++
+
+- remove away prompt popup
+
+
+0.4.0 (2013-08-08)
+++++++++++++++++++
+
+- run wakatime package in background
+
+
+0.3.3 (2013-08-06)
+++++++++++++++++++
+
+- support installing via Sublime Package Control
+
+
+0.3.2 (2013-08-06)
+++++++++++++++++++
+
+- fixes for user sublime-settings file
+
+
+0.3.1 (2013-08-04)
+++++++++++++++++++
+
+- renamed plugin folder
+
+
+0.3.0 (2013-08-04)
+++++++++++++++++++
+
+- use WakaTime.sublime-settings file for configuration settings
+
+
+0.2.10 (2013-07-29)
++++++++++++++++++++
+
+- Python3 support
+- better Windows support by detecting pythonw.exe location
+
+
+0.2.9 (2013-07-22)
+++++++++++++++++++
+
+- upgraded wakatime package
+- bug fix when detecting git repos
+
+
+0.2.8 (2013-07-21)
+++++++++++++++++++
+
+- Windows bug fixes
+
+
+0.2.7 (2013-07-20)
+++++++++++++++++++
+
+- prevent cmd window opening in background (Windows users only)
+
+
+0.2.6 (2013-07-17)
+++++++++++++++++++
+
+- log errors from wakatime package to ~/.wakatime.log
+
+
+0.2.5 (2013-07-17)
+++++++++++++++++++
+
+- distinguish between write events and normal events
+- prompt user for api key if one does not already exist
+- rename ~/.wakatime to ~/.wakatime.conf
+- set away prompt to 5 minutes
+- fix bug in custom logger
+
+
+0.2.1 (2013-07-07)
+++++++++++++++++++
+
+- Birth
+

README.md

@@ -1,7 +1,7 @@
 sublime-wakatime
 ================
 
-Automatic time tracking for Sublime Text 2 & 3.
+Fully automatic time tracking for Sublime Text 2 & 3.
 
 Installation
 ------------
@@ -29,9 +29,5 @@ Heads Up! For Sublime Text 2 on Windows & Linux, WakaTime depends on [Python](ht
 Screen Shots
 ------------
 
-![Project Overview](https://www.wakati.me/static/img/ScreenShots/Screenshot%20from%202013-06-26%2001:12:59.png)
-
-![Files in a Project](https://www.wakati.me/static/img/ScreenShots/Screenshot%20from%202013-06-26%2001:13:13.png)
-
-![Changing Date Range](https://www.wakati.me/static/img/ScreenShots/Screenshot%20from%202013-06-26%2001:13:53.png)
+![Project Overview](https://www.wakati.me/static/img/ScreenShots/Screen Shot 2013-10-26 at 5.04.01 PM.png)
 

WakaTime.py

@@ -5,7 +5,7 @@ Maintainer:  WakaTi.me <support@wakatime.com>
 Website:     https://www.wakati.me/
 ==========================================================="""
 
-__version__ = '1.4.3'
+__version__ = '1.4.8'
 
 import sublime
 import sublime_plugin
@@ -47,31 +47,6 @@ if HAS_SSL:
     import wakatime
 
 
-def setup_settings_file():
-    """ Convert ~/.wakatime.conf to WakaTime.sublime-settings
-    """
-    global SETTINGS
-    # To be backwards compatible, rename config file
-    SETTINGS = sublime.load_settings(SETTINGS_FILE)
-    api_key = SETTINGS.get('api_key', '')
-    if not api_key:
-        api_key = ''
-        try:
-            with open(join(expanduser('~'), '.wakatime.conf')) as old_file:
-                for line in old_file:
-                    line = line.split('=', 1)
-                    if line[0] == 'api_key':
-                        api_key = str(line[1].strip())
-            try:
-                os.remove(join(expanduser('~'), '.wakatime.conf'))
-            except:
-                pass
-        except IOError:
-            pass
-    SETTINGS.set('api_key', api_key)
-    sublime.save_settings(SETTINGS_FILE)
-
-
 def prompt_api_key():
     global SETTINGS
     if not SETTINGS.get('api_key'):
@@ -89,17 +64,16 @@ def prompt_api_key():
 
 
 def python_binary():
-    python = 'python'
     if platform.system() == 'Windows':
-        python = 'pythonw'
         try:
-            Popen([python, '--version'])
+            Popen(['pythonw', '--version'])
+            return 'pythonw'
         except:
             for path in glob.iglob('/python*'):
                 if exists(realpath(join(path, 'pythonw.exe'))):
-                    python = realpath(join(path, 'pythonw'))
-                    break
-    return python
+                    return realpath(join(path, 'pythonw'))
+            return None
+    return 'python'
 
 
 def enough_time_passed(now):
@@ -108,41 +82,32 @@ def enough_time_passed(now):
     return False
 
 
-def handle_write_action(view):
+def handle_action(view, is_write=False):
     global LOCK, LAST_FILE, LAST_ACTION
     with LOCK:
-        targetFile = view.file_name()
-        thread = SendActionThread(targetFile, isWrite=True)
+        target_file = view.file_name()
+        thread = SendActionThread(target_file, is_write=is_write)
         thread.start()
-        LAST_FILE = targetFile
-        LAST_ACTION = time.time()
-
-
-def handle_normal_action(view):
-    global LOCK, LAST_FILE, LAST_ACTION
-    with LOCK:
-        targetFile = view.file_name()
-        thread = SendActionThread(targetFile)
-        thread.start()
-        LAST_FILE = targetFile
+        LAST_FILE = target_file
         LAST_ACTION = time.time()
 
 
 class SendActionThread(threading.Thread):
 
-    def __init__(self, targetFile, isWrite=False, force=False):
+    def __init__(self, target_file, is_write=False, force=False):
         threading.Thread.__init__(self)
-        self.targetFile = targetFile
-        self.isWrite = isWrite
+        self.target_file = target_file
+        self.is_write = is_write
         self.force = force
         self.debug = SETTINGS.get('debug')
         self.api_key = SETTINGS.get('api_key', '')
+        self.ignore = SETTINGS.get('ignore', [])
         self.last_file = LAST_FILE
 
     def run(self):
-        if self.targetFile:
+        if self.target_file:
             self.timestamp = time.time()
-            if self.force or self.isWrite or self.targetFile != self.last_file or enough_time_passed(self.timestamp):
+            if self.force or self.is_write or self.target_file != self.last_file or enough_time_passed(self.timestamp):
                 self.send()
 
     def send(self):
@@ -152,13 +117,15 @@ class SendActionThread(threading.Thread):
         ua = 'sublime/%d sublime-wakatime/%s' % (ST_VERSION, __version__)
         cmd = [
             API_CLIENT,
-            '--file', self.targetFile,
+            '--file', self.target_file,
             '--time', str('%f' % self.timestamp),
             '--plugin', ua,
             '--key', str(bytes.decode(self.api_key.encode('utf8'))),
         ]
-        if self.isWrite:
+        if self.is_write:
             cmd.append('--write')
+        for pattern in self.ignore:
+            cmd.extend(['--ignore', pattern])
         if self.debug:
             cmd.append('--verbose')
         if HAS_SSL:
@@ -168,18 +135,23 @@ class SendActionThread(threading.Thread):
             if code != 0:
                 print('Error: Response code %d from wakatime package' % code)
         else:
-            cmd.insert(0, python_binary())
-            if self.debug:
-                print(cmd)
-            if platform.system() == 'Windows':
-                Popen(cmd, shell=False)
+            python = python_binary()
+            if python:
+                cmd.insert(0, python)
+                if self.debug:
+                    print(cmd)
+                if platform.system() == 'Windows':
+                    Popen(cmd, shell=False)
+                else:
+                    with open(join(expanduser('~'), '.wakatime.log'), 'a') as stderr:
+                        Popen(cmd, stderr=stderr)
             else:
-                with open(join(expanduser('~'), '.wakatime.log'), 'a') as stderr:
-                    Popen(cmd, stderr=stderr)
+                print('Error: Unable to find python binary.')
 
 
 def plugin_loaded():
-    setup_settings_file()
+    global SETTINGS
+    SETTINGS = sublime.load_settings(SETTINGS_FILE)
     after_loaded()
 
 
@@ -196,10 +168,10 @@ if ST_VERSION < 3000:
 class WakatimeListener(sublime_plugin.EventListener):
 
     def on_post_save(self, view):
-        handle_write_action(view)
+        handle_action(view, is_write=True)
 
     def on_activated(self, view):
-        handle_normal_action(view)
+        handle_action(view)
 
     def on_modified(self, view):
-        handle_normal_action(view)
+        handle_action(view)

WakaTime.sublime-settings

@@ -7,6 +7,10 @@
     // Set this in your User specific WakaTime.sublime-settings file.
     "api_key": "",
     
+    // Ignore files; Files (including absolute paths) that match one of these
+    // POSIX regular expressions will not be logged.
+    "ignore": ["^/tmp/", "^/etc/", "^/var/"],
+    
     // Debug mode. Set to true for verbose logging. Defaults to false.
     "debug": false
 }

packages/wakatime/HISTORY.rst

@@ -3,6 +3,25 @@ History
 -------
 
 
+0.4.9 (2013-10-27)
+++++++++++++++++++
+
+- New config for ignoring files from regular expressions
+- Parse more options from config file (verbose, logfile, ignore)
+
+
+0.4.8 (2013-10-13)
+++++++++++++++++++
+
+- Read git HEAD file to find current branch instead of running git command line
+
+
+0.4.7 (2013-09-30)
+++++++++++++++++++
+
+- Sending local olson timezone string in api request
+
+
 0.4.6 (2013-09-22)
 ++++++++++++++++++
 

packages/wakatime/wakatime/__init__.py

@@ -12,7 +12,7 @@
 from __future__ import print_function
 
 __title__ = 'wakatime'
-__version__ = '0.4.7'
+__version__ = '0.4.9'
 __author__ = 'Alan Hamlett'
 __license__ = 'BSD'
 __copyright__ = 'Copyright 2013 Alan Hamlett'
@@ -52,6 +52,38 @@ class FileAction(argparse.Action):
         setattr(namespace, self.dest, values)
 
 
+def parseConfigFile(configFile):
+    if not configFile:
+        configFile = os.path.join(os.path.expanduser('~'), '.wakatime.conf')
+
+    # define default config values
+    configs = {
+        'api_key': None,
+        'ignore': [],
+        'verbose': False,
+    }
+
+    try:
+        with open(configFile) as fh:
+            for line in fh:
+                line = line.split('=', 1)
+                if len(line) == 2 and line[0].strip() and line[1].strip():
+                    line[0] = line[0].strip()
+                    line[1] = 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]
+    except IOError:
+        print('Error: Could not read from config file ~/.wakatime.conf')
+    return configs
+
+
 def parseArguments(argv):
     try:
         sys.argv
@@ -75,6 +107,8 @@ def parseArguments(argv):
     parser.add_argument('--key', dest='key',
             help='your wakati.me api key; uses api_key from '+
                 '~/.wakatime.conf by default')
+    parser.add_argument('--ignore', dest='ignore', action='append',
+            help='filename patterns to ignore; POSIX regex syntax; can be used more than once')
     parser.add_argument('--logfile', dest='logfile',
             help='defaults to ~/.wakatime.log')
     parser.add_argument('--config', dest='config',
@@ -85,29 +119,35 @@ def parseArguments(argv):
     args = parser.parse_args(args=argv[1:])
     if not args.timestamp:
         args.timestamp = time.time()
+
+    # set arguments from config file
+    configs = parseConfigFile(args.config)
     if not args.key:
-        default_key = get_api_key(args.config)
+        default_key = configs.get('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:
+            args.ignore = []
+        args.ignore.append(pattern)
+    if not args.verbose and 'verbose' in configs:
+        args.verbose = configs['verbose']
+    if not args.logfile and 'logfile' in configs:
+        args.logfile = configs['logfile']
     return args
 
 
-def get_api_key(configFile):
-    if not configFile:
-        configFile = os.path.join(os.path.expanduser('~'), '.wakatime.conf')
-    api_key = None
-    try:
-        cf = open(configFile)
-        for line in cf:
-            line = line.split('=', 1)
-            if line[0] == 'api_key':
-                api_key = line[1].strip()
-        cf.close()
-    except IOError:
-        print('Error: Could not read from config file.')
-    return api_key
+def should_ignore(fileName, patterns):
+    for pattern in patterns:
+        try:
+            compiled = re.compile(pattern, re.IGNORECASE)
+            if compiled.search(fileName):
+                return pattern
+        except re.error as ex:
+            log.warning('Regex error (%s) for ignore pattern: %s' % (str(ex), pattern))
+    return False
 
 
 def get_user_agent(plugin):
@@ -189,6 +229,10 @@ def main(argv=None):
         argv = sys.argv
     args = parseArguments(argv)
     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
@@ -208,4 +252,3 @@ def main(argv=None):
     else:
         log.debug('File does not exist; ignoring this action.')
     return 101
-

packages/wakatime/wakatime/projects/git.py

@@ -11,7 +11,6 @@
 
 import logging
 import os
-from subprocess import Popen, PIPE
 
 from .base import BaseProject
 try:
@@ -38,23 +37,16 @@ class Git(BaseProject):
         return None
 
     def branch(self):
-        stdout = None
-        try:
-            stdout, stderr = Popen([
-                    'git', 'branch', '--no-color'
-                ], stdout=PIPE, stderr=PIPE, cwd=self._project_base()
-            ).communicate()
-        except OSError:
-            pass
-        if stdout:
-            for line in stdout.splitlines():
-                if isinstance(line, bytes):
-                    line = bytes.decode(line)
-                line = line.split(' ', 1)
-                if line[0] == '*':
-                    return line[1]
-        return None
-
+        branch = None
+        base = self._project_base()
+        if base:
+            head = os.path.join(self._project_base(), '.git', 'HEAD')
+            try:
+                with open(head) as f:
+                    branch = f.readline().strip().rsplit('/', 1)[-1]
+            except IOError:
+                pass
+        return branch
 
     def _project_base(self):
         if self.config:

packages/wakatime/wakatime/projects/subversion.py

@@ -11,6 +11,7 @@
 
 import logging
 import os
+import platform
 from subprocess import Popen, PIPE
 
 from .base import BaseProject
@@ -62,6 +63,8 @@ class Subversion(BaseProject):
         return info
 
     def _find_project_base(self, path, found=False):
+        if platform.system() == 'Windows':
+            return False
         path = os.path.realpath(path)
         if os.path.isfile(path):
             path = os.path.split(path)[0]

packages/wakatime/wakatime/stats.py

@@ -18,25 +18,58 @@ if sys.version_info[0] == 2:
 else:
     sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), 'packages', 'pygments3'))
 from pygments.lexers import guess_lexer_for_filename
-from pygments.util import ClassNotFound
 
 
 log = logging.getLogger(__name__)
 
 
+# force file name extensions to be recognized as a certain language
+EXTENSIONS = {
+    'md': 'Markdown',
+}
+TRANSLATIONS = {
+    'CSS+Genshi Text': 'CSS',
+    'CSS+Lasso': 'CSS',
+    'HTML+Django/Jinja': 'HTML',
+    'HTML+Lasso': 'HTML',
+    'JavaScript+Genshi Text': 'JavaScript',
+    'JavaScript+Lasso': 'JavaScript',
+    'Perl6': 'Perl',
+}
+
+
 def guess_language(file_name):
+    if file_name:
+        language = guess_language_from_extension(file_name.rsplit('.', 1)[-1])
+        if language:
+            return language
     lexer = None
     try:
         with open(file_name) as f:
             lexer = guess_lexer_for_filename(file_name, f.read(512000))
-    except (ClassNotFound, IOError):
+    except:
         pass
     if lexer:
-        return str(lexer.name)
+        return translate_language(str(lexer.name))
     else:
         return None
 
 
+def guess_language_from_extension(extension):
+    if extension:
+        if extension in EXTENSIONS:
+            return EXTENSIONS[extension]
+        if extension.lower() in EXTENSIONS:
+            return mapping[EXTENSIONS.lower()]
+    return None
+
+
+def translate_language(language):
+    if language in TRANSLATIONS:
+        language = TRANSLATIONS[language]
+    return language
+
+
 def number_lines_in_file(file_name):
     lines = 0
     try: