FormatDS.py

import tkinter as tk
from tkinter import filedialog
import configparser
import shutil
import os
import subprocess
import sys
import chardet

from error_decoder import extract_error_messages, extract_error_info, find_single_prjscr_file, update_prjscr_file
from like_handler import like_processing_content_restore, like_processing_content_preprocess


class FileProcessorGUI:
    def __init__(self, master):
        self.master = master
        self.master.title("DelphiScript Formatter 0.6")

        # Set minimum window size
        self.master.minsize(width=400, height=150)

        self.file_path = None
        self.config_file_path = None
        self.rev_config_file_path = None

        # Initialize checkbox variables
        self.comma_handler_var = tk.BooleanVar()
        self.delimiter_handler_var = tk.BooleanVar()
        self.like_handler_var = tk.BooleanVar()
        self.generate_bak_var = tk.BooleanVar()
        self.keep_work_var = tk.BooleanVar()

        self.file_path_label = tk.Label(self.master, text="File Path:")
        self.file_path_label.pack(padx=10, pady=(5, 0), anchor=tk.W)

        self.config_label_text = tk.StringVar()
        self.config_label_text.set("Config File: Default")
        self.file_path_label_cfg = tk.Label(self.master, textvariable=self.config_label_text)
        self.file_path_label_cfg.pack(padx=10, pady=(0, 5), anchor=tk.W)

        # Checkbox for Function declaration format comma handler
        self.comma_handler_var = tk.BooleanVar()
        self.comma_handler_checkbox = tk.Checkbutton(self.master, text="Function declaration format comma handler",
                                                     variable=self.comma_handler_var,
                                                     command=self.update_config_file)
        self.comma_handler_checkbox.pack(padx=10, pady=(5, 0), anchor=tk.W)

        # Checkbox for Change declaration delimiters to semicolons
        self.delimiter_handler_var = tk.BooleanVar()
        self.delimiter_handler_checkbox = tk.Checkbutton(self.master,
                                                         text="Change declaration delimiters to semicolons",
                                                         variable=self.delimiter_handler_var,
                                                         command=self.update_config_file,
                                                         state=tk.DISABLED)
        self.delimiter_handler_checkbox.pack(padx=10, pady=(0, 5), anchor=tk.W)

        self.like_handler_var = tk.BooleanVar()
        self.like_handler_checkbox = tk.Checkbutton(self.master,
                                                    text="Preprocess \'like\' operator",
                                                    variable=self.like_handler_var,
                                                    command=self.update_config_file)
        self.like_handler_checkbox.pack(padx=10, pady=(0, 5), anchor=tk.W)

        self.generate_bak_var = tk.BooleanVar()
        self.generate_bak_checkbox = tk.Checkbutton(self.master,
                                                    text="Make backup (.bak) file",
                                                    variable=self.generate_bak_var,
                                                    command=self.update_config_file)
        self.generate_bak_checkbox.pack(padx=10, pady=(5, 0), anchor=tk.W)

        self.keep_work_var = tk.BooleanVar()
        self.keep_work_checkbox = tk.Checkbutton(self.master,
                                                 text="Keep work (.wrk) file",
                                                 variable=self.keep_work_var,
                                                 command=self.update_config_file)
        self.keep_work_checkbox.pack(padx=10, pady=(0, 5), anchor=tk.W)

        self.generate_breakpoints_var = tk.BooleanVar()
        self.generate_breakpoints_checkbox = tk.Checkbutton(self.master,
                                                 text="Generate Breakpoints for Errors (to Altium .PrjScr File)",
                                                 variable=self.generate_breakpoints_var,
                                                 command=self.update_config_file)
        self.generate_breakpoints_checkbox.pack(padx=10, pady=(0, 5), anchor=tk.W)

        self.open_button = tk.Button(self.master, text="Open", command=self.open_file, width=15, height=2)
        self.open_button.pack(side=tk.LEFT, padx=10, pady=5)

        self.process_button = tk.Button(self.master, text="Process", command=self.process_file, width=15, height=2,
                                        state=tk.DISABLED)
        self.process_button.pack(side=tk.RIGHT, padx=10, pady=5)

        self.load_config_button = tk.Button(self.master, text="Load Config", command=self.load_config, width=15,
                                            height=2)
        self.load_config_button.pack(side=tk.LEFT, padx=10, pady=5)

        # Load setting states from config file
        self.load_settings()

    def load_settings(self):
        config = configparser.ConfigParser()
        try:
            config.read('DSF_settings.ini')
            self.comma_handler_var.set(config.getboolean('Settings', 'comma_handler'))
            self.delimiter_handler_var.set(config.getboolean('Settings', 'delimiter_handler'))
            self.like_handler_var.set(config.getboolean('Settings', 'like_handler'))
            self.generate_bak_var.set(config.getboolean('Settings', 'generate_bak'))
            self.keep_work_var.set(config.getboolean('Settings', 'keep_work_file'))
            self.generate_breakpoints_var.set(config.getboolean('Settings', 'generate_breakpoints'))
            self.update_checkbox_states()
        except configparser.Error:
            # If there's any issue reading the config file, all checkboxes will be set to default (False)
            pass

    def save_settings(self):
        config = configparser.ConfigParser()
        config['Settings'] = {
            'comma_handler': self.comma_handler_var.get(),
            'delimiter_handler': self.delimiter_handler_var.get(),
            'like_handler': self.like_handler_var.get(),
            'generate_bak': self.generate_bak_var.get(),
            'keep_work_file': self.keep_work_var.get(),
            'generate_breakpoints': self.generate_breakpoints_var.get()
        }
        with open('DSF_settings.ini', 'w') as configfile:
            config.write(configfile)

    def update_config_file(self):
        self.save_settings()
        self.update_checkbox_states()

    def update_checkbox_states(self):
        if not self.comma_handler_var.get():
            self.delimiter_handler_var.set(False)
            self.delimiter_handler_checkbox.config(state=tk.DISABLED)
        else:
            self.delimiter_handler_checkbox.config(state=tk.NORMAL)

    def open_file(self):
        file_path = filedialog.askopenfilename(filetypes=[("Pascal files", "*.pas")])
        if file_path:
            self.file_path_label.config(text="File Path: " + file_path)
            self.file_path = file_path
            self.process_button.config(state=tk.NORMAL)
        else:
            self.file_path_label.config(text="File Path:")
            self.file_path = None
            self.process_button.config(state=tk.DISABLED)

    def load_config(self):
        config_file_path = filedialog.askopenfilename(filetypes=[("Config files", "*.cfg")])
        if config_file_path:
            self.config_label_text.set("Config File: " + config_file_path)
            self.config_file_path = config_file_path

            # Check and modify the key in the config file if needed
            if self.check_and_modify_config():
                self.config_label_text.set("Config File: " + self.rev_config_file_path)
                self.config_file_path = self.rev_config_file_path
                print("Key 'JediCodeFormatSettings' renamed to 'CodeFormatSettings'. Using revised config file.")
            else:
                print("Using the provided config file.")
        else:
            self.config_label_text.set("Config File: Default")
            self.config_file_path = None

    def check_and_modify_config(self):
        if self.config_file_path and self.config_file_path.endswith('.cfg'):

            with open(self.config_file_path, 'rb') as config_file:
                config_content = config_file.read()

            # Check if JediCodeFormatSettings is present
            if b'JediCodeFormatSettings' in config_content:
                # Replace JediCodeFormatSettings with CodeFormatSettings
                modified_content = config_content.replace(b'JediCodeFormatSettings', b'CodeFormatSettings')

                # Save the modified content to a new file with _rev in the name
                self.rev_config_file_path = self.config_file_path.replace('.cfg', '_rev.cfg')

                with open(self.rev_config_file_path, 'wb') as rev_config_file:
                    rev_config_file.write(modified_content)

                return True

        return False

    def detect_encoding(self, file_path):
        with open(file_path, 'rb') as f:
            result = chardet.detect(f.read())
            return result['encoding']

    def convert_declaration_format(self, line: str, to_script: bool):
        old_char = ','
        new_char = ';'
        # Direction setting
        if to_script:
            old_char = ';'
            new_char = ','
        # Check if the line starts with "procedure" or "function"
        if line.strip().startswith(('procedure', 'function')):
            # Find the position of the opening and closing parentheses
            start_index = line.find('(')
            end_index = line.find(')')

            # If both opening and closing parentheses are found
            if start_index != -1 and end_index != -1:
                # Replace commas with semicolons within the parentheses
                line = line[:start_index + 1] + line[start_index + 1:end_index].replace(old_char, new_char) + line[
                                                                                                              end_index:]

        return line


    def process_filename(self, file_name):
        # Replace forward slashes with backslashes
        file_name = file_name.replace('/', '\\')

        # Check if the file name has .wrk as extension and remove it
        if file_name.endswith('.wrk'):
            file_name = file_name[:-4]

        return file_name

    def process_file(self):

        # This is set when a formatting error is found
        format_error = False

        # Make a backup copy with .bak extension
        bak_file_path = self.file_path + ".bak"
        if self.generate_bak_var:
            shutil.copy2(self.file_path, bak_file_path)

        # Detect source file encoding
        source_encoding = self.detect_encoding(self.file_path)

        # Modify the file content
        with open(self.file_path, 'r', encoding=source_encoding, errors='ignore') as original_file:
            content = original_file.readlines()

        # Process declaration formatting
        if self.comma_handler_var.get():
            for i, line in enumerate(content):
                content[i] = self.convert_declaration_format(line, False)

        if self.like_handler_var.get():
            content = like_processing_content_preprocess(content)

        modified_content = "unit Test;\ninterface\nimplementation\n\n" + ''.join(content) + "\nend."

        with open(self.file_path + ".wrk", 'w', encoding=source_encoding) as new_file:
            new_file.write(modified_content)

        # Run pascal-format.exe with optional config file
        script_dir = os.path.dirname(os.path.realpath(sys.argv[0]))
        pascal_format_path = os.path.join(script_dir, "pascal-format.exe")

        command = [pascal_format_path]

        if self.rev_config_file_path:
            command.extend(["-config=" + self.rev_config_file_path])
        elif self.config_file_path:
            command.extend(["-config=" + self.config_file_path])

        command.extend([self.file_path + ".wrk"])

        print(command)

        try:
            subprocess.check_output(command)
        except subprocess.CalledProcessError as e:

            format_error = True

            # Read output from JCF
            output = e.output

            # Decode Bytes to str
            error_lines = output.decode()

            print(error_lines)

            # if breakpoints should be generated:
            if self.generate_breakpoints_var:

                # extract error messages from output: [Error] Message
                error_lines_processed = extract_error_messages(error_lines)

                for line in error_lines_processed:
                    error_info = extract_error_info(line)
                    filename = error_info.get('file_name')
                    project_file = find_single_prjscr_file(filename)

                    # Replace forward slashes with backslashes
                    file_name_sanitized = filename.replace('/', '\\')

                    # Check if the file name has .wrk as extension and remove it
                    if file_name_sanitized.endswith('.wrk'):
                        file_name_sanitized = file_name_sanitized[:-4]

                    error_info['file_name'] = file_name_sanitized

                    update_prjscr_file(project_file, error_info, -5)

        # only proceed if formatting was successful
        if not format_error:

            # Detect formatted file encoding
            formatted_encoding = self.detect_encoding(self.file_path + ".wrk")

            # After command completion, remove the added lines
            with open(self.file_path + ".wrk", 'r', encoding=formatted_encoding) as processed_file:
                lines = processed_file.readlines()

                # Process declaration formatting
                if self.comma_handler_var.get() and not self.delimiter_handler_var.get():
                    for i, line in enumerate(lines):
                        lines[i] = self.convert_declaration_format(line, True)

                lines_to_write = [line for line in lines if
                                  line.strip() not in ("unit Test;", "interface", "implementation", "end.")]

            # restore likes on the content if necessary
            if self.like_handler_var.get():
                lines_to_write = like_processing_content_restore(lines_to_write)

            # Remove newlines from the beginning
            while lines_to_write and lines_to_write[0] == "\n":
                lines_to_write.pop(0)

            # Remove newlines from the end
            while lines_to_write and lines_to_write[-1] == "\n":
                lines_to_write.pop()

            # Save the modified content back to the original .pas file without the added lines
            with open(self.file_path, 'w', encoding=source_encoding) as original_file:
                original_file.writelines(lines_to_write)

        # Delete the work file
        if not self.keep_work_var:
            os.remove(self.file_path + ".wrk")


if __name__ == "__main__":
    root = tk.Tk()
    app = FileProcessorGUI(root)
    root.mainloop()