grip Download - grip Quellcode herunterladen

Grip – GitHub Readme-Sofortvorschau

Rendern Sie lokale Readme-Dateien, bevor Sie sie an GitHub senden.

Grip ist eine in Python geschriebene Befehlszeilen-Serveranwendung, die die GitHub-Markdown-API verwendet, um eine lokale Readme-Datei zu rendern. Die Stile und das Rendering stammen direkt von GitHub, sodass Sie genau wissen, wie es aussehen wird. Änderungen, die Sie an der Readme-Datei vornehmen, werden sofort im Browser angezeigt, ohne dass eine Seitenaktualisierung erforderlich ist.

Motivation

Manchmal möchten Sie einfach nur das genaue Readme-Ergebnis sehen, bevor Sie es festschreiben und auf GitHub übertragen.

Vor allem bei der Readme-gesteuerten Entwicklung.

Installation

Um den Griff zu installieren, gehen Sie einfach wie folgt vor:

$ pip install grip

Unter OS X können Sie auch mit Homebrew installieren:

$ brew install grip

Verwendung

So rendern Sie die Readme-Datei eines Repositorys:

$ cd myrepo
$ grip
 * Running on http://localhost:6419/

Öffnen Sie nun einen Browser und besuchen Sie http://localhost:6419. Oder führen Sie es mit -b aus und Grip öffnet einen neuen Browser-Tab für Sie.

Sie können auch einen Port angeben:

$ grip 80
 * Running on http://localhost:80/

Oder eine explizite Datei:

$ grip AUTHORS.md
 * Running on http://localhost:6419/

Alternativ können Sie einfach grip ausführen und localhost:6419/AUTHORS.md besuchen, da grip relative URLs unterstützt.

Sie können die vorherigen Beispiele kombinieren. Oder geben Sie einen Hostnamen anstelle eines Ports an. Oder bieten Sie beides an.

$ grip AUTHORS.md 80
 * Running on http://localhost:80/

$ grip CHANGES.md 0.0.0.0
 * Running on http://0.0.0.0:6419/

$ grip . 0.0.0.0:80
 * Running on http://0.0.0.0:80/

Sie können sogar den Server umgehen und in eine einzige HTML-Datei exportieren , in der alle Stile und Assets eingebunden sind:

$ grip --export
Exporting to README.html

Steuern Sie den Ausgabenamen mit dem zweiten Argument:

$ grip README.md --export index.html
Exporting to index.html

Wenn Sie eine Reihe von Dateien exportieren, können Sie mit --no-inline verhindern, dass Stile inliniert werden, um Platz zu sparen:

$ grip README.md --export --no-inline introduction.html
Exporting to introduction.html

Das Lesen und Schreiben von stdin und stdout wird ebenfalls unterstützt, sodass Sie Grip mit anderen Programmen verwenden können:

$ cat README.md | grip -
 * Running on http://localhost:6419/

$ grip AUTHORS.md --export - | bcat

$ cat README.md | grip --export - | less

So können Sie schnell testen, wie die Dinge aussehen, indem Sie Markdown direkt in Ihr Terminal eingeben:

$ grip -
Hello **world**!
^D
 * Running on http://localhost:6419/

Hinweis: ^D bedeutet Ctrl+D und funktioniert unter Linux und OS X. Unter Windows müssen Sie Ctrl+Z verwenden.

Das Rendern als Benutzerinhalt wie Kommentare und Probleme wird ebenfalls unterstützt, mit einem optionalen Repository-Kontext für die Verknüpfung mit Problemen:

$ grip --user-content --context=joeyespo/grip
 * Running on http://localhost:6419/

Weitere Details und zusätzliche Optionen finden Sie in der Hilfe:

$ grip -h

Zugang

Grip ist bestrebt, so nah wie möglich an GitHub zu sein. Um dies zu erreichen, verwendet Grip die Markdown-API von GitHub, sodass Änderungen an der Rendering-Engine sofort widergespiegelt werden, ohne dass Sie ein Grip-Upgrade durchführen müssen. Aus diesem Grund kann es jedoch sein, dass Sie das Stundensatzlimit der API erreichen. In diesem Fall bietet Grip eine Möglichkeit, mit Ihren Anmeldeinformationen auf die API zuzugreifen, um ein viel höheres Ratenlimit freizuschalten.

