CleanUpWiki_v9 - itnett/FTD02H-N GitHub Wiki

Her er en fullstendig utgave av migreringsskriptet som utfører alle trinnene du har beskrevet:

import os
import re
import subprocess
import datetime
from pathlib import Path

# Funksjon for å identifisere kjørbar kode i et kjent format
def is_executable_code_block(code_block):
    executable_patterns = [r'^```python', r'^```bash', r'^```sql', r'^```makefile', r'^```shell']
    for pattern in executable_patterns:
        if re.search(pattern, code_block, re.MULTILINE):
            return True
    return False

# Funksjon for å bestemme filtypen basert på kodeblokken
def determine_extension(code_block):
    if '```python' in code_block:
        return 'py'
    elif '```bash' in code_block or '```shell' in code_block:
        return 'sh'
    elif '```sql' in code_block:
        return 'sql'
    elif '```makefile' in code_block:
        return 'makefile'
    else:
        return None

# Funksjon for å migrere kodeblokker og generere README-filer
def migrate_code_blocks(input_dir, output_dir):
    if not os.path.exists(output_dir):
        os.makedirs(output_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()

                code_blocks = re.findall(r'```.*?```', content, re.DOTALL)

                for block in code_blocks:
                    if is_executable_code_block(block):
                        extension = determine_extension(block)
                        if extension:
                            relative_path = os.path.relpath(file_path, input_dir)
                            base_name = os.path.splitext(os.path.basename(file))[0]
                            output_subdir = os.path.join(output_dir, extension.capitalize())
                            if not os.path.exists(output_subdir):
                                os.makedirs(output_subdir)
                            output_file_path = os.path.join(output_subdir, f"{base_name}.{extension}")

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

                            print(f"Kode blokk eksportert til {output_file_path}")

                            # Generer README.md fil
                            readme_path = os.path.join(output_subdir, f"{base_name}_README.md")
                            with open(readme_path, 'w', encoding='utf-8') as readme_file:
                                readme_file.write(f"# {base_name}\n")
                                readme_file.write(f"Opprinnelig kilde: {relative_path}\n")
                                readme_file.write(f"Kode eksportert til: {output_file_path}\n")
                                readme_file.write("## Beskrivelse\n")
                                readme_file.write("Beskrivelse av hva koden gjør.\n")
                                readme_file.write("## Referanser\n")
                                readme_file.write(f"Denne koden ble eksportert fra {file_path}\n")

# 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, 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
repo_directory = 'C:/WikiMigration/git/wiki_repo'
output_directory = 'C:/WikiMigration/git/code_repo'

# Kjør migreringen
migrate_code_blocks(repo_directory, output_directory)

# 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/Python/'  # Juster etter behov
update_wiki_urls(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, commit_message_code_repo)
git_operations(repo_directory, commit_message_wiki_repo)

Funksjonaliteter i Skriptet:

  1. Migrering av Kodeblokker:

    • Filtrerer og eksporterer kun kjørbare kodeblokker (Python, Bash, SQL osv.) fra .md-filer i wiki-repoet.
    • Lagrer disse i en passende mappe i code_repo med riktig filtype.
    • Genererer en README.md-fil for hver kodefil med relevant informasjon om koden.

  2. Oppdatering av URL-er:

    • Oppdaterer URL-er i wiki-sidene slik at de peker til de riktige filene i code_repo.

  3. Git-operasjoner:

    • Utfører Git-kommandoer for å legge til, commit, pull og pushe endringer både for code_repo og wiki_repo.
    • Genererer commit-meldinger med tidsstempel for sporing.

Hvordan Kjøre Skriptet:

  1. Naviger til Katalogen:

    • Åpne CMD eller PowerShell og naviger til C:\WikiMigration.

  2. Kjør Skriptet:

    • Kjør skriptet med kommandoen:
    python backup_and_prepare_v02.py

Viktige Forventninger:

  • Filstruktur: Skriptet vil opprette mapper basert på filtyper i code_repo.
  • URL-oppdatering: Det forutsettes at alle relevante URL-er i wiki-repoet blir oppdatert for å reflektere den nye plasseringen av koden.
  • Loggføring: Alle operasjoner blir loggført, slik at du kan spore hva som har blitt gjort og hvor endringer har skjedd.

Dette skriptet skal håndtere hele prosessen fra migrering av kode til oppdatering av wiki og synkronisering med GitHub. Hvis du trenger ytterligere tilpasninger, er det bare å si fra!