J'ai besoin de convertir une sortie de journal git en objet.

J'utilise la commande git log --all --graph --oneline --date-order.

* 8896805 (origin/firstbranch) test(firstbranch): this is my commit on this branch
| * 5fef2da (HEAD -> testbranch, origin/another, another) refactor(another): this is a change
| * 2a34d72 refactor(another): typo
| * 683d704 refactor(another): changes
* |   0120274 Merge remote-tracking branch 'origin/develop' into firstbranch
|\ \

Après cela, j'ai créé un tableau où chaque élément du tableau correspond à une ligne de cette sortie.

Et avec ça, j'aimerais avoir un tableau comme celui-ci :

[
    {
        art: "*",
        commitHash: "8896805",
        branches: ["origin/firstbranch"],
        commitString: "test(firstbranch): this is my commit on this branch"
    },
    {
        art: "| *",
        commitHash: "5fef2da",
        branches: ["testbranch", "origin/another", "another"],
        commitString: "refactor(another): this is a change"
    },
    {
        art: "| *",
        commitHash: "2a34d72",
        branches: [],
        commitString: "refactor(another): typo"
    },
    {
        art: "| *",
        commitHash: "683d704",
        branches: [],
        commitString: "refactor(another): changes"
    },
    {
        art: "* |",
        commitHash: "0120274",
        branches: [],
        commitString: "Merge remote-tracking branch 'origin/develop' into firstbranch"
    },
    {
        art: "|\ \",
        commitHash: "",
        branches: [],
        commitString: ""
    }
]

Mais je n'arrive pas à obtenir ce résultat.

Merci d'avance!

2
Nulji 17 mars 2019 à 17:04

2 réponses

Meilleure réponse

Voici une solution possible utilisant une seule expression régulière, puis rogner chaque valeur, et enfin diviser les branches dans un tableau :

const input = [
  '* 8896805 (origin/firstbranch) test(firstbranch): this is my commit on this branch',
  '| * 5fef2da (HEAD -> testbranch, origin/another, another) refactor(another): this is a change',
  '| * 2a34d72 refactor(another): typo',
  '| * 683d704 refactor(another): changes',
  '* |   0120274 Merge remote-tracking branch \'origin/develop\' into firstbranch',
  '|\\ \\'
];

const result = input.map(entry => {
  let [, alt, commitHash, branches, commitString] = entry
    .match(/^([|*\s\\]+)(?:\s+([a-f0-9]+)?(?:\s+\((?:HEAD\s+->\s+)?([^)]+)\))?(?:\s+(.*))?)?$/)
    .map(value => value ? value.trim() : '');
  branches = branches ? branches.split(/\s*,\s*/) : [];
  return {alt, commitHash, branches, commitString};
});

console.log(result);
1
Jeto 17 mars 2019 à 15:04

Vous pouvez faire quelque chose comme ça avec le regex.

  1. alt regex
    • ^\W+ - Ceci correspond à tous les caractères non-mot au début de la chaîne.
  2. commitHash regex
    • \w+ - Cela correspond à tous les caractères du mot et nous sélectionnons uniquement la première correspondance
  3. branches regex
    • /\(.*?\)/ - Cela correspond à toutes les branches ( branches here )
    • à partir des branches de matchs, nous remplaçons (Head -> et () par replace
  4. commit regex
    • /.*?\)|\W+/ - Remplacez tous les caractères jusqu'au premier ) ou tous les caractères autres que des mots.
let str = `* 8896805 (origin/firstbranch) test(firstbranch): this is my commit on this branch
| * 5fef2da (HEAD -> testbranch, origin\/another, another) refactor(another): this is a change
| * 2a34d72 refactor(another): typo
| * 683d704 refactor(another): changes
* |   0120274 Merge remote-tracking branch 'origin/develop' into firstbranch
|\\ \\`

let splited = str.split('\n')

let op = splited.map(inp=>{
  let alt = "" 
  inp = inp.replace(/^\W+/,(match)=>{alt=match; return ''})
  
  let commitHash = ''
  inp = inp.replace(/\s*(\w+)\s*/,(match,g1)=>{commitHash = g1;return ''})
  let branches = ''
  inp = inp.replace(/^\s*(\(.*?\))/,(match,g1)=>{branches = g1; return ''})
  branches = branches ? branches.replace(/^\s*\(HEAD\s*->\s*|[)(]/g,'').split(/\s*,\s*/) : []
  let commit = inp.trim()
  return {alt,commitHash,branches,commit}
})

console.log(op)

Remarque :- Veuillez noter qu'il ne s'agit pas d'une preuve complète. j'ai examiné les cas selon les informations fournies, mais il peut y avoir beaucoup plus de cas

1
Code Maniac 17 mars 2019 à 17:13