$ grip --user < your-username > --pass < your-password >

Oder verwenden Sie ein persönliches Zugriffstoken mit leerem Gültigkeitsbereich (beachten Sie, dass ein Token erforderlich ist, wenn Ihr GitHub-Konto mit Zwei-Faktor-Authentifizierung eingerichtet ist):

$ grip --pass < token >

Sie können diese Optionen in Ihrer lokalen Konfiguration beibehalten. Aus Sicherheitsgründen wird dringend empfohlen, statt eines Passworts ein Zugriffstoken zu verwenden . (Sie können Ihr Passwort auch schützen, indem Sie Grip so konfigurieren, dass es Ihr Passwort von einem Passwort-Manager abruft.)

Es gibt auch einen Work-in-Progress-Zweig, der Offline-Rendering ermöglicht. Sobald dies GitHub genauer ähnelt, wird es in der CLI verfügbar gemacht und letztendlich als nahtlose Fallback-Engine verwendet, wenn auf die API nicht zugegriffen werden kann.

Grip greift immer über HTTPS auf GitHub zu, sodass Ihre README-Datei und Ihre Anmeldeinformationen geschützt sind.

Tipps

So verwenden andere aus der Community Grip.

Möchten Sie Ihre eigenen teilen? Sagen Sie Hallo @joeyespo oder senden Sie eine Pull-Anfrage.

Erstellen Sie einen lokalen Spiegel eines Github-Wikis

$ git clone https://github.com/YOUR_USERNAME/YOUR_REPOSITORY.wiki.git
$ cd YOUR_REPOSITORY.wiki
$ grip

Von Joshua Gourneau.

Generieren Sie eine HTML-Dokumentation aus einer Sammlung verknüpfter README-Dateien

Geben Sie das Verzeichnis ein:

$ cd YOUR_DIR
$ export GRIPURL= $( pwd )

Schließen Sie alle Assets ein, indem Sie die Konfigurationsvariable CACHE_DIRECTORY festlegen:
> ~/.grip/settings.py">
```
$ echo " CACHE_DIRECTORY = ' $( pwd ) /assets' " >> ~ /.grip/settings.py
```

Exportieren Sie alle Ihre Markdown-Dateien mit Grip und ersetzen Sie absolute Asset-Pfade durch relative Pfade:

$ for f in * .md ; do grip --export $f --no-inline ; done
$ for f in * .html ; do sed -i ' ' " s? $GRIPURL /??g " $f ; done

Sie können die HTML-Dateien optional mit folgendem Befehl in docs.tgz komprimieren:

$ tar -czvf docs.tgz ` ls | grep [ . ]html$ ` assets

Suchen Sie nach einer plattformübergreifenden Lösung? Hier ist ein entsprechendes Python-Skript.

Von Matthew R. Tanudjaja.

Konfiguration

Um Grip anzupassen, erstellen Sie ~/.grip/settings.py und fügen Sie dann eine oder mehrere der folgenden Variablen hinzu:

