Hoe een Sublime Text 2 Plugin te maken

Sublime Text 2 is een zeer aanpasbare teksteditor die steeds meer de aandacht trekt van codeerders op zoek naar een tool die krachtig, snel en modern is. Vandaag gaan we mijn populaire Sublime-plug-in recreëren die CSS via de Nettuts + Prefixr-API verzendt voor gemakkelijke CSS-koppeling tussen verschillende browsers.

Als je klaar bent, heb je een goed begrip van hoe de Sublime Prefixr-plug-in is geschreven en ben je uitgerust om te beginnen met het schrijven van je eigen plug-ins voor de editor!

Voorwoord: terminologie en referentiemateriaal

Het uitbreidingsmodel voor Sublime Text 2 is redelijk volledig.

Het uitbreidingsmodel voor Sublime Text 2 is redelijk volledig. Er zijn manieren om de syntaxisaccentuering, het eigenlijke chroom van de editor en alle menu's te wijzigen. Bovendien is het mogelijk om nieuwe build-systemen, automatische aanvullingen, taaldefinities, fragmenten, macro's, sneltoetsen, muisbindingen en plug-ins te maken. Al deze verschillende soorten wijzigingen worden geïmplementeerd via bestanden die zijn georganiseerd in pakketten.

Een pakket is een map die is opgeslagen in uw Pakketjes directory. U kunt toegang krijgen tot de map met pakketten door op de knop te klikken Voorkeuren> Door pakketten bladeren ... menu-item. Het is ook mogelijk om een pakket in een enkel bestand te bundelen door een zipbestand te maken en de extensie te wijzigen in .verheven-pakket. In deze tutorial bespreken we de verpakking wat verder.

Sublime wordt geleverd met een flink aantal verschillende pakketten. De meeste gebundelde pakketten zijn taalspecifiek. Deze bevatten taaldefinities, automatische aanvullingen en build-systemen. Naast de taalpakketten zijn er nog twee andere pakketten: Standaard en Gebruiker. De
Standaard pakket bevat alle standaard toetsbindingen, menudefinities, bestandsinstellingen en een hele reeks plug-ins geschreven in Python. De Gebruiker pakket is speciaal omdat het altijd als laatste is geladen. Hiermee kunnen gebruikers de standaardinstellingen overschrijven door bestanden in hun eigen bestand aan te passen Gebruiker pakket.

Tijdens het schrijven van een plug-in, is de Sublime Text 2 API essentieel.

Tijdens het schrijven van een plug-in, is de Sublime Text 2 API essentieel. tevens de Standaard pakket fungeert als een goede referentie voor het uitzoeken hoe dingen te doen en wat mogelijk is. Veel van de functionaliteit van de editor wordt zichtbaar via commando's. Elke bewerking anders dan het typen van karakters wordt bereikt via commando's. Door het te bekijken Voorkeuren> Sleutelbindingen - Standaardmenugegeven, is het mogelijk om een schat aan ingebouwde functionaliteit te vinden.

Nu het onderscheid tussen een plug-in en een pakket duidelijk is, laten we beginnen met het schrijven van onze plug-in.

Stap 1 - Een plug-in starten

Sublime wordt geleverd met functionaliteit die een skelet van Python-code genereert dat nodig is om een eenvoudige plug-in te schrijven. Selecteer de Hulpmiddelen> Nieuwe plug-in ... menu-invoer en een nieuwe buffer wordt geopend met deze standaard.

sublime importeren, sublime_plugin class ExampleCommand (sublime_plugin.TextCommand): def run (self, edit): self.view.insert (bewerken, 0, "Hallo, Wereld!")

Hier ziet u dat de twee Sublime Python-modules worden geïmporteerd om gebruik van de API mogelijk te maken en een nieuwe opdrachtklasse wordt gemaakt. Voordat we dit gaan bewerken en beginnen met het maken van onze eigen plug-in, kunnen we het bestand opslaan en de ingebouwde functionaliteit activeren.

