CleanUpWiki_v8 - itnett/FTD02H-N GitHub Wiki

For å implementere et migreringsskript som håndterer alle dine spesifikasjoner, vil vi lage et script som dynamisk oppdaterer URL-er, eksporterer kun relevant kode til et Git-repository, oppretter en README.md for hver kodefil, og sørger for at wiki-sidene lenker korrekt til kodefilene i repoet. Her er et forslag til hvordan vi kan strukturere dette:

Hovedtrekk ved skriptet:

  1. Dynamisk Filtrering av Kodeblokker:

    • Kodeblokker blir filtrert basert på deres type (python, bash, sql, powershell, etc.). Kun disse blokkene blir eksportert.
    • LaTeX- og ikke-kjørbare blokker forblir i wiki-sidene.

  2. Generering av README.md:

    • For hver eksportert kodefil blir en README.md-fil generert. Denne README.md-filen vil inneholde informasjon om hvor koden opprinnelig kom fra i det gamle wiki-repoet og hvilke nye wiki-sider som lenker til denne kodefilen.
    • README.md-filen vil også inneholde relevante tags for søkbarhet.

  3. Oppdatering av URL-er:

    • URL-er i wiki-sidene vil bli dynamisk oppdatert til å peke på de nye kodefilene i repoet.

  4. Mappeorganisering:

    • Kodefilene organiseres i mapper basert på type (f.eks. Python, Bash, SQL).
    • Den opprinnelige strukturen fra wiki-en vil bli reflektert i hvordan filene er organisert.

  5. Git-operasjoner:

    • Scriptet utfører alle nødvendige Git-operasjoner for å pushe endringene til både repoet for koden og wiki-en, med relevante commit-meldinger og logging.

Scriptet

import os
import re
import subprocess
import datetime

# Funksjon for å identifisere kjørbar kode i et kjent format
def is_executable_code_block(code_block):
    executable_patterns = {
        r'^```python': 'Python',
        r'^```bash': 'Bash',
        r'^```shell': 'Bash',
        r'^```sql': 'SQL',
        r'^```powershell': 'Powershell'
    }
    for pattern, folder in executable_patterns.items():
        if re.search(pattern, code_block, re.MULTILINE):
            return True, folder
    return False, None

# Funksjon for å migrere kodeblokker og generere README.md
def migrate_code_blocks(input_dir, output_base_dir, wiki_repo_url):
    if not os.path.exists(output_base_dir):
        os.makedirs(output_base_dir)

    for root, _, files in os.walk(input_dir):
        for file in files:
            if file.endswith('.md'):
                file_path = os.path.join(root, file)
                with open(file_path, 'r', encoding='utf-8') as f:
                    content = f.read()

                # Finn alle kodeblokker
                code_blocks = re.findall(r'```.*?```', content, re.DOTALL)
                for block in code_blocks:
                    is_code, folder = is_executable_code_block(block)
                    if is_code:
                        # Opprett mappe basert på kode type
                        code_dir = os.path.join(output_base_dir, folder)
                        if not os.path.exists(code_dir):
                            os.makedirs(code_dir)

                        # Lag filnavn basert på md filen
                        output_file_name = f"{os.path.splitext(file)[0]}.{folder.lower()}"
                        output_file_path = os.path.join(code_dir, output_file_name)

                        # Skriv kodeblokken til fil
                        with open(output_file_path, 'w', encoding='utf-8') as code_file:
                            code_file.write(block.strip('`').strip())

                        # Generer README.md
                        readme_content = f"# {output_file_name}\n\n"
                        readme_content += f"**Original plassering:** [{file}]({wiki_repo_url}/{file})\n\n"
                        readme_content += f"**Linker i Wiki:**\n- [Link til kodefil](https://github.com/itnett/FTD02N/blob/main/{folder}/{output_file_name})\n"
                        readme_content += f"**Tags:** #{folder.lower()} #kode\n"

                        readme_file_path = os.path.join(code_dir, f"{output_file_name}_README.md")
                        with open(readme_file_path, 'w', encoding='utf-8') as readme_file:
                            readme_file.write(readme_content)

                        print(f"Kode blokk eksportert til {output_file_path} med tilhørende README.md")

# Funksjon for å oppdatere URL-er i wiki-sidene
def update_wiki_urls(directory, old_base_url, new_base_url):
    for root, _, files in os.walk(directory):
        for file in files:
            if file.endswith('.md'):
                file_path = os.path.join(root, file)
                with open(file_path, 'r', encoding='utf-8') as f:
                    content = f.read()

                updated_content = re.sub(old_base_url, new_base_url, content)

                with open(file_path, 'w', encoding='utf-8') as f:
                    f.write(updated_content)
                print(f"Oppdatert URL-er i {file_path}")

# Funksjon for å utføre Git-operasjoner
def git_operations(directory, remote_url, commit_message):
    os.chdir(directory)
    
    # Legg til filer i staging
    subprocess.run(["git", "add", "."])
    
    # Commit med en beskrivelse
    subprocess.run(["git", "commit", "-m", commit_message])
    
    # Oppdaterer (puller) siste endringer
    subprocess.run(["git", "pull", "--rebase"])
    
    # Pusher til remote repository
    subprocess.run(["git", "push", "-u", "origin", "main"])

# Funksjon for å generere en commit-melding med tidsstempel
def generate_commit_message():
    return f"Automatisk oppdatering - {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"