HOST : Der zu verwendende Host, wenn er nicht als CLI-Argument angegeben wird, standardmäßig localhost
PORT : Der zu verwendende Port, wenn er nicht als CLI-Argument angegeben wird, standardmäßig 6419
DEBUG : Ob der Debugger von Flask verwendet werden soll, wenn ein Fehler auftritt, standardmäßig False
DEBUG_GRIP : Gibt erweiterte Informationen aus, wenn ein Fehler auftritt, standardmäßig False
API_URL : Basis-URL für die Github-API, zum Beispiel die einer Github Enterprise-Instanz. Standardmäßig https://api.github.com
CACHE_DIRECTORY : Das Verzeichnis relativ zu ~/.grip , in dem zwischengespeicherte Assets abgelegt werden sollen (dies wird durch den folgenden Filter ausgeführt: CACHE_DIRECTORY.format(version=__version__) ), standardmäßig 'cache-{version}'
AUTOREFRESH : Ob der Readme-Inhalt automatisch aktualisiert werden soll, wenn sich die Datei ändert, standardmäßig True
QUIET : Keine erweiterten Informationen drucken, standardmäßig False
STYLE_URLS : Zusätzliche URLs, die der gerenderten Seite hinzugefügt werden, standardmäßig []
USERNAME : Der zu verwendende Benutzername, wenn er nicht als CLI-Argument angegeben wird, standardmäßig None
PASSWORD : Das zu verwendende Passwort oder persönliche Zugriffstoken, wenn es nicht als CLI-Argument bereitgestellt wird ( Bitte speichern Sie Ihre Passwörter hier nicht. Verwenden Sie stattdessen ein Zugriffstoken oder geben Sie diesen Code ein, um Ihr Passwort von einem Passwort-Manager zu erhalten), standardmäßig None

Beachten Sie, dass es sich hierbei um eine Python-Datei handelt. Wenn Sie den Fehler 'X' is not defined sehen, haben Sie möglicherweise einige Anführungszeichen übersehen. Zum Beispiel:

 USERNAME = 'your-username'
PASSWORD = 'your-personal-access-token'

Umgebungsvariablen

GRIPHOME : Geben Sie einen alternativen Speicherort settings.py an, standardmäßig ~/.grip
GRIPURL : Die URL des Grip-Servers, standardmäßig /__/grip

Fortschrittlich

Bei dieser Datei handelt es sich um ein normales Python-Skript, sodass Sie eine erweiterte Konfiguration hinzufügen können.

Um beispielsweise eine Einstellung aus der Umgebung zu lesen und einen Standardwert bereitzustellen, wenn dieser nicht festgelegt ist:

 PORT = os . environ . get ( 'GRIP_PORT' , 8080 )

API

Sie können mit Python direkt auf die API zugreifen und sie in Ihren eigenen Projekten verwenden:

 from grip import serve

serve ( port = 8080 )
 * Running on http : // localhost : 8080 /

Führen Sie main direkt aus:

 from grip import main

main ( argv = [ '-b' , '8080' ])
 * Running on http : // localhost : 8080 /

Oder greifen Sie für noch mehr Flexibilität auf die zugrunde liegende Flask-Anwendung zu:

 from grip import create_app

grip_app = create_app ( user_content = True )
# Use in your own app

Dokumentation

Aufschlag

Führt einen lokalen Server aus und rendert die Readme-Datei, die sich im path befindet, wenn sie im Browser aufgerufen wird.

 serve ( path = None , host = None , port = None , user_content = False , context = None , username = None , password = None , render_offline = False , render_wide = False , render_inline = False , api_url = None , title = None , autorefresh = True , browser = False , grip_class = None )

path : Der zu rendernde Dateiname oder das Verzeichnis, das Ihre Readme-Datei enthält, standardmäßig das aktuelle Arbeitsverzeichnis
host : Der zu überwachende Host, standardmäßig die Konfigurationsvariable HOST
port : Der zu überwachende Port, standardmäßig die Konfigurationsvariable PORT
user_content : Gibt an, ob ein Dokument als Benutzerinhalt wie Benutzerkommentare oder -probleme gerendert werden soll
context : Der zu verwendende Projektkontext, wenn user_content wahr ist, in der Form username/project
username : Der Benutzer, der sich bei GitHub authentifizieren muss, um das API-Limit zu erweitern
password : Das Passwort zur Authentifizierung bei GitHub, um das API-Limit zu erweitern
render_offline : Ob lokal mit Python-Markdown gerendert werden soll (Hinweis: Dies ist in Arbeit)
render_wide : Ob eine breite Seite gerendert werden soll, standardmäßig False (dies hat keine Auswirkung, wenn es mit user_content verwendet wird)
render_inline : Ob die Stile in die HTML-Datei eingebunden werden sollen
api_url : Eine andere Basis-URL für die Github-API, beispielsweise die einer Github Enterprise-Instanz. Der Standardwert ist die öffentliche API https://api.github.com.
title : Der Seitentitel, standardmäßig vom path abgeleitet
autorefresh : Aktualisiert den gerenderten Inhalt automatisch, wenn sich die Readme-Datei ändert, standardmäßig True
browser : Öffnen Sie nach dem Serverstart eine Registerkarte im Browser. Standardmäßig False
grip_class : Verwenden Sie eine benutzerdefinierte Grip-Klasse