Wanneer we het bestand opslaan, gaan we een nieuw pakket maken om het op te slaan. Druk op ctrl + s (Windows / Linux) of cmd + s (OS X) om het bestand op te slaan. Het opslagvenster wordt geopend voor de Gebruiker pakket. Sla het bestand daar niet op, maar blader in plaats daarvan door een map en maak een nieuwe map met de naam Prefixr.

Pakketten / ... - OCaml / - Perl / - PHP / - Prefixr / - Python / - R / - Rails / ...

Bewaar nu het bestand in de map Prefixr als Prefixr.py. Het maakt eigenlijk niet uit wat de bestandsnaam is, alleen dat het eindigt .py. Bij conventie gebruiken we echter de naam van de plug-in voor de bestandsnaam.

Nu de plug-in is opgeslagen, laten we het uitproberen. Open de sublieme console door op te drukken ctrl +'. Dit is een Python-console die toegang heeft tot theAPI. Voer de volgende Python in om de nieuwe plug-in uit te testen:

view.run_command (voorbeeld)

Je zou moeten zien Hallo Wereld ingevoegd in het begin van het plugin-bestand. Zorg ervoor dat u deze wijziging ongedaan maakt voordat we verder gaan.

Stap 2 - Opdrachttypen en naamgeving

Voor plug-ins biedt Sublime drie verschillende soorten opdrachten.

Tekstcommando's geef via a toegang tot de inhoud van het geselecteerde bestand / buffer Uitzicht voorwerp
Window-commando's geef verwijzingen naar het huidige venster via een Venster voorwerp
Applicatieopdrachten hebben geen verwijzing naar een specifiek venster of bestand / buffer en worden minder vaak gebruikt

Omdat we de inhoud van een CSS-bestand / buffer met deze plug-in zullen manipuleren, gaan we de sublime_plugin.TextCommand klasse als basis voor onze aangepaste Prefixr-opdracht. Dit brengt ons bij het onderwerp van het benoemen van commandoklassen.

In het pluginskelet van Sublime merk je de klasse:

class ExampleCommand (sublime_plugin.TextCommand):

Toen we de opdracht wilden uitvoeren, hebben we de volgende code in de console uitgevoerd:

view.run_command (voorbeeld)

Sublime neemt elke klasse die een van de uitbreidt sublime_plugin klassen
(TextCommand, WindowCommand of ApplicationCommand), verwijder het achtervoegsel Commando en converteer vervolgens de CamelCasein underscore_notation voor de opdrachtnaam.

Dus om een commando met de naam te maken prefixr, de klas moet zijn PrefixrCommand.

class PrefixrCommand (sublime_plugin.TextCommand):

Stap 3 - Tekst selecteren

Een van de handigste functies van Sublime is de mogelijkheid om meerdere selecties te hebben.

Nu we onze plugin juist hebben genoemd, kunnen we beginnen met het ophalen van CSS uit de huidige buffer en het verzenden naar de Prefixr API. Een van de handigste functies van Sublime is de mogelijkheid om meerdere selecties te hebben. Terwijl we de geselecteerde tekst pakken, moeten we onze plug in niet alleen de eerste selectie, maar allemaal in schrijven.

Omdat we een tekstopdracht schrijven, hebben we toegang tot de huidige weergave via self.view. De sel () methode van de Uitzicht object retourneert een iterabele RegionSet van de huidige selecties. We beginnen door deze te scannen voor accolades. Als accolades niet aanwezig zijn, kunnen we de selectie uitbreiden naar de omliggende accolades om ervoor te zorgen dat het hele blok wordt voorafgegaan. Of onze selectie accolades bevatte, zal later ook nuttig zijn om te weten of we de witruimte en opmaak kunnen aanpassen aan het resultaat dat we terug krijgen van de Prefixr API.

braces = False sels = self.view.sel () voor sel in sels: if self.view.substr (sel) .find ('')! = -1: braces = True

Deze code vervangt de inhoud van het skelet rennen() methode.