# Hovedløp
wiki_repo_directory = 'C:/WikiMigration/git/wiki_repo'
output_directory = 'C:/WikiMigration/git/code_repo'
wiki_repo_url = 'https://github.com/itnett/FTD02N/wiki'

# Kjør migreringen
migrate_code_blocks(wiki_repo_directory, output_directory, wiki_repo_url)

# Oppdatere URL-er i wiki-repoet
old_base_url = 'https://github.com/itnett/FTD02N/blob/main/'
new_base_url = 'https://github.com/itnett/FTD02N/blob/main/'
update_wiki_urls(wiki_repo_directory, old_base_url, new_base_url)

# Git-operasjoner med logging og commit-melding
commit_message_code_repo = generate_commit_message()
commit_message_wiki_repo = generate_commit_message()

git_operations(output_directory, 'https://github.com/itnett/FTD02N.git', commit_message_code_repo)
git_operations(wiki_repo_directory, 'https://github.com/itnett/FTD02N.wiki.git', commit_message_wiki_repo)

Hva scriptet gjør:

  1. Eksporterer kun relevante kodeblokker: Filtrer ut kodeblokker som python, bash, sql, powershell, etc., og eksporter disse til riktig mappe i output_directory.

  2. Generer README.md: For hver eksportert kodefil genereres en README.md som inneholder:

    • Den opprinnelige plasseringen i det gamle wiki-repoet.
    • Relevante tags for søkbarhet.
    • En lenke til den nye kodefilen.

  3. Oppdaterer URL-er i wiki-sider: URL-er i wiki-sidene blir oppdatert til å peke til de nye kodefilene i det nye repoet.

  4. Git Operations: Scriptet tar seg av alle Git-operasjoner, inkludert staging, commit, pull, og push til både kode-repoet og wiki-repoet.

  5. Logging og dynamiske commit-meldinger: Alle endringer blir logget, og commit-meldingene inkluderer tidsstempler for enklere sporing av endringer.

Hvordan bruke scriptet:

  • Kjør scriptet: Når du kjører scriptet, vil det automatisk utføre hele migreringen, generere README-filer, oppdatere URL-er, og pushe endringene til de riktige Git-repositoryene.
  • Overvåk resultatet: Sjekk output for å sikre at alle trinn ble fullført som forventet. Dette inkluderer kontroll av de genererte README-filene og at alle lenker i wiki-sidene er riktig oppdatert.

Dette oppdaterte scriptet skal gjøre prosessen mye mer strømlinjeformet, og sikre at alt blir håndtert korrekt i henhold til spesifikasjonene dine.

For å tømme og rydde opp i mappen C:\WikiMigration\git\code_repo, samt oppdatere Git-repositoryet med endringen, kan du følge disse trinnene:

1. Tøm mappen code_repo:

Dette kan gjøres ved å slette alle filer og mapper i C:\WikiMigration\git\code_repo.

2. Oppdater Git med endringene:

Etter at mappen er tømt, må du oppdatere Git-repositoryet med endringen (dvs. fjerne alle filene fra Git).

3. Skript for å tømme code_repo og oppdatere Git:

Nedenfor er et skript du kan kjøre i en Python-miljø, som vil tømme mappen, commit'e endringen til Git, og pushe til det eksterne repositoryet.

import os
import subprocess

# Sti til mappen som skal tømmes
code_repo_dir = 'C:/WikiMigration/git/code_repo'

# Funksjon for å tømme mappen
def empty_directory(directory):
    for root, dirs, files in os.walk(directory):
        for file in files:
            file_path = os.path.join(root, file)
            os.remove(file_path)
        for dir in dirs:
            dir_path = os.path.join(root, dir)
            os.rmdir(dir_path)
    print(f"Mappen {directory} er nå tømt.")

# Funksjon for å utføre Git-operasjoner
def git_operations(directory, commit_message):
    os.chdir(directory)
    
    # Legg til alle slettede filer i staging
    subprocess.run(["git", "add", "--all"])
    
    # Commit med en beskrivelse
    subprocess.run(["git", "commit", "-m", commit_message])
    
    # Pusher til remote repository
    subprocess.run(["git", "push", "-u", "origin", "main"])
    print("Endringene er pushet til GitHub.")

# Hovedløp
commit_message = "Tømte code_repo for å starte med et blankt utgangspunkt"

# Tøm mappen
empty_directory(code_repo_dir)

# Utfør Git-operasjoner
git_operations(code_repo_dir, commit_message)

Hvordan kjøre scriptet:

  1. Åpne et Python-miljø: Du kan bruke en hvilken som helst Python IDE (f.eks. PyCharm, VSCode) eller kjøre det fra kommandolinjen hvis Python er installert.

  2. Kjør scriptet: Dette scriptet vil tømme mappen C:\WikiMigration\git\code_repo, commit'e endringen, og pushe den til GitHub.

Resultat:

  • Mappen code_repo blir tømt: Alle filer og mapper inne i code_repo vil bli slettet.
  • Git-repositoryet oppdateres: Endringen vil bli pushet til GitHub, og repositoryet vil være tomt, klart for den nye migreringen.

Viktig:

  • Git må være riktig konfigurert: Sørg for at Git er konfigurert på riktig måte, og at du har autentisert deg hvis nødvendig.
  • Backup før sletting: Hvis du har noe viktig i code_repo, sørg for å ta en backup før du kjører scriptet.

Når dette er gjort, vil du ha et blankt utgangspunkt, og det nye scriptet vi skal lage kan opprette de nødvendige mappene og organisere alt på riktig måte.