[PYTHON] Ajoutez la langue D (toute autre langue) à Sublime Linter pour permettre la mise en évidence

Sublime Linter est l'un des packages de Sublime Text2, et c'est une fonction pour mettre en évidence la partie où l'erreur de compilation ou l'erreur de syntaxe s'est produite. Cela ressemble à l'image ci-dessous.

La page officielle de Sublime Linter est ci-dessous. https://github.com/SublimeLinter/SublimeLinter

Consultez la page suivante pour installer Sublime Linter. http://perl.no-tubo.net/2012/05/03/mac%E3%81%AE%E3%83%86%E3%82%AD%E3%82%B9%E3%83%88%E3%82%A8%E3%83%87%E3%82%A3%E3%82%BF-sublime-text2%E3%81%A7javascript%E3%81%AE%E3%82%B7%E3%83%B3%E3%82%BF%E3%83%83%E3%82%AF%E3%82%B9%E3%82%A8%E3%83%A9/ http://watson1978.github.com/blog/2012/08/23/make-a-sublime-text-environment/

Alors, voici comment mettre en évidence le langage D avec cela.

Ajouter un fichier pour la langue D

Après avoir installé SublimeLinter, ouvrez le dossier contenant les packages en sélectionnant [Sublime Text 2] -> [Preference] -> [Browse Packages…]. (Pour MacOS. Je ne connais pas d'autre OS)

Ensuite, lorsque vous ouvrez le dossier contenant le package, ouvrez le dossier [~~ / Packages / SublimeLinter / sublimelinter / modules /]. Je pense que python.py ou java.py y est inclus, alors créez d.py.

Créer une rivière d.py

Copiez la source de objective-j.py vers d.py, supprimez les parties inutiles et procédez comme suit.

d.py

import re
import os
import subprocess

from base_linter import BaseLinter

CONFIG = {
    'language': 'D'
}


class Linter(BaseLinter):
    def built_in_check(self, view, code, filename):
        return ''

    def parse_errors(self, view, errors, lines, errorUnderlines, violationUnderlines, warningUnderlines, errorMessages, violationMessages, warningMessages):
		return ''

built_in_check est la fonction qui compile le code et renvoie une erreur de compilation, et parse_errors est la fonction qui décide où mettre en surbrillance en fonction de l'erreur provenant de built_in_check.

Contenu de built_in_check

Les arguments pour built_in_check sont self, view, code, filename. self est confiance en soi (ceci en C #), view est une classe d'onglets, le code est ** le contenu d'un fichier non enregistré en cours d'édition **, et filename est le nom du fichier affiché. Donc, j'écris le traitement du contenu pour compiler le code dans'built_in_check ', mais les notes sont les suivantes.

1. La cible de la compilation est le code. La compilation du fichier de nom de fichier compile le fichier non édité, ce qui est étrange. Enregistrez le code dans un dossier approprié avec d.py et compilez-le
2. L'option de compilation dmd est -c -o- -w -unittest -debug
3. Si vous ne comprenez pas, lisez base_linter.py

Le résultat est donc ci-dessous.

d.py

…
#Dossier temporaire pour écrire des fichiers au milieu de l'écriture
TMPPATH_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), '.dtmpfiles'))
if not os.path.exists(TMPPATH_DIR):
    os.mkdir(TMPPATH_DIR)
…
class Linter(BaseLinter):
    def built_in_check(self, view, code, filename):
      def built_in_check(self, view, code, filename):
        #Obtenez un pass
        work_path = os.path.dirname(filename)
        file_name = os.path.basename(filename)

		 #Obtenir les paramètres d'emplacement de compilation
        settings = view.settings().get('SublimeLinter', {}).get(self.language, {})
        if(settings):
            dwd = settings.get('working_directory', [])
            if(dwd):
                #Obtenez-le s'il est défini dans le projet
                work_path = dwd

        #Le fichier en cours d'écriture est utilisé comme fichier temporaire..Exporter directement sous py
        tempfilePath = os.path.join(TMPPATH_DIR, file_name)

        with open(tempfilePath, 'w') as f:
            f.write(code)

        args = ["dmd", "-c", "-o-", "-w", "-unittest", "-debug", tempfilePath]

        try:
			#compiler
            process = subprocess.Popen(args,
                                        cwd=work_path,
                                        stdin=subprocess.PIPE,
                                        stdout=subprocess.PIPE,
                                        stderr=subprocess.STDOUT,
                                        startupinfo=self.get_startupinfo())
            result = process.communicate(None)[0]
        finally:
            if tempfilePath:
                #Supprimer le fichier enregistré
                os.remove(tempfilePath)

        return result.strip()
…

SublimeText2 a une fonction de gestion de projet, mais si vous écrivez les paramètres dans le fichier projet, vous pouvez définir l'emplacement sur dmd. Si vous n'importez pas un module que vous avez créé vous-même, une erreur de compilation se produira dans la partie import (je pense). Les paramètres sont les suivants.

xxx.sublime-project

{
	"folders":
	[
		{
			//Dossier de projet
			"path": "~~~~"
		}
	],

	"settings":
    {
        "SublimeLinter":
        {
            "d":
            {
				//dmd Le dossier que vous souhaitez déplacer. Ce peut être le même que le dossier ci-dessus.
                "working_directory": "~~~~~"
            }
        }
    }
}

Contenu de parse_errors

Le message d'erreur de l'erreur de compilation passé dans le retour de built_in_check est passé aux lignes de l'argument parse_errors. Après cela, vous pouvez supprimer le message d'erreur et la ligne d'erreur du message d'erreur dans chaque ligne de lines et le transmettre à la fonction self.add_message. Les points à noter ici sont les suivants.

1. Dans dmd v2.060, une erreur de compilation est crachée à un endroit autre que la source que j'ai écrite. Ce sera corrigé. À ce stade, je mets toutes les erreurs dans la ligne que j'importe en partant du principe que j'importe si elle est crachée.
2. «Messages d'erreur» est passé, mais cela n'a pas beaucoup de sens ici. Je veux dire, je n'ai pas vérifié ce qui va arriver. Il n'y a peut-être rien dedans.
3. Si vous ne comprenez pas, lisez base_linter.py (c'est important, donc la deuxième fois)

Alors (ry

d.py

…
    def parse_errors(self, view, errors, lines, errorUnderlines, violationUnderlines, warningUnderlines, errorMessages, violationMessages, warningMessages):
        for line in errors.splitlines():
            match = re.match(r'^(?P<filename>.+\.d)\((?P<line>\d+)\): Error: (?P<error>.+)', line)

            if match:
                tab_filename = os.path.basename(view.file_name())
                error_filename = os.path.basename(match.group('filename'))
                error, line = match.group('error'), match.group('line')
                if(tab_filename == error_filename):
                    self.add_message(int(line), lines, error, errorMessages)
                else:
                    line = 1
                    module_name = error_filename.replace('.d', '')
                    regions = view.find_all(r'import.*\.' + module_name)
                    if(regions):
                        line = view.rowcol(regions[0].a)[0] + 1
                    self.add_message(line, lines, error, errorMessages)

Cela devrait probablement fonctionner. Si cela ne fonctionne pas, veuillez le réparer.