Detect GAS *.s files as Assembly language

Author: alanhamlett

tests/samples/codefiles/gas.s

@@ -0,0 +1,17 @@
+.global	_start
+
+.text
+_start:
+	movl  $4, %eax
+	movl  $1, %ebx
+	movl  $msg, %ecx
+	movl  $len, %edx
+	int   $0x80
+
+	movl  $1, %eax
+	movl  $0, %ebx
+	int   $0x80
+.data
+msg:
+	.ascii  "Hello, world!\n"
+	len =   . - msg

tests/test_dependencies.py

@@ -193,7 +193,7 @@ def test_classnotfound_error_suppressed_when_parsing_dependencies(self):
                 )
 
     def test_dependencies_still_detected_when_alternate_language_used(self):
-        with mock.patch('wakatime.stats.smart_guess_lexer') as mock_guess_lexer:
+        with mock.patch('wakatime.stats.guess_lexer') as mock_guess_lexer:
             mock_guess_lexer.return_value = None
 
             self.shared(

tests/test_languages.py

@@ -8,7 +8,7 @@
 import time
 from wakatime.compat import u
 from wakatime.constants import SUCCESS
-from wakatime.stats import guess_language
+from wakatime.stats import guess_lexer
 from . import utils
 from .utils import ANY, CustomResponse
 
@@ -105,27 +105,26 @@ def test_objectivecpp_language_detected_when_m_files_in_folder(self):
             entity='c_and_cpp/objective-cpp.h',
         )
 
-    def test_guess_language(self):
-        with utils.mock.patch('wakatime.stats.smart_guess_lexer') as mock_guess_lexer:
-            mock_guess_lexer.return_value = None
-            source_file = 'tests/samples/codefiles/python.py'
-            local_file = None
-            result = guess_language(source_file, local_file)
-            mock_guess_lexer.assert_called_once_with(source_file, local_file)
-            self.assertEquals(result, (None, None))
+    def test_guess_lexer(self):
+        source_file = 'tests/samples/codefiles/python.py'
+        local_file = None
+        lexer = guess_lexer(source_file, local_file)
+        language = u(lexer.name) if lexer else None
+        self.assertEquals(language, 'Python')
 
-    def test_guess_language_from_vim_modeline(self):
+    def test_guess_lexer_from_vim_modeline(self):
         self.shared(
             expected_language='Python',
             entity='python_without_extension',
         )
 
-    def test_guess_language_when_entity_not_exist_but_local_file_exists(self):
+    def test_guess_lexer_when_entity_not_exist_but_local_file_exists(self):
         source_file = 'tests/samples/codefiles/does_not_exist.py'
         local_file = 'tests/samples/codefiles/python.py'
         self.assertFalse(os.path.exists(source_file))
-        result = guess_language(source_file, local_file)
-        self.assertEquals(result[0], 'Python')
+        lexer = guess_lexer(source_file, local_file)
+        language = u(lexer.name) if lexer else None
+        self.assertEquals(language, 'Python')
 
     def test_language_arg_takes_priority_over_detected_language(self):
         self.shared(
@@ -135,7 +134,7 @@ def test_language_arg_takes_priority_over_detected_language(self):
         )
 
     def test_language_arg_is_used_when_not_guessed(self):
-        with utils.mock.patch('wakatime.stats.smart_guess_lexer') as mock_guess_lexer:
+        with utils.mock.patch('wakatime.stats.guess_lexer') as mock_guess_lexer:
             mock_guess_lexer.return_value = None
 
             self.shared(
@@ -169,7 +168,7 @@ def test_language_arg_used_for_entity_type_domain(self):
         )
 
     def test_vim_language_arg_is_used_when_not_guessed(self):
-        with utils.mock.patch('wakatime.stats.smart_guess_lexer') as mock_guess_lexer:
+        with utils.mock.patch('wakatime.stats.guess_lexer') as mock_guess_lexer:
             mock_guess_lexer.return_value = None
 
             self.shared(
@@ -179,7 +178,7 @@ def test_vim_language_arg_is_used_when_not_guessed(self):
             )
 
     def test_alternate_language_not_used_when_invalid(self):
-        with utils.mock.patch('wakatime.stats.smart_guess_lexer') as mock_guess_lexer:
+        with utils.mock.patch('wakatime.stats.guess_lexer') as mock_guess_lexer:
             mock_guess_lexer.return_value = None
 
             self.shared(
@@ -189,7 +188,7 @@ def test_alternate_language_not_used_when_invalid(self):
             )
 
     def test_error_reading_alternate_language_json_map_file(self):
-        with utils.mock.patch('wakatime.stats.smart_guess_lexer') as mock_guess_lexer:
+        with utils.mock.patch('wakatime.stats.guess_lexer') as mock_guess_lexer:
             mock_guess_lexer.return_value = None
 
             with utils.mock.patch('wakatime.stats.open') as mock_open:
