CleanUpWiki_v11 - itnett/FTD02H-N GitHub Wiki

Feilen indikerer at skriptet prøver å utføre Git-operasjoner i en katalog som ikke er en gyldig Git-repositorium. For å løse dette problemet, la oss gå gjennom følgende sjekkpunkter og gjøre noen justeringer i skriptet:

Mulige årsaker og løsninger:

  1. Katalogene er ikke Git-repositorier:

    • Før du kjører Git-operasjonene, må vi sikre at katalogene code_repo_directory og dump_directory faktisk er Git-repositorier. Dette betyr at de må inneholde en .git-mappe.

  2. Kloning av repoet hvis det ikke eksisterer:

    • Vi må sørge for at dump_directory og code_repo_directory er gyldige Git-repositorier ved å klone repoene hvis de ikke allerede finnes.

Justert skript:

Her er en oppdatert versjon av skriptet med sjekk for om katalogene er gyldige Git-repositorier. Hvis de ikke er det, vil skriptet klone dem automatisk.

import os
import re
import subprocess
import datetime
import yaml

# Last inn konfigurasjonen fra input.yml
with open('input.yml', 'r') as file:
    config = yaml.safe_load(file)

wiki_repo_url = config['wiki_repo_url']
dump_directory = config['dump_directory']
code_repo_url = config['code_repo_url']
wiki_repo_new_url = config['wiki_repo_new_url']
code_repo_directory = config['code_repo_directory']
wiki_repo_directory = config['wiki_repo_directory']

# Funksjon for å sjekke om en katalog er et git-repo
def is_git_repo(directory):
    return os.path.isdir(os.path.join(directory, '.git'))

# Funksjon for å sikre at katalogen er et Git-repo (kloner hvis nødvendig)
def ensure_git_repo(directory, repo_url):
    if not is_git_repo(directory):
        if not os.path.exists(directory):
            os.makedirs(directory)
        subprocess.run(["git", "clone", repo_url, directory])
    os.chdir(directory)

# 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 å migrere kodeblokker
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()

                # Finn alle kodeblokker
                code_blocks = re.findall(r'```.*?```', content, re.DOTALL)

                for block in code_blocks:
                    if is_executable_code_block(block):
                        # Bestem filtype basert på innholdet
                        if '```python' in block:
                            extension = 'py'
                            folder = 'Python'
                        elif '```bash' in block or '```shell' in block:
                            extension = 'sh'
                            folder = 'ShellScripts'
                        elif '```sql' in block:
                            extension = 'sql'
                            folder = 'SQL'
                        elif '```makefile' in block:
                            extension = 'makefile'
                            folder = 'Makefiles'
                        else:
                            continue

                        # Lag mappe hvis den ikke eksisterer
                        output_folder = os.path.join(output_dir, folder)
                        if not os.path.exists(output_folder):
                            os.makedirs(output_folder)

                        output_file_path = os.path.join(output_folder, f"{os.path.splitext(file)[0]}.{extension}")
                        with open(output_file_path, 'w', encoding='utf-8') as code_file:
                            code_file.write(block.strip('`').strip())

                        # Opprett README.md for koden
                        readme_path = os.path.join(output_folder, 'README.md')
                        with open(readme_path, 'w', encoding='utf-8') as readme_file:
                            readme_content = (
                                f"# {file}\n\n"
                                f"**Original Location**: {file_path}\n\n"
                                f"**Link in Wiki**: [{file}](https://github.com/itnett/FTD02N/wiki/{os.path.splitext(file)[0]})\n"
                            )
                            readme_file.write(readme_content)

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

# 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
# Sørg for at dump_directory er et git-repo
ensure_git_repo(dump_directory, wiki_repo_url)

# Migrer kodeblokker til ny repo
migrate_code_blocks(dump_directory, code_repo_directory)

# Oppdater URL-er i den nye Wiki-repoen
old_base_url = 'https://github.com/itnett/FTD02N/blob/main/'
new_base_url = 'https://github.com/itnett/FTD02N/blob/main/'
update_wiki_urls(dump_directory, old_base_url, new_base_url)

# Sørg for at code_repo_directory er et git-repo
ensure_git_repo(code_repo_directory, code_repo_url)

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

git_operations(code_repo_directory, commit_message_code_repo)
git_operations(dump_directory, commit_message_wiki_repo)

Slik fungerer det:

  1. Kloning av repoer: Hvis katalogene for dump_directory (for den gamle wiki-repoen) og code_repo_directory (for den nye kode-repoen) ikke eksisterer eller ikke er git-repositorier, kloner skriptet automatisk de nødvendige repoene fra GitHub.

  2. Migrering av kodeblokker: Skriptet migrerer kjørbare kodeblokker fra den gamle wiki-repoen til den nye kode-repoen, organiserer dem i mapper og genererer en README.md-fil for hver kodefil.

  3. Oppdatering av URL-er: Alle lenker i de oppdaterte wiki-filene peker nå til de nye plasseringene i kode-repoen.

  4. Git-operasjoner: Alle endringer blir commitet og pushet til de respektive GitHub-repoene.

Prøv å kjøre denne versjonen av skriptet. Hvis alt er satt opp riktig, bør det nå fungere uten feil.