Het automatiseren van het hernoemen van alle variabelen naar camelCase in Sublime Text vereist het gebruik van een plugin of een externe tool, omdat Sublime Text zelf geen ingebouwde refactoring tools biedt die zo specifiek zijn. Een goede aanpak is het gebruik van een Python-script in combinatie met een build systeem of een plugin zoals "SublimeLinter" met een refactoring plugin, of het gebruik van een externe formatter zoals Black of isort voor PEP8 conformiteit. Hieronder geef ik je een stapsgewijze aanpak om dit te realiseren, inclusief voorbeeldconfiguraties. Stap 1: Installeer Package Control (indien nog niet geïnstalleerd) - Ga naar https://packagecontrol.io/ en volg de instructies. Stap 2: Installeer benodigde plugins - Open de Command Palette (Ctrl+Shift+P of Cmd+Shift+P). - Typ "Package Control: Install Package" en druk op Enter. - Installeer bijvoorbeeld "SublimeLinter" en "SublimeLinter-contrib-flake8" voor PEP8-checks. - Voor automatische refactoring kan je een plugin zoals "RegReplace" gebruiken. Stap 3: Maak een Python script voor variabelen hernoemen naar camelCase Omdat er geen directe ondersteuning is voor hernoemen van variabelen binnen Sublime Text, kun je een custom Python-script schrijven dat je in je project kunt uitvoeren. Voorbeeld Python script (rename_variables.py): ```python import re def to_camel_case(snake_str): components = snake_str.split('_') return components[0] + ''.join(x.title() for x in components[1:]) def refactor_code(file_path): with open(file_path, 'r', encoding='utf-8') as f: code = f.read() # Zoek variabelen volgens Python conventies (bijvoorbeeld variabelen die beginnen met een underscore of niet) pattern = re.compile(r'\b([a-zA-Z_][a-zA-Z0-9_]*)\b') # Verzamel alle variabelen die niet al in camelCase zijn variabelen = set(re.findall(r'\b[a-z_][a-z0-9_]*\b', code)) # Filter voor snake_case variabelen snake_case_vars = [var for var in variabelen if '_' in var] # Maak een mapping van snake_case naar camelCase mapping = {var: to_camel_case(var) for var in snake_case_vars} # Voer vervangingen uit for snake_var, camel_var in mapping.items(): code = re.sub(r'\b' + re.escape(snake_var) + r'\b', camel_var, code) # Schrijf het aangepaste code terug with open(file_path, 'w', encoding='utf-8') as f: f.write(code) if __name__ == '__main__': import sys if len(sys.argv) != 2: print("Gebruik: python rename_variables.py <bestand>") else: refactor_code(sys.argv[1]) ``` Stap 4: Voer het script uit in Sublime Text - Sla het script op als `rename_variables.py`. - Open je Python-bestand. - Vanuit de terminal of via de Build command, voer je uit: ``` python path/to/rename_variables.py bestand.py ``` - Of je kunt een build systeem instellen in Sublime Text om dit automatisch te doen. Stap 5: Volg PEP8 richtlijnen - Installeer en configureer Black voor automatische PEP8 formattering: - Installeer Black via pip: ``` pip install black ``` - Configureer een build systeem in Sublime Text: - Ga naar Tools > Build System > New Build System... - Voeg toe: ```json { "shell_cmd": "black '$file'" } ``` - Sla op als bijvoorbeeld "Black.sublime-build". - Nu kun je je bestand formatteren door Build te gebruiken (Ctrl+B). Samenvatting: - Installeer benodigde plugins. - Gebruik een Python-script om variabelen te hernoemen naar camelCase. - Gebruik Black om code conform PEP8 te maken. - Automatiseer het proces met build systemen of externe scripts. Let op: Deze aanpak vereist enige handmatige setup en het schrijven van een script, aangezien Sublime Text geen geavanceerde refactoring ondersteunt zoals IDE's dat doen.