Export

Schreibt die angegebene Readme-Datei in eine HTML-Datei mit eingebundenen Stilen und Assets.

 export ( path = None , user_content = False , context = None , username = None , password = None , render_offline = False , render_wide = False , render_inline = True , out_filename = None , api_url = None , title = None , quiet = None , theme = 'light' , grip_class = None )

path : Der zu rendernde Dateiname oder das Verzeichnis, das Ihre Readme-Datei enthält, standardmäßig das aktuelle Arbeitsverzeichnis
user_content : Gibt an, ob ein Dokument als Benutzerinhalt wie Benutzerkommentare oder -probleme gerendert werden soll
context : Der zu verwendende Projektkontext, wenn user_content wahr ist, in der Form username/project
username : Der Benutzer, der sich bei GitHub authentifizieren muss, um das API-Limit zu erweitern
password : Das Passwort zur Authentifizierung bei GitHub, um das API-Limit zu erweitern
render_offline : Ob lokal mit Python-Markdown gerendert werden soll (Hinweis: Dies ist in Arbeit)
render_wide : Ob eine breite Seite gerendert werden soll, standardmäßig False (dies hat keine Auswirkung, wenn es mit user_content verwendet wird)
render_inline : Ob die Stile in die HTML-Datei eingebunden werden sollen (Hinweis: Im Gegensatz zu den anderen API-Funktionen ist dies standardmäßig True )
out_filename : Der Dateiname, in den geschrieben werden soll, standardmäßig .html
api_url : Eine andere Basis-URL für die Github-API, beispielsweise die einer Github Enterprise-Instanz. Der Standardwert ist die öffentliche API https://api.github.com.
title : Der Seitentitel, standardmäßig vom path abgeleitet
quiet : Nicht auf dem Terminal drucken
theme : Thema zum Anzeigen der Markdown-Datei (heller Modus oder dunkler Modus). Gültige Optionen („hell“, „dunkel“). Standard: „hell“.
grip_class : Verwenden Sie eine benutzerdefinierte Grip-Klasse

create_app

Erstellt eine Flask-Anwendung, die Sie zum Rendern und Bereitstellen der Readme-Dateien verwenden können. Dies ist dieselbe App, die von serve und export verwendet wird und den Cache initialisiert, wobei die zwischengespeicherten Stile verwendet werden, sofern verfügbar.

 create_app ( path = None , user_content = False , context = None , username = None , password = None , render_offline = False , render_wide = False , render_inline = False , api_url = None , title = None , text = None , grip_class = None )

path : Der zu rendernde Dateiname oder das Verzeichnis, das Ihre Readme-Datei enthält, standardmäßig das aktuelle Arbeitsverzeichnis
user_content : Gibt an, ob ein Dokument als Benutzerinhalt wie Benutzerkommentare oder -probleme gerendert werden soll
context : Der zu verwendende Projektkontext, wenn user_content wahr ist, in der Form username/project
username : Der Benutzer, der sich bei GitHub authentifizieren muss, um das API-Limit zu erweitern
password : Das Passwort zur Authentifizierung bei GitHub, um das API-Limit zu erweitern
render_offline : Ob lokal mit Python-Markdown gerendert werden soll (Hinweis: Dies ist in Arbeit)
render_wide : Ob eine breite Seite gerendert werden soll, standardmäßig False (dies hat keine Auswirkung, wenn es mit user_content verwendet wird)
render_inline : Ob die Stile in die HTML-Datei eingebunden werden sollen
api_url : Eine andere Basis-URL für die Github-API, beispielsweise die einer Github Enterprise-Instanz. Der Standardwert ist die öffentliche API https://api.github.com.
title : Der Seitentitel, standardmäßig vom path abgeleitet
text : Eine Zeichenfolge oder ein Stream von Markdown-Text, der gerendert werden soll, anstatt aus path geladen zu werden (Hinweis: path kann zum Festlegen des Seitentitels verwendet werden.)
grip_class : Verwenden Sie eine benutzerdefinierte Grip-Klasse

