Ki: Un petit problème avec `.gitignore`

Le début de ça

L'une des tâches principales à faire après la «validation initiale» d'un projet est de «créer un joli» .gitignore »à partir de gitignore.io, n'est-ce pas? [^ 1] [^ 2]

** Y a-t-il? ** **

.Gitignore change avec le temps ...

Il n'y a aucun problème s'il peut être utilisé tel quel au début,

Oh, je veux aussi ajouter ignorer pour cet environnement
Il semble qu'un peu d'ignorance spéciale sera nécessaire

Cela peut sortir.

** Il sortira. ** **

Dans le cas (1), vous devrez peut-être accéder à nouveau à gitignore.io et le régénérer.

Dans le cas de (2), je dois l'écrire quelque part dans le ".gitignore" généré par le modèle. Si cela se produit, vous pouvez ressentir des problèmes chaque fois que vous répondez à (1). Peut-être

Acceptation: idées grossières et MVP

Idée

Donc, je me suis demandé si je pouvais faire quelque chose comme "un éditeur qui écrit simplement" nom de la langue "et" ignorer la langue "d'une manière agréable lors de l'édition .gitignore. L'interface utilisateur n'est-elle pas cool comme lazygit?

こんなの

Si vous entrez un mot-clé, "candidats pour les langues et environnements qui incluent ce mot-clé" apparaîtra.
Si vous passez à un candidat avec Tab et appuyez à droite ou quelque chose du genre, cela sera reflété comme une langue
Si vous sélectionnez un mot-clé et appuyez à droite alors qu'il n'y a pas de candidats, il sera reflété comme un motif
Lors de l'enregistrement, appelez l'API sans autorisation et compilez avec gitignore.io + pattern

Si vous pouvez le faire, il serait pratique d'ajouter tous les modèles que vous souhaitez ignorer dans la dérivation.

Cela dit, nous n'avons actuellement pas la possibilité de créer des éditeurs dans ce format.

Essayez de faire quelque chose comme ça (= MVP?) Sans aucun tracas

J'ai essayé une implémentation super simple comme MVP. Ici => vigi = vi gitignore

Lorsque vous exécutez la commande vigi,


# ~~~~~~

Ouvrez un fichier comme celui-ci avec vim et

.idea

# ~~~~~~
python
virtualenv

Si vous modifiez comme ceci et quittez vim,

.idea

# ~~~~~~

# https://www.gitignore.io/api/python,Contenu de virtualenv

Cela créera un .gitignore dans un état comme celui-ci.

Au fait, si vous exécutez la commande vigi dans cet état, la partie gitignore.io ne sera une information que pour la langue. Facile à modifier ... je pense.

Tran: Le contenu ressemble à ceci

Un style qui crée un fichier temporaire avec le nom «.gi», le modifie et le convertit en «.gitignore» lorsqu'il est enregistré.

import subprocess
from pathlib import Path
from subprocess import CalledProcessError, PIPE

def main():
    gi_path = Path.cwd() / '.gi'
    gitignore_path = Path.cwd() / '.gitignore'
    try:
        # Convert from ``.gitignore`` to ``.gi``
        if gitignore_path.exists():
            encode_gitignore(gitignore_path, gi_path)
        else:
            with gi_path.open('w') as fp:
                fp.write(dedent(gi_template).strip())
        # Spawn vim
        vim_args = ['/usr/bin/vim', str(gi_path)]
        vim_proc = subprocess.run(vim_args, check=True)
        # Convert from ``.gi`` to ``.gitignore``
        decode_gitignore(gi_path, gitignore_path)
    except CalledProcessError:
        pass
    finally:
        # Remove ``.gi``
        gi_path.unlink()

Appeler vim

Un style approximatif qui appelle vim avec subprocess.run et est OK s'il n'y a pas d'exceptions CalledProcessError. C'est facile et bon.

Ne laissez pas `.gi`

J'utilise try ~ finally et je jette finalement le fichier .gi. S'il y a une erreur, .gitignore n'est pas édité, il est donc écologique.

Créer `.gitignore` en fonction du matériau

Le fichier .gi est normalement sur le système de fichiers à ce stade, donc on a l'impression de l'ouvrir comme un fichier normal. Ensuite, rassemblez les informations côté langue et transmettez-les à gitignore.io. Uniquement lorsque l'état HTTP est 404, la réponse est enregistrée comme d'habitude, En effet, tous les cas qui "contiennent des informations qui n'existent pas dans le maître" semblent être 404. C'est la seule chose que l'on puisse dire comme un peu d'ingéniosité.

def decode_gitignore(src, dest):
    custom = []
    online = []
    with src.open() as fp:
        # .Ouvrez le fichier gi et séparez l'avant et l'arrière de la délimitation, etc.
    if online:
        url = f'https://www.gitignore.io/api/{",".join(online)}'
        req = Request(url, None, headers={'User-Agent': 'vigi'})
        try:
            resp = urlopen(req)
            custom.append(resp.read().decode())
        except HTTPError as err:
            if err.code == 404:
                custom.append(resp.read().decode())
            raise err
    with dest.open('w') as fp:
        fp.write('\n'.join(custom))

Conclusion: convivialité

Pour le moment, «.gitignore» dans le projet «vigi» a été créé sur la base de cette commande.

Je pense que c'est un mérite que le nombre de lignes affichées au moment de l'édition soit considérablement réduit. En ce sens, il a bien fait son travail de MVP.

Cependant, je ne sais pas quel type de modèle est inclus dans le master de langue avant d'avoir terminé la conversion en .gitignore. Si je voulais le développer un peu plus, je devais retirer correctement le maître de langue des candidats de modèle. Je ne sais pas si c'est vraiment bon. ~~ Peut-être convient-il pour une formation dans une langue? ~~

[^ 1]: Il existe un modèle de projet, mais oubliez-le. [^ 2]: Vous pouvez le gérer avec dotfiles, mais oubliez cela aussi

Je pensais que je pouvais créer un bon éditeur gitignore, alors j'ai essayé de faire quelque chose comme MVP pour le moment

Ki: Un petit problème avec .gitignore