Hier is een stapsgewijze handleiding om een aangepaste opdracht in Sublime Text te maken voor het hernoemen van variabelen naar camelCase volgens PEP8-richtlijnen: ## Stap 1: Installeer het Package Control Plugin (indien nog niet geïnstalleerd) - Open Sublime Text - Druk op `Ctrl+Shift+P` (Windows/Linux) of `Cmd+Shift+P` (Mac) - Type "Install Package Control" en druk op Enter ## Stap 2: Installeer de benodigde packages - Druk op `Ctrl+Shift+P` → "Package Control: Install Package" - Installeer deze packages: - **Anaconda** (voor Python-autocompletion en refactoring) - **Python Improved** (voor betere Python-syntax highlighting) ## Stap 3: Maak een nieuwe build system 1. Ga naar `Tools → Build System → New Build System` 2. Plak de volgende code: ```json { "cmd": ["python", "-c", " import re import sublime import sublime_plugin class CamelCaseVariablesCommand(sublime_plugin.TextCommand): def run(self, edit): # Haal de volledige tekst op content = self.view.substr(sublime.Region(0, self.view.size())) # Regex patronen voor verschillende variabele types patterns = [ r'\\b([a-z]+_[a-z_]+)\\b', # snake_case variabelen r'\\b([A-Z][a-z]*[A-Z][a-z]*)\\b', # PascalCase variabelen r'\\b([a-z]+[A-Z][a-z]*)\\b' # camelCase (voor consistentie) ] def to_camel_case(name): # Converteer naar camelCase if '_' in name: # snake_case naar camelCase parts = name.split('_') return parts[0] + ''.join(part.capitalize() for part in parts[1:]) elif name[0].isupper(): # PascalCase naar camelCase return name[0].lower() + name[1:] else: # Al camelCase, return origineel return name # Vervang alle variabelen for pattern in patterns: matches = list(re.finditer(pattern, content)) for match in reversed(matches): # Van achter naar voor om posities consistent te houden original = match.group(1) camel_case = to_camel_case(original) if original != camel_case: start = match.start(1) end = match.end(1) content = content[:start] + camel_case + content[end:] # Vervang de volledige tekst self.view.replace(edit, sublime.Region(0, self.view.size()), content) sublime.status_message('Variabelen geconverteerd naar camelCase') # Activeer de command view = sublime.active_window().active_view() view.run_command('camel_case_variables') "], "selector": "source.python", "file_regex": "^[ ]*File \\\"(...*?)\\\", line ([0-9]*)", "working_dir": "${file_path}" } ``` 3. Sla dit op als `CamelCaseConverter.sublime-build` ## Stap 4: Maak een key binding (optioneel) 1. Ga naar `Preferences → Key Bindings` 2. Voeg toe aan de rechter kant: ```json { "keys": ["ctrl+alt+c"], "command": "camel_case_variables", "context": [ { "key": "selector", "operator": "equal", "operand": "source.python" } ] } ``` ## Stap 5: Gebruik de opdracht - **Methode 1**: `Tools → Build System → CamelCaseConverter` en druk `Ctrl+B` - **Methode 2**: Druk `Ctrl+Shift+P` en zoek "Camel Case Variables" - **Methode 3**: Gebruik de key binding `Ctrl+Alt+C` ## Voorbeeld: **Voor conversie:** ```python def calculate_total_price(item_price, item_quantity): TAX_RATE = 0.21 subtotal = item_price * item_quantity total_tax = subtotal * TAX_RATE final_total = subtotal + total_tax return final_total ``` **Na conversie:** ```python def calculateTotalPrice(itemPrice, itemQuantity): taxRate = 0.21 subtotal = itemPrice * itemQuantity totalTax = subtotal * taxRate finalTotal = subtotal + totalTax return finalTotal ``` ## Belangrijke opmerkingen: - Deze opdracht werkt alleen met Python-bestanden - Constante variabelen (ALL_CAPS) worden ook geconverteerd naar camelCase - Test altijd eerst op een kopie van je code - De conversie is hoofdlettergevoelig De opdracht volgt PEP8-richtlijnen door consistente naamgeving toe te passen en behoudt de code-structuur en opmaak.