render_app

Rendert die von create_app erstellte Anwendung und gibt den HTML-Code zurück, der normalerweise beim Besuch dieser Route angezeigt wird.

 render_app ( app , route = '/' )

app : Die zu rendernde Flask-Anwendung
route : Die zu rendernde Route, standardmäßig „/“.

render_content

Rendert den angegebenen Markdown-Text ohne Zwischenspeicherung.

 render_content ( text , user_content = False , context = None , username = None , password = None , render_offline = False , api_url = None , title = None )

text : Der zu rendernde Markdown-Text
user_content : Gibt an, ob ein Dokument als Benutzerinhalt wie Benutzerkommentare oder -probleme gerendert werden soll
context : Der zu verwendende Projektkontext, wenn user_content wahr ist, in der Form username/project
username : Der Benutzer, der sich bei GitHub authentifizieren muss, um das API-Limit zu erweitern
password : Das Passwort zur Authentifizierung bei GitHub, um das API-Limit zu erweitern
render_offline : Ob lokal mit Python-Markdown gerendert werden soll (Hinweis: Dies ist in Arbeit)
api_url : Eine andere Basis-URL für die Github-API, beispielsweise die einer Github Enterprise-Instanz. Dies ist erforderlich, wenn Sie den Offline-Renderer nicht verwenden.
title : Der Seitentitel, standardmäßig vom path abgeleitet

render_page

Rendert den Markdown aus dem angegebenen Pfad oder Text ohne Zwischenspeicherung und gibt eine HTML-Seite zurück, die der GitHub-Readme-Ansicht ähnelt.

 render_page ( path = None , user_content = False , context = None , username = None , password = None , render_offline = False , render_wide = False , render_inline = False , api_url = None , title = None , text = None , quiet = None , theme = 'light' , grip_class = None )

path : Der für den Seitentitel zu verwendende Pfad, 'README.md' darstellt, wenn „None“ vorhanden ist
user_content : Gibt an, ob ein Dokument als Benutzerinhalt wie Benutzerkommentare oder -probleme gerendert werden soll
context : Der zu verwendende Projektkontext, wenn user_content wahr ist, in der Form username/project
username : Der Benutzer, der sich bei GitHub authentifizieren muss, um das API-Limit zu erweitern
password : Das Passwort zur Authentifizierung bei GitHub, um das API-Limit zu erweitern
render_offline : Ob offline mit Python-Markdown gerendert werden soll (Hinweis: Dies ist in Arbeit)
render_wide : Ob eine breite Seite gerendert werden soll, standardmäßig False (dies hat keine Auswirkung, wenn es mit user_content verwendet wird)
render_inline : Ob die Stile in die HTML-Datei eingebunden werden sollen
api_url : Eine andere Basis-URL für die Github-API, beispielsweise die einer Github Enterprise-Instanz. Der Standardwert ist die öffentliche API https://api.github.com.
title : Der Seitentitel, standardmäßig vom path abgeleitet
text : Eine Zeichenfolge oder ein Stream von Markdown-Text, der gerendert werden soll, anstatt aus path geladen zu werden (Hinweis: path kann zum Festlegen des Seitentitels verwendet werden.)
quiet : Nicht auf dem Terminal drucken
theme : Thema zum Anzeigen der Markdown-Datei (heller Modus oder dunkler Modus). Gültige Optionen („hell“, „dunkel“). Standard: „hell“.
grip_class : Verwenden Sie eine benutzerdefinierte Grip-Klasse

clear_cache