@@ -286,3 +285,9 @@ def test_coldfusion_detected(self):
             expected_language='ColdFusion',
             entity='coldfusion.cfm',
         )
+
+    def test_gas_detected_as_assembly(self):
+        self.shared(
+            expected_language='Assembly',
+            entity='gas.s',
+        )

wakatime/languages/default.json

@@ -15,6 +15,7 @@
   "cocoa": "Cocoa",
   "coffeescript": "CoffeeScript",
   "coldfusion": "ColdFusion",
+  "coldfusion html": "ColdFusion",
   "common lisp": "Common Lisp",
   "cshtml": "CSHTML",
   "css": "CSS",
@@ -26,6 +27,7 @@
   "erlang": "Erlang",
   "f#": "F#",
   "fortran": "Fortran",
+  "gas": "Assembly",
   "go": "Go",
   "gosu": "Gosu",
   "groovy": "Groovy",

wakatime/stats.py

@@ -68,56 +68,42 @@ def get_file_stats(file_name, entity_type='file', lineno=None, cursorpos=None,
 
     if entity_type == 'file':
         lexer = get_lexer(language)
-        if not language:
-            language, lexer = guess_language(file_name, local_file)
+        if not lexer:
+            lexer = guess_lexer(file_name, local_file)
+            language = root_language(lexer)
         parser = DependencyParser(local_file or file_name, lexer)
         stats.update({
-            'language': use_root_language(language, lexer),
+            'language': standardize_language(language),
             'dependencies': parser.parse(),
             'lines': number_lines_in_file(local_file or file_name),
         })
 
     return stats
 
 
-def guess_language(file_name, local_file):
-    """Guess lexer and language for a file.
-
-    Returns a tuple of (language_str, lexer_obj).
-    """
-
-    lexer = None
-
-    language = get_language_from_extension(file_name)
-    if language:
-        lexer = get_lexer(language)
-    else:
-        lexer = smart_guess_lexer(file_name, local_file)
-        if lexer:
-            language = u(lexer.name)
-
-    return language, lexer
-
-
-def smart_guess_lexer(file_name, local_file):
+def guess_lexer(file_name, local_file):
     """Guess Pygments lexer for a file.
 
     Looks for a vim modeline in file contents, then compares the accuracy
     of that lexer with a second guess. The second guess looks up all lexers
     matching the file name, then runs a text analysis for the best choice.
     """
-    lexer = None
 
-    text = get_file_head(file_name)
+    lexer = None
 
-    lexer1, accuracy1 = guess_lexer_using_filename(local_file or file_name, text)
-    lexer2, accuracy2 = guess_lexer_using_modeline(text)
+    language = get_language_from_extension(file_name)
+    if language:
+        lexer = get_lexer(language)
 
-    if lexer1:
-        lexer = lexer1
-    if (lexer2 and accuracy2 is not None and
-            (accuracy1 is None or accuracy2 > accuracy1)):
-        lexer = lexer2
+    if not lexer:
+        text = get_file_head(file_name)
+        lexer1, accuracy1 = guess_lexer_using_filename(local_file or file_name, text)
+        lexer2, accuracy2 = guess_lexer_using_modeline(text)
+        if lexer1:
+            lexer = lexer1
+        if (lexer2 and accuracy2 is not None and
+                (accuracy1 is None or accuracy2 > accuracy1)):
+            lexer = lexer2
 
     return lexer
 
@@ -238,7 +224,7 @@ def number_lines_in_file(file_name):
     return lines
 
 
-def standardize_language(language, plugin):
+def standardize_language(language, plugin=None):
     """Maps a string to the equivalent Pygments language.
 
     Returns the standardized language string.
@@ -247,15 +233,17 @@ def standardize_language(language, plugin):
     if not language:
         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
+            language = standardized
+
+    standardized = get_language_from_json(language, 'default')
+    if standardized is not None:
+        language = standardized
 
-    # standardize language against default languages
-    return get_language_from_json(language, 'default')
+    return language
 
 
 def get_lexer(language):
@@ -271,17 +259,15 @@ def get_lexer(language):
     return None
 
 
-def use_root_language(language, lexer):
-    override = {
-        'Coldfusion HTML': 'ColdFusion',
-    }
-    if language in override:
-        return override[language]
-
-    if lexer and hasattr(lexer, 'root_lexer'):
-        return u(lexer.root_lexer.name)
-
-    return language
+def root_language(lexer):
+    if lexer:
+        prevent_using_root = set([
+            'coldfusion html',
+        ])
+        if hasattr(lexer, 'root_lexer') and u(lexer.name).lower() not in prevent_using_root:
+            lexer = lexer.root_lexer
+        return u(lexer.name)
+    return None
 
 
 def get_language_from_json(language, key):