v1.4.9

HISTORY.rst

@@ -3,6 +3,18 @@ History
 -------
 
 
+1.4.9 (2013-10-28)
+++++++++++++++++++
+
+- handle case where ignore patterns not defined
+
+
+1.4.8 (2013-10-27)
+++++++++++++++++++
+
+- new setting to ignore files that match a regular expression pattern
+
+
 1.4.7 (2013-10-26)
 ++++++++++++++++++
 

WakaTime.py

@@ -5,7 +5,7 @@ Maintainer:  WakaTi.me <support@wakatime.com>
 Website:     https://www.wakati.me/
 ==========================================================="""
 
-__version__ = '1.4.7'
+__version__ = '1.4.9'
 
 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'):
@@ -107,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):
@@ -151,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:
@@ -182,7 +150,8 @@ class SendActionThread(threading.Thread):
 
 
 def plugin_loaded():
-    setup_settings_file()
+    global SETTINGS
+    SETTINGS = sublime.load_settings(SETTINGS_FILE)
     after_loaded()
 
 
@@ -199,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,13 @@ 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)
 ++++++++++++++++++
 

packages/wakatime/wakatime/__init__.py

@@ -12,7 +12,7 @@
 from __future__ import print_function
 
 __title__ = 'wakatime'
-__version__ = '0.4.8'
+__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,38 @@ 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
+def should_ignore(fileName, patterns):
     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
+        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))
+    except TypeError:
+        pass
+    return False
 
 
 def get_user_agent(plugin):
@@ -189,6 +232,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 +255,3 @@ def main(argv=None):
     else:
         log.debug('File does not exist; ignoring this action.')
     return 101
-