v3.0.4

HISTORY.rst

@@ -3,6 +3,39 @@ History
 -------
 
 
+3.0.4 (2014-12-26)
+++++++++++++++++++
+
+- fix bug causing plugin to not work in Sublime Text 2
+
+
+3.0.3 (2014-12-25)
+++++++++++++++++++
+
+- upgrade external wakatime package to v3.0.3
+- detect JavaScript frameworks from script tags in Html template files
+
+
+3.0.2 (2014-12-25)
+++++++++++++++++++
+
+- upgrade external wakatime package to v3.0.2
+- detect frameworks from JavaScript and JSON files
+
+
+3.0.1 (2014-12-23)
+++++++++++++++++++
+
+- parse use namespaces from php files
+
+
+3.0.0 (2014-12-23)
+++++++++++++++++++
+
+- upgrade external wakatime package to v3.0.1
+- detect libraries and frameworks for C++, Java, .NET, PHP, and Python files
+
+
 2.0.21 (2014-12-22)
 ++++++++++++++++++
 

WakaTime.py

@@ -6,7 +6,7 @@ License:     BSD, see LICENSE for more details.
 Website:     https://wakatime.com/
 ==========================================================="""
 
-__version__ = '2.0.21'
+__version__ = '3.0.4'
 
 import sublime
 import sublime_plugin
@@ -20,7 +20,6 @@ import threading
 import uuid
 from os.path import expanduser, dirname, basename, realpath, isfile, join, exists
 
-
 # globals
 ACTION_FREQUENCY = 2
 ST_VERSION = int(sublime.version())
@@ -36,6 +35,11 @@ LAST_ACTION = {
 HAS_SSL = False
 LOCK = threading.RLock()
 
+# add wakatime package to path
+sys.path.insert(0, join(PLUGIN_DIR, 'packages', 'wakatime'))
+
+from wakatime import parseConfigFile
+
 # check if we have SSL support
 try:
     import ssl
@@ -46,13 +50,39 @@ except (ImportError, AttributeError):
     from subprocess import Popen
 
 if HAS_SSL:
-    # import wakatime package
-    sys.path.insert(0, join(PLUGIN_DIR, 'packages', 'wakatime'))
+    # import wakatime package so we can use built-in python
     import wakatime
 
 
+def createConfigFile():
+    """Creates the .wakatime.cfg INI file in $HOME directory, if it does
+    not already exist.
+    """
+    configFile = os.path.join(os.path.expanduser('~'), '.wakatime.cfg')
+    try:
+        with open(configFile) as fh:
+            pass
+    except IOError:
+        try:
+            with open(configFile, 'w') as fh:
+                fh.write("[settings]\n")
+                fh.write("debug = false\n")
+                fh.write("hidefilenames = false\n")
+        except IOError:
+            pass
+
+
 def prompt_api_key():
     global SETTINGS
+
+    createConfigFile()
+
+    default_key = ''
+    configs = parseConfigFile()
+    if configs is not None:
+        if configs.has_option('settings', 'api_key'):
+            default_key = configs.get('settings', 'api_key')
+
     if SETTINGS.get('api_key'):
         return True
     else:
@@ -62,7 +92,7 @@ def prompt_api_key():
                 sublime.save_settings(SETTINGS_FILE)
         window = sublime.active_window()
         if window:
-            window.show_input_panel('[WakaTime] Enter your wakatime.com api key:', '', got_key, None, None)
+            window.show_input_panel('[WakaTime] Enter your wakatime.com api key:', default_key, got_key, None, None)
             return True
         else:
             print('[WakaTime] Error: Could not prompt for api key because no window found.')

packages/wakatime/HISTORY.rst

@@ -3,6 +3,30 @@ History
 -------
 
 
+3.0.3 (2014-12-25)
+++++++++++++++++++
+
+- detect JavaScript frameworks from script tags in Html template files
+
+
+3.0.2 (2014-12-25)
+++++++++++++++++++
+
+- detect frameworks from JavaScript and JSON files
+
+
+3.0.1 (2014-12-23)
+++++++++++++++++++
+
+- handle unknown language when parsing dependencies
+
+
+3.0.0 (2014-12-23)
+++++++++++++++++++
+
+- detect libraries and frameworks for C++, Java, .NET, PHP, and Python files
+
+
 2.1.11 (2014-12-22)
 +++++++++++++++++++
 

packages/wakatime/wakatime/__init__.py

@@ -13,7 +13,7 @@
 from __future__ import print_function
 
 __title__ = 'wakatime'
-__version__ = '2.1.11'
+__version__ = '3.0.3'
 __author__ = 'Alan Hamlett'
 __license__ = 'BSD'
 __copyright__ = 'Copyright 2014 Alan Hamlett'
@@ -40,7 +40,7 @@ except ImportError:
 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'))
 
-from .compat import u, open, is_py2, is_py3
+from .compat import u, open, is_py3
 from .queue import Queue
 from .log import setup_logging
 from .project import find_project
@@ -102,7 +102,7 @@ def upgradeConfigFile(configFile):
         pass
 
 
-def parseConfigFile(configFile):
+def parseConfigFile(configFile=None):
     """Returns a configparser.SafeConfigParser instance with configs
     read from the config file. Default location of the config file is
     at ~/.wakatime.cfg.