Als we geen accolades hebben gevonden, doorlopen we elke selectie en passen de selecties aan naar de dichtstbijzijnde sluitende accolade. Vervolgens gebruiken we de ingebouwde opdracht expand_selection met de naar arg ingesteld op beugels om ervoor te zorgen dat we de volledige inhoud van elk geselecteerd CSS-blok hebben.

if not braces: new_sels = [] voor sel in sels: new_sels.append (self.view.find ('\', sel.end ())) sels.clear () voor sel in new_sels: sels.add (sel ) self.view.run_command ("expand_selection", "to": "brackets")

Als je je werk tot nu toe nog een keer wilt controleren, vergelijk dan de bron met het bestand Prefixr-1.py in het zipbestand van de broncode.

Stap 4 - Rijgen

Om te voorkomen dat een slechte verbinding andere werkzaamheden onderbreekt, moeten we ervoor zorgen dat de Prefixr API-aanroepen op de achtergrond plaatsvinden.

Op dit punt zijn de selecties uitgebreid om de volledige inhoud van elk CSS-blok te bemachtigen. Nu moeten we ze naar de Prefixr-API sturen. Dit is een eenvoudig HTTP-verzoek, dat we gaan gebruiken urllib en urllib2 modules voor. Voordat we beginnen met het afvuren van webverzoeken, moeten we echter nadenken over hoe een mogelijk laggy-webverzoek de prestaties van de editor zou kunnen beïnvloeden. Als de gebruiker om de een of andere reden een hoge latentie of een trage verbinding heeft, kunnen de verzoeken aan de Prefixr API gemakkelijk enkele seconden of langer duren.

Om te voorkomen dat een slechte verbinding andere werkzaamheden onderbreekt, moeten we ervoor zorgen dat de Prefixr API-aanroepen op de achtergrond plaatsvinden. Als u niets weet over draadsnijden, is een heel eenvoudige verklaring dat threads een manier zijn waarop een programma meerdere sets code kan programmeren om schijnbaar tegelijkertijd te kunnen werken. Het is in ons geval van essentieel belang omdat het de code die gegevens verzendt naar, en wacht op een reactie van, de Prefixr API, de mogelijkheid biedt om de rest van de Sublieme gebruikersinterface te bevriezen..

Stap 5 - Discussies maken

We zullen de Python gebruiken threading module om threads te maken. Om de threading-module te gebruiken, maken we een nieuwe klasse die zich uitstrekt threading.Thread riep PrefixrApiCall. Lessen die uitbreiden threading.Thread omvatten een rennen() methode die alle code bevat die in de thread moet worden uitgevoerd.

klasse PrefixrApiCall (threading.Thread): def __init __ (self, sel, string, timeout): self.sel = sel self.original = string self.timeout = timeout self.result = Geen threading.Thread .__ init __ (zelf) def run (zelf): try: data = urllib.urlencode ('css': self.original) request = urllib2.Request ('http://prefixr.com/api/index.php', data, headers = " User-Agent ":" Sublime Prefixr ") http_file = urllib2.urlopen (request, timeout = self.timeout) self.result = http_file.read () return behalve (urllib2.HTTPError) als (e): err = '% s: HTTP-fout% s contact API '% (__name__, str (e.code)) behalve (urllib2.URLError) als (e): err ='% s: URL-fout% s contact API '% (__name__, str ( e.Reason)) sublime.error_message (err) self.result = False

Hier gebruiken we de draad __in het__() methode om alle waarden in te stellen die nodig zijn tijdens het webverzoek. De rennen() methode bevat de code om het HTTP-verzoek voor de Prefixr-API in te stellen en uit te voeren. Aangezien threads gelijktijdig werken met andere code, is het niet mogelijk om direct waarden te retourneren. In plaats daarvan stellen we in self.result naar het resultaat van de oproep.

Omdat we net wat meer modules in onze plug-in hebben gebruikt, moeten we ze toevoegen aan de importinstructies bovenaan in het script.

import urllib import urllib2 import threading

Nu we een thread-klasse hebben om de HTTP-aanroepen uit te voeren, moeten we voor elke selectie een thread maken. Om dit te doen springen we terug in de rennen() methode van onze PrefixrCommand klasse en gebruik de volgende lus:

threads = [] voor sel in sels: string = self.view.substr (sel) thread = PrefixrApiCall (sel, string, 5) threads.append (thread) thread.start ()

We volgen elke thread die we maken bij en noemen de begin() methode om elk te starten.

Als je je werk tot nu toe nog een keer wilt controleren, vergelijk dan de bron met het bestand Prefixr-2.py in het zipbestand van de broncode.

Stap 6 - Voorbereiden op resultaten

Nu we met de daadwerkelijke Prefixr API-verzoeken zijn begonnen, moeten we een paar laatste details instellen voordat we de antwoorden kunnen verwerken.

Eerst wissen we alle selecties omdat we ze eerder hebben gewijzigd. Later zullen we ze terugbrengen naar een redelijke staat.

self.view.sel (). clear ()

Daarnaast starten we een nieuw Bewerk voorwerp. Dit groepeert bewerkingen voor ongedaan maken en opnieuw uitvoeren. We specificeren dat we een groep maken voor de prefixr commando.

edit = self.view.begin_edit ('prefixr')

Als laatste stap noemen we een methode die we vervolgens zullen schrijven en die het resultaat van de API-verzoeken zullen afhandelen.

self.handle_threads (bewerken, onderwerpen, accolades)

Stap 7 - Werken met threads

Op dit moment zijn onze threads actief, of mogelijk zelfs voltooid. Vervolgens moeten we de handle_threads () methode waarnaar we zojuist verwezen hebben. Deze methode gaat door de lijst met threads en zoekt naar threads die niet meer actief zijn.

def handle_threads (zelf, bewerken, threads, accolades, offset = 0, i = 0, dir = 1): next_threads = [] voor thread in threads: als thread.is_alive (): next_threads.append (thread) doorgaan als thread. resultaat == Niet waar: continue offset = self.replace (bewerken, draad, accolades, offset) threads = next_threads

Als een thread nog in leven is, voegen we deze toe aan de lijst met threads om later opnieuw te controleren. Als het resultaat een mislukking was, negeren we het, maar voor goede resultaten noemen we een nieuw vervangen() methode die we binnenkort zullen schrijven.

Als er threads zijn die nog in leven zijn, moeten we deze binnenkort opnieuw controleren. Bovendien is het een mooie uitbreiding van de gebruikersinterface om een activiteitsindicator te leveren om aan te geven dat onze plug-in nog steeds actief is.

if len (threads): # Dit animeert een kleine activiteitsindicator in het statusgedeelte voor = i% 8 after = (7) - before if not after: dir = -1 if not before: dir = 1 i + = dir self. view.set_status ('prefixr', 'Prefixr [% s =% s]'% \ ("* before," * after)) sublime.set_timeout (lambda: self.handle_threads (bewerken, threads, accolades, offset, i, dir), 100) terugkeren

Het eerste deel van de code gebruikt een eenvoudige integerwaarde die is opgeslagen in de variabele ik verplaatsen van een = heen en weer tussen twee haakjes. Het laatste deel is echter het belangrijkste. Dit vertelt Sublime om het handle_threads ()methode opnieuw, met nieuwe waarden, in nog eens 100 milliseconden. Dit is net als het setTimeout () functie in JavaScript.

De lambda keyword is een functie van Python waarmee we een nieuwe naamloze of anonieme functie kunnen maken.

De sublime.set_timeout () methode vereist een functie of methode en het aantal milliseconden totdat deze moet worden uitgevoerd. Zonder lambda we konden het vertellen dat we wilden rennen handle_threads (), maar we zouden de parameters niet kunnen specificeren.

Als alle threads zijn voltooid, hoeven we geen nieuwe time-out in te stellen, maar in plaats daarvan voltooien we onze undo-groep en werken we de gebruikersinterface bij om de gebruiker te laten weten dat alles is gedaan.

self.view.end_edit (bewerken) self.view.erase_status ('prefixr') selections = len (self.view.sel ()) sublime.status_message ('Prefixr succesvol uitgevoerd op% s selectie% s'% (selecties, " als selecties == 1 anders 's'))

Als je je werk tot nu toe nog een keer wilt controleren, vergelijk dan de bron met het bestand Prefixr-3.py in het zipbestand van de broncode.

Stap 8 - Vervanging uitvoeren

Omdat onze threads worden afgehandeld, hoeven we alleen de code te schrijven die de oorspronkelijke CSS vervangt door het resultaat van de Prefixr API. Zoals we eerder hebben vermeld, gaan we een methode schrijven genaamd vervangen().

Deze methode accepteert een aantal parameters, waaronder de Bewerk object voor ongedaan maken, de thread die het resultaat van de Prefixr-API heeft gepakt, als de originele selectie beugels bevatte en tenslotte de selectie-offset.

def vervangen (zelf, bewerken, draad, accolades, offset): sel = thread.sel original = thread.original result = thread.result # Hier passen we elke selectie aan voor elke tekst die we al hebben ingevoegd als offset: sel = sublime.Region (sel.begin () + offset, sel.end () + offset)

De offset is nodig bij het verwerken van meerdere selecties. Wanneer we een CSS-blok vervangen door het vooraf gedefinieerde CSS, neemt de lengte van dat blok toe. De offset zorgt ervoor dat we de juiste inhoud voor volgende selecties vervangen, omdat de tekst alle verplaatsingen bij elke vervanging positioneert.

De volgende stap is het voorbereiden van het resultaat van de Prefixr-API die als vervangende CSS wordt toegevoegd. Dit omvat het converteren van regeleinden en inspringing om overeen te komen met het huidige document en de oorspronkelijke selectie.

result = self.normalize_line_endings (result) (prefix, main, suffix) = self.fix_whitespace (origineel, resultaat, sel, accolades) self.view.replace (bewerken, sel, prefix + main + achtervoegsel)

Als laatste stap stellen we de selectie van de gebruiker in op het einde van de laatste regel van de nieuwe CSS die we hebben ingevoegd, en retourneert vervolgens de aangepaste correctie voor verdere selecties.

end_point = sel.begin () + len (prefix) + len (hoofd) self.view.sel (). add (sublime.Region (end_point, end_point)) return offset + len (prefix + main + suffix) - len ( original)

Als je je werk tot nu toe nog een keer wilt controleren, vergelijk dan de bron met het bestand Prefixr-4.py in het zipbestand van de broncode.

Stap 9 - Whitespace manipulatie

Tijdens het vervangingsproces hebben we twee aangepaste methoden gebruikt om de nieuwe CSS voor het document voor te bereiden. Deze methoden hebben het resultaat van Prefixr en passen het aan het huidige document aan.

normalize_line_endings () neemt de string en zorgt ervoor dat deze overeenkomt met de regeluitgangen van het huidige bestand. Wij gebruiken de instellingen klasse van de Sublime API om de juiste regeluitgangen te krijgen.

def normalize_line_endings (self, string): string = string.replace ('\ r \ n', '\ n'). replace ('\ r', '\ n') line_endings = self.view.settings (). krijgen ('default_line_ending') if line_endings == 'windows': string = string.replace ('\ n', '\ r \ n') elif line_endings == 'mac': string = string.replace ('\ n', '\ r') return string

De fix_whitespace () methode is een beetje ingewikkelder, maar doet hetzelfde soort manipulatie, alleen voor de inspringing en witruimte in het CSS-blok. Deze manipulatie werkt alleen echt met een enkel blok CSS, dus we sluiten af als een of meer accolades in de oorspronkelijke selectie zijn opgenomen.

def fix_whitespace (self, original, prefixed, sel, braces): # Als er braces aanwezig zijn, kunnen we alle witruimtemagie uitvoeren als braces: return (", prefixed,")

Anders beginnen we met het bepalen van het inspringniveau van de originele CSS. Dit wordt gedaan door te zoeken naar witruimte aan het begin van de selectie.

(row, col) = self.view.rowcol (sel.begin ()) indent_region = self.view.find ('^ \ s +', self.view.text_point (row, 0)) if self.view.rowcol ( indent_region.begin ()) [0] == rij: indent = self.view.substr (indent_region) else: indent = "

Vervolgens trimmen we de witruimte van de vooraf gedefinieerde CSS en gebruiken we de huidige weergave-instellingen om de ingekorte CSS naar het oorspronkelijke niveau te laten inspringen met behulp van tabs of spaties, afhankelijk van de huidige editorinstellingen.

prefixed = prefixed.strip () prefixed = re.sub (re.compile ('^ \ s +', re.M), ", prefixed) settings = self.view.settings () use_spaces = settings.get ('translate_tabs_to_spaces' ) tab_size = int (settings.get ('tab_size', 8)) indent_characters = '\ t' if use_spaces: indent_characters = "* tab_size prefixed = prefixed.replace ('\ n', '\ n' + streepje + indent_characters)

We voltooien de methode door de originele begin- en eindwitruimte te gebruiken om ervoor te zorgen dat de nieuwe vooraf gedefinieerde CSS exact in plaats van het origineel past.

match = re.search ('^ (\ s *)', origineel) prefix = match.groups () [0] match = re.search ('(\ s *) \ Z', origineel) suffix = match.groups () [0] return (prefix, prefixed, suffix)

Met de fix_whitespace () methode hebben we de reguliere expressie (re) module van Python gebruikt, dus we moeten deze toevoegen aan de lijst met importen bovenaan het script.

importeer opnieuw

En hiermee hebben we het proces voltooid van het schrijven van de prefixr opdracht.De volgende stap om de opdracht eenvoudig uit te voeren door een sneltoets en een menu-item te bieden.

Stap 10 - Sleutelbindingen

De meeste instellingen en aanpassingen die kunnen worden aangebracht in Sublime worden gedaan via JSON-bestanden, en dit geldt voor toetsbindingen. Sleutelbindingen zijn meestal besturingssysteemspecifiek, wat betekent dat er drie sleutelbindingsbestanden moeten worden gemaakt voor uw plug-in. De bestanden moeten een naam hebben Standaard (Windows) .sublime-keymap, Standaard (Linux) .sublime-keymap en Standaard (OSX) .sublime-keymap.

 Prefixr / ... - Standaard (Linux) .sublime-keymap - Standaard (OSX) .sublime-keymap - Standaard (Windows) .sublime-keymap - Prefixr.py

De .subliem-toetsenbordindeling bestanden bevatten een JSON-array die JSON-objecten bevat om de sneltoetsen op te geven. De JSON-objecten moeten een bevatten sleutels en commando sleutel, en kan ook een bevatten args sleutel als het commando argumenten vereist. Het moeilijkste deel over het kiezen van een toetsbinding is ervoor te zorgen dat de toetsbinding nog niet wordt gebruikt. Dit kan gedaan worden door naar de Voorkeuren> Sleutelbindingen - Standaard menu-invoer en zoeken naar de keybinding die u wilt gebruiken. Zodra je een geschikte ongebruikte binding hebt gevonden, voeg je deze toe aan je .subliem-toetsenbordindeling bestanden.

 ["keys": ["ctrl + alt + x"], "command": "prefixr"]

Normaal zijn de Linux- en Windows-toetsbindingen hetzelfde. De cmd-toets op OS Xis opgegeven door de tekenreeks super in de .subliem-toetsenbordindeling bestanden. Bij porten van een sleutelbinding over besturingssystemen, is het gebruikelijk voor de ctrl sleutel opWindows en Linux om te worden geruild voor super op OS X. Dit is echter niet altijd de meest natuurlijke handbeweging, dus probeer indien mogelijk uw toetscombinaties uit te testen op een echt toetsenbord.

Stap 11 - Menu-items

Een van de coolere dingen over het uitbreiden van Sublime is dat het mogelijk is om items aan de menustructuur toe te voegen door ze te maken .subliem-menu bestanden. Menufiles moeten specifieke namen krijgen om aan te geven welk menu ze beïnvloeden:

Main.sublime-menu bestuurt het hoofdmenu van het programma
Side Bar.sublime-menu beheert het rechtsklikmenu van een bestand of map in de zijbalk
Context.sublime-menu beheert het rechtsklikmenu van een bestand dat wordt bewerkt

Er zijn een hele reeks andere menu-bestanden die van invloed zijn op verschillende andere menu's in de hele interface. Bladeren door de Standaard pakket is de gemakkelijkste manier om over al deze dingen te leren.

Voor Prefixr willen we een menu-item toevoegen aan de Bewerk menu en enkele items voor de voorkeuren menu voor instellingen. Het volgende voorbeeld is de JSON-structuur voor de Bewerk menu-item. Ik heb de vermeldingen voor de voorkeuren menu omdat ze tamelijk breed zijn en een aantal niveaus diep worden genest.

["id": "edit", "children": ["id": "wrap", "command": "prefixr"]]

Het enige stuk om op te letten is het ID kaart sleutels. Door de ID kaartvan een bestaand menu-item, is het mogelijk om een item toe te voegen zonder de bestaande structuur opnieuw te definiëren. Als u de Main.sublime-menu bestand van de Standaard pakket en bladeren rond, kunt u bepalen wat ID kaartu wilt uw vermelding toevoegen aan.

Op dit punt moet je Prefixr-pakket er bijna identiek uitzien als de officiële versie op GitHub.

Stap 12 - Uw pakket distribueren

Nu je de tijd hebt genomen om een nuttige Sublieme plug-in te schrijven, is het tijd om andere gebruikers in de hand te nemen.

Sublime ondersteunt het distribueren van een zip-bestand van een pakketdirectory als een eenvoudige manier om pakketten te delen. Pak gewoon uw pakketmap in en wijzig de extensie naar .verheven-pakket. Andere gebruikers kunnen dit nu in hun plaatsen Geïnstalleerde pakketten directory en herstart Sublime om het pakket te installeren.

Naast de eenvoudige beschikbaarheid voor veel gebruikers, zorgt het beschikbaar zijn van uw pakket via Package Control ervoor dat gebruikers automatisch een upgrade naar uw nieuwste updates krijgen.

Hoewel dit zeker kan werken, is er ook een pakketbeheerder voor Sublux genaamd Package Control die een hoofdlijst met pakketten en automatische upgrades ondersteunt. Om uw pakket aan het standaardkanaal toe te voegen, host u het eenvoudig op GitHubor BitBucket en vult u vervolgens het kanaalbestand (op GitHub of BitBucket), voegt u uw repository toe en stuurt u een pull-aanvraag. Zodra het pull-verzoek is geaccepteerd, is uw pakket beschikbaar voor duizenden gebruikers die Sublime gebruiken. Naast de eenvoudige beschikbaarheid voor veel gebruikers, zorgt het beschikbaar zijn van uw pakket via Package Control ervoor dat gebruikers automatisch een upgrade naar uw nieuwste updates krijgen.

Als je niet op GitHub of BitBucket wilt hosten, is er een aangepast JSON-kanaal / repository-systeem dat overal kan worden gehost, terwijl het pakket toch aan alle gebruikers wordt aangeboden. Het biedt ook geavanceerde functionaliteit zoals het specificeren van de beschikbaarheid van pakketten door OS. Zie de PackageControl-pagina voor meer informatie.

Ga enkele plug-ins schrijven!

Nu we de stappen voor het schrijven van een sublieme plugin hebben besproken, is het tijd voor je om erin te duiken! De Sublime-plug-community maakt en publiceert bijna elke dag nieuwe functionaliteit. Met elke release wordt Sublime steeds krachtiger en veelzijdiger. Het Sublime Text Forum is een geweldige plek om hulp te krijgen en met anderen te praten over wat je aan het bouwen bent.

Code