Löscht die zwischengespeicherten Stile und Assets.

 clear_cache ( grip_class = None )

hauptsächlich

Führt Grip mit den angegebenen Argumenten aus.

 main ( argv = None , force_utf8 = True )

argv : Die Argumente, mit denen ausgeführt werden soll, standardmäßig sys.argv[1:]
force_utf8 : Setzt die Standardkodierung in der aktuellen Python-Instanz auf utf-8 . Dies hat keine Auswirkungen auf Python 3, da Unicode standardmäßig verarbeitet wird

Klassen

Klasse Grip(Flask)

Eine Flask-Anwendung, die eine Datei oder ein Verzeichnis mit einer README-Datei bereitstellen kann.

 Grip ( source = None , auth = None , renderer = None , assets = None , render_wide = None , render_inline = None , title = None , autorefresh = None , quiet = None , theme = 'light' , grip_url = None , static_url_path = None , instance_path = None , ** kwargs )

default_renderer

Gibt den Standardrenderer unter Verwendung der aktuellen Konfiguration zurück. Dies wird nur verwendet, wenn der Renderer im Konstruktor auf „None“ gesetzt ist.

 Grip . default_renderer ()

default_asset_manager

Gibt den Standard-Asset-Manager mit der aktuellen Konfiguration zurück. Dies wird nur verwendet, wenn asset_manager im Konstruktor auf None gesetzt ist.

 Grip . default_asset_manager ()

add_content_types

Fügt die Inhaltstypen application/x-font-woff und application/octet-stream hinzu, falls diese fehlen. Überschreiben Sie, um bei der Initialisierung zusätzliche Inhaltstypen hinzuzufügen.

 Grip . add_content_types ()

clear_cache

Löscht die heruntergeladenen Assets.

 Grip . clear_cache ()

machen

Rendert die Anwendung und gibt den HTML-Unicode zurück, der normalerweise beim Besuch im Browser angezeigt wird.

 Grip . render ( route = None )

route : Die zu rendernde Route, standardmäßig /

laufen

Startet einen Server zum Rendern der README-Datei. Dadurch wird Flask.run intern aufgerufen.

 Grip . run ( host = None , port = None , debug = None , use_reloader = None , open_browser = False )

host : Der Hostname, der überwacht werden soll. Setzen Sie dies auf '0.0.0.0' damit der Server auch extern verfügbar ist, standardmäßig 'localhost'
port : Der Port des Webservers. Der Standardwert ist 6419
debug : Falls angegeben, aktivieren oder deaktivieren Sie den Debug-Modus. Siehe Flask.debug.
use_reloader : Sollte der Server den Python-Prozess automatisch neu starten, wenn Module geändert wurden? Standardmäßig False , es sei denn, die DEBUG_GRIP -Einstellung ist angegeben.
open_browser : Öffnet den Browser mit der Adresse, wenn der Server startet

Klasse bereitsRunningError(RuntimeError)

Wird ausgelöst, wenn Grip.run aufgerufen wird, während der Server bereits läuft.

 AlreadyRunningError ()

Klasse ReadmeNotFoundError(NotFoundError oder IOError)

Wird ausgelöst, wenn die angegebene Readme-Datei nicht gefunden werden konnte.

 ReadmeNotFoundError ( path = None , message = None )

Klasse ReadmeAssetManager(Objekt)

Verwaltet die Stil- und Schriftarten-Assets, die mit Readme-Seiten gerendert werden. Dies ist eine abstrakte Basisklasse.

 ReadmeAssetManager ( cache_path , style_urls = None )

Klasse GitHubAssetManager(ReadmeAssetManager)

Verwaltet die Stil- und Schriftarten-Assets, die mit Readme-Seiten gerendert werden. Setzen Sie „cache_path“ auf „None“, um das Caching zu deaktivieren.

Klasse ReadmeReader(Objekt)

Liest Readme-Inhalt aus einem URL-Unterpfad. Dies ist eine abstrakte Basisklasse.

 ReadmeReader ()

Klasse DirectoryReader(ReadmeReader)