@@ -251,10 +251,10 @@ def get_user_agent(plugin):
     return user_agent
 
 
-def send_action(project=None, branch=None, stats={}, key=None, targetFile=None,
+def send_heartbeat(project=None, branch=None, stats={}, key=None, targetFile=None,
         timestamp=None, isWrite=None, plugin=None, offline=None,
         hidefilenames=None, **kwargs):
-    url = 'https://wakatime.com/api/v1/actions'
+    url = 'https://wakatime.com/api/v1/heartbeats'
     log.debug('Sending heartbeat to api at %s' % url)
     data = {
         'time': timestamp,
@@ -401,7 +401,7 @@ def main(argv=None):
             branch = project.branch()
             project_name = project.name()
 
-        if send_action(
+        if send_heartbeat(
                 project=project_name,
                 branch=branch,
                 stats=stats,
@@ -412,7 +412,7 @@ def main(argv=None):
                 heartbeat = queue.pop()
                 if heartbeat is None:
                     break
-                sent = send_action(project=heartbeat['project'],
+                sent = send_heartbeat(project=heartbeat['project'],
                                    targetFile=heartbeat['file'],
                                    timestamp=heartbeat['time'],
                                    branch=heartbeat['branch'],

packages/wakatime/wakatime/compat.py

@@ -40,3 +40,38 @@ elif is_py3:
         return str(text)
     open = open
     basestring = (str, bytes)
+
+try:
+    from importlib import import_module
+except ImportError:
+    def _resolve_name(name, package, level):
+        """Return the absolute name of the module to be imported."""
+        if not hasattr(package, 'rindex'):
+            raise ValueError("'package' not set to a string")
+        dot = len(package)
+        for x in xrange(level, 1, -1):
+            try:
+                dot = package.rindex('.', 0, dot)
+            except ValueError:
+                raise ValueError("attempted relative import beyond top-level "
+                                 "package")
+        return "%s.%s" % (package[:dot], name)
+
+    def import_module(name, package=None):
+        """Import a module.
+        The 'package' argument is required when performing a relative import.
+        It specifies the package to use as the anchor point from which to
+        resolve the relative import to an absolute import.
+        """
+        if name.startswith('.'):
+            if not package:
+                raise TypeError("relative imports require the 'package' "
+                                + "argument")
+            level = 0
+            for character in name:
+                if character != '.':
+                    break
+                level += 1
+            name = _resolve_name(name[level:], package, level)
+        __import__(name)
+        return sys.modules[name]

packages/wakatime/wakatime/languages/__init__.py

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+"""
+    wakatime.languages
+    ~~~~~~~~~~~~~~~~~~
+
+    Parse dependencies from a source code file.
+
+    :copyright: (c) 2014 Alan Hamlett.
+    :license: BSD, see LICENSE for more details.
+"""
+
+import logging
+import traceback
+
+from ..compat import u, open, import_module
+
+
+log = logging.getLogger('WakaTime')
+
+
+class TokenParser(object):
+    """The base class for all dependency parsers. To add support for your
+    language, inherit from this class and implement the :meth:`parse` method
+    to return a list of dependency strings.
+    """
+    source_file = None
+    lexer = None
+    dependencies = []
+    tokens = []
+
+    def __init__(self, source_file, lexer=None):
+        self.source_file = source_file
+        self.lexer = lexer
+
+    def parse(self, tokens=[]):
+        """ Should return a list of dependencies.
+        """
+        if not tokens and not self.tokens:
+            self.tokens = self._extract_tokens()
+        raise Exception('Not yet implemented.')
+
+    def append(self, dep, truncate=False, separator=None, truncate_to=None,
+               strip_whitespace=True):
+        if dep == 'as':
+            print('***************** as')
+        self._save_dependency(
+            dep,
+            truncate=truncate,
+            truncate_to=truncate_to,
+            separator=separator,
+            strip_whitespace=strip_whitespace,
+        )
+
+    def _extract_tokens(self):
+        if self.lexer:
+            with open(self.source_file, 'r', encoding='utf-8') as fh:
+                return self.lexer.get_tokens_unprocessed(fh.read(512000))
+        return []
+
+    def _save_dependency(self, dep, truncate=False, separator=None,
+                         truncate_to=None, strip_whitespace=True):
+        if truncate:
+            if separator is None:
+                separator = u('.')
+            separator = u(separator)
+            dep = dep.split(separator)
+            if truncate_to is None or truncate_to < 0 or truncate_to > len(dep) - 1:
+                truncate_to = len(dep) - 1
+            dep = dep[0] if len(dep) == 1 else separator.join(dep[0:truncate_to])
+        if strip_whitespace:
+            dep = dep.strip()
+        if dep:
+            self.dependencies.append(dep)
+
+
+class DependencyParser(object):
+    source_file = None
+    lexer = None
+    parser = None
+
+    def __init__(self, source_file, lexer):
+        self.source_file = source_file
+        self.lexer = lexer
+
+        if self.lexer:
+            module_name = self.lexer.__module__.split('.')[-1]
+            class_name = self.lexer.__class__.__name__.replace('Lexer', 'Parser', 1)
+        else:
+            module_name = 'unknown'
+            class_name = 'UnknownParser'
+
+        try:
+            module = import_module('.%s' % module_name, package=__package__)
+            try:
+                self.parser = getattr(module, class_name)
+            except AttributeError:
+                log.debug('Module {0} is missing class {1}'.format(module.__name__, class_name))
+        except ImportError:
+            log.debug(traceback.format_exc())
+
+    def parse(self):
+        if self.parser:
+            plugin = self.parser(self.source_file, lexer=self.lexer)
+            dependencies = plugin.parse()
+            return list(set(dependencies))
+        return []

packages/wakatime/wakatime/languages/c_cpp.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+"""
+    wakatime.languages.c_cpp
+    ~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Parse dependencies from C++ code.
+
+    :copyright: (c) 2014 Alan Hamlett.
+    :license: BSD, see LICENSE for more details.
+"""
+
+from . import TokenParser
+from ..compat import u
+
+
+class CppParser(TokenParser):
+
+    def parse(self, tokens=[]):
+        if not tokens and not self.tokens:
+            self.tokens = self._extract_tokens()
+        for index, token, content in self.tokens:
+            self._process_token(token, content)
+        return self.dependencies
+
+    def _process_token(self, token, content):
+        if u(token).split('.')[-1] == 'Preproc':
+            self._process_preproc(token, content)
+        else:
+            self._process_other(token, content)
+
+    def _process_preproc(self, token, content):
+        if content.strip().startswith('include ') or content.strip().startswith("include\t"):
+            content = content.replace('include', '', 1).strip()
+            self.append(content)
+
+    def _process_other(self, token, content):
+        pass

packages/wakatime/wakatime/languages/data.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+"""
+    wakatime.languages.data
+    ~~~~~~~~~~~~~~~~~~~~~~~
+
+    Parse dependencies from data files.
+
+    :copyright: (c) 2014 Alan Hamlett.
+    :license: BSD, see LICENSE for more details.
+"""
+
+import os
+
+from . import TokenParser
+from ..compat import u
+
+
+FILES = {
+    'bower.json': {'exact': True, 'dependency': 'bower'},
+    'component.json': {'exact': True, 'dependency': 'bower'},
+    'package.json': {'exact': True, 'dependency': 'npm'},
+}
+
+
+class JsonParser(TokenParser):
+    state = None
+    level = 0
+
+    def parse(self, tokens=[]):
+        self._process_file_name(os.path.basename(self.source_file))
+        if not tokens and not self.tokens:
+            self.tokens = self._extract_tokens()
+        for index, token, content in self.tokens:
+            self._process_token(token, content)
+        return self.dependencies
+
+    def _process_file_name(self, file_name):
+        for key, value in FILES.items():
+            found = (key == file_name) if value.get('exact') else (key.lower() in file_name.lower())
+            if found:
+                self.append(value['dependency'])
+
+    def _process_token(self, token, content):
+        if u(token) == 'Token.Name.Tag':
+            self._process_tag(token, content)
+        elif u(token) == 'Token.Literal.String.Single' or u(token) == 'Token.Literal.String.Double':
+            self._process_literal_string(token, content)
+        elif u(token) == 'Token.Punctuation':
+            self._process_punctuation(token, content)
+
+    def _process_tag(self, token, content):
+        if content.strip('"').strip("'") == 'dependencies' or content.strip('"').strip("'") == 'devDependencies':
+            self.state = 'dependencies'
+        elif self.state == 'dependencies' and self.level == 2:
+            self.append(content.strip('"').strip("'"))
+
+    def _process_literal_string(self, token, content):
+        pass
+
+    def _process_punctuation(self, token, content):
+        if content == '{':
+            self.level += 1
+        elif content == '}':
+            self.level -= 1
+            if self.state is not None and self.level <= 1:
+                self.state = None

packages/wakatime/wakatime/languages/dotnet.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+"""
+    wakatime.languages.dotnet
+    ~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Parse dependencies from .NET code.
+
+    :copyright: (c) 2014 Alan Hamlett.
+    :license: BSD, see LICENSE for more details.
+"""
+
+from . import TokenParser
+from ..compat import u
+
+
+class CSharpParser(TokenParser):
+
+    def parse(self, tokens=[]):
+        if not tokens and not self.tokens:
+            self.tokens = self._extract_tokens()
+        for index, token, content in self.tokens:
+            self._process_token(token, content)
+        return self.dependencies
+
+    def _process_token(self, token, content):
+        if u(token).split('.')[-1] == 'Namespace':
+            self._process_namespace(token, content)
+        else:
+            self._process_other(token, content)
+
+    def _process_namespace(self, token, content):
+        if content != 'import' and content != 'package' and content != 'namespace':
+            self.append(content, truncate=True)
+
+    def _process_other(self, token, content):
+        pass

packages/wakatime/wakatime/languages/jvm.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+"""
+    wakatime.languages.java
+    ~~~~~~~~~~~~~~~~~~~~~~~
+
+    Parse dependencies from Java code.
+
+    :copyright: (c) 2014 Alan Hamlett.
+    :license: BSD, see LICENSE for more details.
+"""
+
+from . import TokenParser
+from ..compat import u
+
+
+class JavaParser(TokenParser):
+
+    def parse(self, tokens=[]):
+        if not tokens and not self.tokens:
+            self.tokens = self._extract_tokens()
+        for index, token, content in self.tokens:
+            self._process_token(token, content)
+        return self.dependencies
+
+    def _process_token(self, token, content):
+        if u(token).split('.')[-1] == 'Namespace':
+            self._process_namespace(token, content)
+        else:
+            self._process_other(token, content)
+
+    def _process_namespace(self, token, content):
+        if content != 'import' and content != 'package' and content != 'namespace':
+            self.append(content, truncate=True)
+
+    def _process_other(self, token, content):
+        pass

packages/wakatime/wakatime/languages/php.py

@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+"""
+    wakatime.languages.php
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    Parse dependencies from PHP code.
+
+    :copyright: (c) 2014 Alan Hamlett.
+    :license: BSD, see LICENSE for more details.
+"""
+
+from . import TokenParser
+from ..compat import u
+
+
+class PhpParser(TokenParser):
+    state = None
+    parens = 0
+
+    def parse(self, tokens=[]):
+        if not tokens and not self.tokens:
+            self.tokens = self._extract_tokens()
+        for index, token, content in self.tokens:
+            self._process_token(token, content)
+        return self.dependencies
+
+    def _process_token(self, token, content):
+        if u(token).split('.')[-1] == 'Keyword':
+            self._process_keyword(token, content)
+        elif u(token) == 'Token.Literal.String.Single' or u(token) == 'Token.Literal.String.Double':
+            self._process_literal_string(token, content)
+        elif u(token) == 'Token.Name.Other':
+            self._process_name(token, content)
+        elif u(token) == 'Token.Name.Function':
+            self._process_function(token, content)
+        elif u(token).split('.')[-1] == 'Punctuation':
+            self._process_punctuation(token, content)
+        elif u(token).split('.')[-1] == 'Text':
+            self._process_text(token, content)
+        else:
+            self._process_other(token, content)
+
+    def _process_name(self, token, content):
+        if self.state == 'use':
+            self.append(content, truncate=True, separator=u("\\"))
+
+    def _process_function(self, token, content):
+        if self.state == 'use function':
+            self.append(content, truncate=True, separator=u("\\"))
+            self.state = 'use'
+
+    def _process_keyword(self, token, content):
+        if content == 'include' or content == 'include_once' or content == 'require' or content == 'require_once':
+            self.state = 'include'
+        elif content == 'use':
+            self.state = 'use'
+        elif content == 'as':
+            self.state = 'as'
+        elif self.state == 'use' and content == 'function':
+            self.state = 'use function'
+        else:
+            self.state = None
+
+    def _process_literal_string(self, token, content):
+        if self.state == 'include':
+            if content != '"':
+                content = content.strip()
+                if u(token) == 'Token.Literal.String.Double':
+                    content = u('"{0}"').format(content)
+                self.append(content)
+                self.state = None
+
+    def _process_punctuation(self, token, content):
+        if content == '(':
+            self.parens += 1
+        elif content == ')':
+            self.parens -= 1
+        elif (self.state == 'use' or self.state == 'as') and content == ',':
+            self.state = 'use'
+        else:
+            self.state = None
+
+    def _process_text(self, token, content):
+        pass
+
+    def _process_other(self, token, content):
+        self.state = None

packages/wakatime/wakatime/languages/python.py

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+"""
+    wakatime.languages.python
+    ~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Parse dependencies from Python code.
+
+    :copyright: (c) 2014 Alan Hamlett.
+    :license: BSD, see LICENSE for more details.
+"""
+
+from . import TokenParser
+from ..compat import u
+
+
+class PythonParser(TokenParser):
+    state = None
+    parens = 0
+    nonpackage = False
+
+    def parse(self, tokens=[]):
+        if not tokens and not self.tokens:
+            self.tokens = self._extract_tokens()
+        for index, token, content in self.tokens:
+            self._process_token(token, content)
+        return self.dependencies
+
+    def _process_token(self, token, content):
+        if u(token).split('.')[-1] == 'Namespace':
+            self._process_namespace(token, content)
+        elif u(token).split('.')[-1] == 'Name':
+            self._process_name(token, content)
+        elif u(token).split('.')[-1] == 'Word':
+            self._process_word(token, content)
+        elif u(token).split('.')[-1] == 'Operator':
+            self._process_operator(token, content)
+        elif u(token).split('.')[-1] == 'Punctuation':
+            self._process_punctuation(token, content)
+        elif u(token).split('.')[-1] == 'Text':
+            self._process_text(token, content)
+        else:
+            self._process_other(token, content)
+
+    def _process_namespace(self, token, content):
+        if self.state is None:
+            self.state = content
+        else:
+            if content == 'as':
+                self.nonpackage = True
+            else:
+                self._process_import(token, content)
+
+    def _process_name(self, token, content):
+        if self.state is not None:
+            if self.nonpackage:
+                self.nonpackage = False
+            else:
+                if self.state == 'from':
+                    self.append(content, truncate=True, truncate_to=0)
+                if self.state == 'from-2' and content != 'import':
+                    self.append(content, truncate=True, truncate_to=0)
+                elif self.state == 'import':
+                    self.append(content, truncate=True, truncate_to=0)
+                elif self.state == 'import-2':
+                    self.append(content, truncate=True, truncate_to=0)
+                else:
+                    self.state = None
+
+    def _process_word(self, token, content):
+        if self.state is not None:
+            if self.nonpackage:
+                self.nonpackage = False
+            else:
+                if self.state == 'from':
+                    self.append(content, truncate=True, truncate_to=0)
+                if self.state == 'from-2' and content != 'import':
+                    self.append(content, truncate=True, truncate_to=0)
+                elif self.state == 'import':
+                    self.append(content, truncate=True, truncate_to=0)
+                elif self.state == 'import-2':
+                    self.append(content, truncate=True, truncate_to=0)
+                else:
+                    self.state = None
+
+    def _process_operator(self, token, content):
+        if self.state is not None:
+            if content == '.':
+                self.nonpackage = True
+
+    def _process_punctuation(self, token, content):
+        if content == '(':
+            self.parens += 1
+        elif content == ')':
+            self.parens -= 1
+        self.nonpackage = False
+
+    def _process_text(self, token, content):
+        if self.state is not None:
+            if content == "\n" and self.parens == 0:
+                self.state = None
+                self.nonpackage = False
+
+    def _process_other(self, token, content):
+        pass
+
+    def _process_import(self, token, content):
+        if not self.nonpackage:
+            if self.state == 'from':
+                self.append(content, truncate=True, truncate_to=0)
+                self.state = 'from-2'
+            elif self.state == 'from-2' and content != 'import':
+                self.append(content, truncate=True, truncate_to=0)
+            elif self.state == 'import':
+                self.append(content, truncate=True, truncate_to=0)
+                self.state = 'import-2'
+            elif self.state == 'import-2':
+                self.append(content, truncate=True, truncate_to=0)
+            else:
+                self.state = None
+        self.nonpackage = False

packages/wakatime/wakatime/languages/templates.py

@@ -0,0 +1,220 @@
+# -*- coding: utf-8 -*-
+"""
+    wakatime.languages.templates
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Parse dependencies from Templates.
+
+    :copyright: (c) 2014 Alan Hamlett.
+    :license: BSD, see LICENSE for more details.
+"""
+
+from . import TokenParser
+from ..compat import u
+
+
+""" If these keywords are found in the source file, treat them as a dependency.
+Must be lower-case strings.
+"""
+KEYWORDS = [
+    '_',
+    '$',
+    'angular',
+    'assert', # probably mocha
+    'backbone',
+    'batman',
+    'c3',
+    'can',
+    'casper',
+    'chai',
+    'chaplin',
+    'd3',
+    'define', # probably require
+    'describe', # mocha or jasmine
+    'eco',
+    'ember',
+    'espresso',
+    'expect', # probably jasmine
+    'exports', # probably npm
+    'express',
+    'gulp',
+    'handlebars',
+    'highcharts',
+    'jasmine',
+    'jquery',
+    'jstz',
+    'ko', # probably knockout
+    'm', # probably mithril
+    'marionette',
+    'meteor',
+    'moment',
+    'monitorio',
+    'mustache',
+    'phantom',
+    'pickadate',
+    'pikaday',
+    'qunit',
+    'react',
+    'reactive',
+    'require', # probably the commonjs spec
+    'ripple',
+    'rivets',
+    'socketio',
+    'spine',
+    'thorax',
+    'underscore',
+    'vue',
+    'way',
+    'zombie',
+]
+
+
+class LassoJavascriptParser(TokenParser):
+
+    def parse(self, tokens=[]):
+        if not tokens and not self.tokens:
+            self.tokens = self._extract_tokens()
+        for index, token, content in self.tokens:
+            self._process_token(token, content)
+        return self.dependencies
+
+    def _process_token(self, token, content):
+        if u(token) == 'Token.Name.Other':
+            self._process_name(token, content)
+        elif u(token) == 'Token.Literal.String.Single' or u(token) == 'Token.Literal.String.Double':
+            self._process_literal_string(token, content)
+
+    def _process_name(self, token, content):
+        if content.lower() in KEYWORDS:
+            self.append(content.lower())
+
+    def _process_literal_string(self, token, content):
+        if 'famous/core/' in content.strip('"').strip("'"):
+            self.append('famous')
+
+
+class HtmlDjangoParser(TokenParser):
+    tags = []
+    getting_attrs = False
+    current_attr = None
+    current_attr_value = None
+
+    def parse(self, tokens=[]):
+        if not tokens and not self.tokens:
+            self.tokens = self._extract_tokens()
+        for index, token, content in self.tokens:
+            self._process_token(token, content)
+        return self.dependencies
+
+    def _process_token(self, token, content):
+        if u(token) == 'Token.Name.Tag':
+            self._process_tag(token, content)
+        elif u(token) == 'Token.Literal.String':
+            self._process_string(token, content)
+        elif u(token) == 'Token.Name.Attribute':
+            self._process_attribute(token, content)
+
+    @property
+    def current_tag(self):
+        return None if len(self.tags) == 0 else self.tags[0]
+
+    def _process_tag(self, token, content):
+        if content.startswith('</') or content.startswith('/'):
+            self.tags.pop(0)
+            self.getting_attrs = False
+        elif content.startswith('<'):
+            self.tags.insert(0, content.replace('<', '', 1).strip().lower())
+            self.getting_attrs = True
+        elif content.startswith('>'):
+            self.getting_attrs = False
+        self.current_attr = None
+
+    def _process_attribute(self, token, content):
+        if self.getting_attrs:
+            self.current_attr = content.lower().strip('=')
+        else:
+            self.current_attr = None
+        self.current_attr_value = None
+
+    def _process_string(self, token, content):
+        if self.getting_attrs and self.current_attr is not None:
+            if content.endswith('"') or content.endswith("'"):
+                if self.current_attr_value is not None:
+                    self.current_attr_value += content
+                    if self.current_tag == 'script' and self.current_attr == 'src':
+                        self.append(self.current_attr_value)
+                    self.current_attr = None
+                    self.current_attr_value = None
+                else:
+                    if len(content) == 1:
+                        self.current_attr_value = content
+                    else:
+                        if self.current_tag == 'script' and self.current_attr == 'src':
+                            self.append(content)
+                        self.current_attr = None
+                        self.current_attr_value = None
+            elif content.startswith('"') or content.startswith("'"):
+                if self.current_attr_value is None:
+                    self.current_attr_value = content
+                else:
+                    self.current_attr_value += content
+
+
+class VelocityHtmlParser(HtmlDjangoParser):
+    pass
+
+
+class MyghtyHtmlParser(HtmlDjangoParser):
+    pass
+
+
+class MasonParser(HtmlDjangoParser):
+    pass
+
+
+class MakoHtmlParser(HtmlDjangoParser):
+    pass
+
+
+class CheetahHtmlParser(HtmlDjangoParser):
+    pass
+
+
+class HtmlGenshiParser(HtmlDjangoParser):
+    pass
+
+
+class RhtmlParser(HtmlDjangoParser):
+    pass
+
+
+class HtmlPhpParser(HtmlDjangoParser):
+    pass
+
+
+class HtmlSmartyParser(HtmlDjangoParser):
+    pass
+
+
+class EvoqueHtmlParser(HtmlDjangoParser):
+    pass
+
+
+class ColdfusionHtmlParser(HtmlDjangoParser):
+    pass
+
+
+class LassoHtmlParser(HtmlDjangoParser):
+    pass
+
+
+class HandlebarsHtmlParser(HtmlDjangoParser):
+    pass
+
+
+class YamlJinjaParser(HtmlDjangoParser):
+    pass
+
+
+class TwigHtmlParser(HtmlDjangoParser):
+    pass

packages/wakatime/wakatime/languages/unknown.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+"""
+    wakatime.languages.unknown
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Parse dependencies from files of unknown language.
+
+    :copyright: (c) 2014 Alan Hamlett.
+    :license: BSD, see LICENSE for more details.
+"""
+
+import os
+
+from . import TokenParser
+from ..compat import u
+
+
+FILES = {
+    'bower': {'exact': False, 'dependency': 'bower'},
+    'grunt': {'exact': False, 'dependency': 'grunt'},
+}
+
+
+class UnknownParser(TokenParser):
+
+    def parse(self, tokens=[]):
+        self._process_file_name(os.path.basename(self.source_file))
+        return self.dependencies
+
+    def _process_file_name(self, file_name):
+        for key, value in FILES.items():
+            found = (key == file_name) if value.get('exact') else (key.lower() in file_name.lower())
+            if found:
+                self.append(value['dependency'])

packages/wakatime/wakatime/stats.py

@@ -14,6 +14,7 @@ import os
 import sys
 
 from .compat import u, open
+from .languages import DependencyParser
 
 if sys.version_info[0] == 2:
     sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), 'packages', 'pygments_py2'))
@@ -46,20 +47,17 @@ TRANSLATIONS = {
 
 
 def guess_language(file_name):
-    if file_name:
-        language = guess_language_from_extension(file_name.rsplit('.', 1)[-1])
-        if language:
-            return language
-    lexer = None
+    language, lexer = None, None
     try:
         with open(file_name, 'r', encoding='utf-8') as fh:
             lexer = guess_lexer_for_filename(file_name, fh.read(512000))
     except:
         pass
-    if lexer:
-        return translate_language(u(lexer.name))
-    else:
-        return None
+    if file_name:
+        language = guess_language_from_extension(file_name.rsplit('.', 1)[-1])
+    if lexer and language is None:
+        language = translate_language(u(lexer.name))
+    return language, lexer
 
 
 def guess_language_from_extension(extension):
@@ -89,9 +87,11 @@ def number_lines_in_file(file_name):
 
 
 def get_file_stats(file_name):
-    dependencies = []
+    language, lexer = guess_language(file_name)
+    parser = DependencyParser(file_name, lexer)
+    dependencies = parser.parse()
     stats = {
-        'language': guess_language(file_name),
+        'language': language,
         'dependencies': dependencies,
         'lines': number_lines_in_file(file_name),
     }