Liest Readme-Dateien aus URL-Unterpfaden.

 DirectoryReader ( path = None , silent = False )

Klasse TextReader(ReadmeReader)

Liest den Readme-Inhalt aus der bereitgestellten Unicode-Zeichenfolge.

 TextReader ( text , display_filename = None )

Klasse StdinReader(TextReader)

Liest Readme-Text von STDIN.

 StdinReader ( display_filename = None )

Klasse ReadmeRenderer(Objekt)

Rendert die Readme-Datei. Dies ist eine abstrakte Basisklasse.

 ReadmeRenderer ( user_content = None , context = None )

Klasse GitHubRenderer(ReadmeRenderer)

Rendert die angegebene Readme-Datei mithilfe der GitHub-Markdown-API.

 GitHubRenderer ( user_content = None , context = None , api_url = None , raw = None )

Klasse OfflineRenderer(ReadmeRenderer)

Rendert die angegebene Readme-Datei lokal mit reinem Python. Hinweis: Dies ist derzeit eine unvollständige Funktion.

 OfflineRenderer ( user_content = None , context = None )

Konstanten

SUPPORTED_TITLES

Die gängigen Markdown-Dateititel auf GitHub.

 SUPPORTED_TITLES = [ 'README' , 'Home' ]

filename : Die zu lesende UTF-8-Datei.

SUPPORTED_EXTENSIONS

Die unterstützten Erweiterungen, wie von GitHub definiert.

 SUPPORTED_EXTENSIONS = [ '.md' , '.markdown' ]

DEFAULT_FILENAMES

Diese Konstante enthält die Namen, nach denen Grip sucht, wenn keine Datei bereitgestellt wird.

 DEFAULT_FILENAMES = [ title + ext
                     for title in SUPPORTED_TITLES
                     for ext in SUPPORTED_EXTENSIONS ]

DEFAULT_FILENAME

Diese Konstante enthält den Standard-Readme-Dateinamen, nämlich:

 DEFAULT_FILENAME = DEFAULT_FILENAMES [ 0 ]  # README.md

DEFAULT_GRIPHOME

Diese Konstante verweist auf den Standardwert, wenn die Umgebungsvariable GRIPHOME nicht angegeben ist.

 DEFAULT_GRIPHOME = '~/.grip'

DEFAULT_GRIPURL

Die Standard-URL des Grip-Servers und aller seiner Assets:

 DEFAULT_GRIPURL = '/__/grip'

DEFAULT_API_URL

Der Standardwert für app_url:

 DEFAULT_API_URL = 'https://api.github.com'

Testen

Installieren Sie das Paket und testen Sie die Anforderungen:

$ pip install -e .[tests]

Führen Sie Tests mit Pytest durch:

$ pytest

Oder um Tests erneut auszuführen, während Sie Änderungen vornehmen, verwenden Sie pytest-watch:

$ ptw

Externe Annahmetests

Wenn Sie ein Problem mit Grip haben, ist es wahrscheinlich, dass eine Annahme bezüglich der GitHub-API nicht erfüllt wurde. Um dies zu überprüfen, führen Sie Folgendes aus:

$ pytest -m assumption

Da die externen Annahmen auf einer Internetverbindung basieren, möchten Sie sie möglicherweise bei der lokalen Entwicklung überspringen. Verkürzen Sie den Zyklus noch weiter, indem Sie beim ersten Fehler mit -x anhalten:

$ pytest -xm " not assumption "

Oder mit pytest-watch:

$ ptw -- -xm " not assumption "

Mitwirken

Überprüfen Sie die offenen Probleme oder eröffnen Sie ein neues Problem, um eine Diskussion über Ihre Feature-Idee oder den gefundenen Fehler zu starten
Forken Sie das Repository und nehmen Sie Ihre Änderungen vor
Öffnen Sie eine neue Pull-Anfrage

Wenn Ihre PR eine Weile gewartet hat, können Sie mich gerne auf Twitter anpingen.

Benutzen Sie diese Software oft? ?

Expandieren