cutf 0.0.8__py3-none-any.whl

cutf/app.py

@@ -0,0 +1,201 @@
+import argparse
+import os
+from shutil import which
+
+import rich
+
+from cutf.controller.fileController import handle_file
+from cutf.controller.resultHandler import print_results
+from cutf.model.AppSetting import AppSetting
+from cutf.util.log import format_log_error, format_log_path
+
+
+def check_path_file(path: str) -> None:
+    """Validate that the provided path exists and is a file.
+
+    Args:
+        path: Candidate file path.
+
+    Raises:
+        FileNotFoundError: If the path does not exist as a file.
+    """
+    if not os.path.isfile(path):
+        raise FileNotFoundError(f"File not found: {path}")
+
+
+def check_path_dir(path: str) -> None:
+    """Validate that the provided path exists and is a directory.
+
+    Args:
+        path: Candidate directory path.
+
+    Raises:
+        NotADirectoryError: If the path does not exist as a directory.
+    """
+    if not os.path.isdir(path):
+        raise NotADirectoryError(f"Directory not found: {path}")
+
+
+def is_command_available(command: str) -> bool:
+    """Check whether an executable is available on PATH.
+
+    Args:
+        command: Executable name.
+
+    Returns:
+        bool: ``True`` if the command can be resolved via ``PATH``.
+    """
+    return which(command) is not None
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build and return the CLI argument parser.
+
+    Returns:
+        argparse.ArgumentParser: Configured parser for CUFT command-line options.
+    """
+    # Get CLI params
+    parser = argparse.ArgumentParser(
+        description="Convert source files from legacy encodings to UTF-8 with BOM."
+    )
+    parser.add_argument("--path", type=str, required=True, help="Path of the file/directory to scan/convert.")
+    parser.add_argument("--checks", action="store_true", help="Enable checks for the file")
+    parser.add_argument("--convert", action="store_true", help="Enable conversion from current encoding to UTF-8")
+    parser.add_argument("--copyOld", action="store_true", help="Copy old encoded file before converting")
+    parser.add_argument(
+        "--printMissingCharString",
+        action="store_true",
+        help="Print the string where the missing char has been found",
+    )
+    parser.add_argument(
+        "--printAllSkippedFile",
+        action="store_true",
+        help="Print all skipped files where no action was required",
+    )
+    parser.add_argument("--all", action="store_true", help="Enable both conversion and checks")
+    parser.add_argument("--verbose", action="store_true", help="Enable extended logging")
+    parser.add_argument(
+        "--only-relevant",
+        action="store_true",
+        help="Print only relevant results (hides less relevant missing-char entries)",
+    )
+    parser.add_argument(
+        "--extensions",
+        # Nome dell'argomento
+        type=str,
+        # Tipo stringa
+        nargs="+",
+        # Permette di passare piu estensioni separando con uno spazio
+        help="List of extensions to scan, for example: .cpp .h .cs .ini",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None, confirm_fn=input) -> int:
+    """Run the command-line application.
+
+    Args:
+        argv: Optional CLI argument list. When ``None``, arguments are read from ``sys.argv``.
+        confirm_fn: Function used to prompt the user before processing files.
+
+    Returns:
+        int: Process exit code (``0`` on success).
+
+    Raises:
+        SystemExit: If user input is invalid or required system dependencies are missing.
+    """
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    # Check CLI params
+    if not (args.checks or args.convert or args.all):
+        rich.print(format_log_error("At least one of --checks or --convert must be set."))
+        raise SystemExit(1)
+    if not args.extensions:
+        rich.print(format_log_error("At least one file extension must be provided with --extensions."))
+        raise SystemExit(1)
+
+    # Get and Print CLI params
+    path = args.path
+    enable_checks = bool(args.checks or args.all)
+    enable_convert = bool(args.convert or args.all)
+
+    rich.print(f"Path to scan: {format_log_path(path)}")
+    rich.print(f"Checks enabled: {enable_checks}")
+    rich.print(f"Conversion enabled: {enable_convert}")
+    rich.print(f"Extensions to scan: {args.extensions}")
+    rich.print(f"Copy old encoded: {args.copyOld}")
+    rich.print("\n")
+
+    # Check path is valid and if it's a dir/file
+    is_file = os.path.isfile(path)
+    if is_file:
+        check_path_file(path)
+    else:
+        check_path_dir(path)
+
+    # Check iconv in path
+    if not is_command_available("iconv"):
+        rich.print(format_log_error("Iconv executable not found on your system PATH."))
+        raise SystemExit(1)
+
+    # Ask user confirmation
+    if is_file:
+        rich.print(
+            f"File \"{format_log_path(path)}\" will be checked and converted to UTF-8 "
+            "(with BOM). Proceed? (Enter to continue or CTRL-C to exit)"
+        )
+    else:
+        rich.print(
+            f"All files inside \"{format_log_path(path)}\" will be checked and converted "
+            "to UTF-8 (with BOM). Proceed? (Enter to continue or CTRL-C to exit)"
+        )
+    confirm_fn()
+
+    # Create setting object
+    setting = AppSetting(
+        input_path=path,
+        is_file=is_file,
+        extensions=args.extensions,
+        checks=enable_checks,
+        convert=enable_convert,
+        copy_old_encoded=args.copyOld,
+        print_missing_char_str=args.printMissingCharString,
+        verbose=args.verbose,
+        print_skipped_file_no_action=args.printAllSkippedFile,
+        print_result_only_relevant=args.only_relevant,
+    )
+
+    # Handle file/dir and get results
+    count_from_files = 0
+    results = []
+    rich.print(f"Scanning \"{format_log_path(path)}\"...")
+    if is_file:
+        count_from_files += 1
+        results.append(handle_file(setting.input_path, setting))
+    else:
+        for root, _, files in os.walk(path):
+            for file_name in files:
+                count_from_files += 1
+                full_file_path = os.path.join(root, file_name)
+                results.append(handle_file(full_file_path, setting))
+
+    rich.print("-------------------------------")
+
+    # Handle results
+    print_results(results, setting)
+
+    # Print count result
+    if setting.is_file:
+        rich.print(f"\nThis software scanned file {format_log_path(path)}.\n")
+    else:
+        rich.print(
+            f"\nThis software scanned {len(results)}/{count_from_files} files inside "
+            f"{format_log_path(path)}.\n"
+        )
+
+    return 0
+
+
+if __name__ == "__main__":
+    main()

cutf/controller/fileChecker.py

@@ -0,0 +1,86 @@
+import os
+
+import rich
+
+from cutf.model.MissingCharResult import MissingCharResult
+from cutf.util.code import is_line_commented
+
+
+def check_illegal_chars(file_path: str, source_encoding: str) -> list[MissingCharResult]:
+    """Find replacement-character byte sequences in a text file.
+
+    This function searches for the UTF-8 byte sequence ``EF BF BD`` (U+FFFD,
+    replacement character) and reports each match with line metadata.
+
+    Args:
+        file_path: Absolute or relative path of the file to inspect.
+        source_encoding: Encoding used to decode the file content for line extraction.
+
+    Returns:
+        list[MissingCharResult]: One item for each detected replacement character.
+
+    Raises:
+        RuntimeError: If the file cannot be decoded using ``source_encoding``.
+    """
+    results = []
+    with open(file_path, "rb") as f:
+        raw_data = f.read()
+
+    # Verifica e gestisci il BOM per UTF-8
+    bom = b"\xef\xbb\xbf"
+    if raw_data.startswith(bom):
+        raw_data = raw_data[len(bom) :]
+
+    # Decodifica i byte usando l'encoding specificato (per esempio UTF-8)
+    try:
+        text_data = raw_data.decode(source_encoding, errors="replace")
+    except UnicodeDecodeError:
+        rich.print(
+            f"\t[bold red]Error decoding file {os.path.basename(file_path)} "
+            f"with encoding {source_encoding}.[/bold red]"
+        )
+        raise RuntimeError(f"Error decoding file {os.path.basename(file_path)} during check_illegal_chars().")
+
+    # Itera sui caratteri per trovare il carattere illegale
+    for idx in range(len(raw_data) - 2):  # -2 per evitare di uscire fuori dal range durante il confronto
+        if raw_data[idx] == 0xEF and raw_data[idx + 1] == 0xBF and raw_data[idx + 2] == 0xBD:
+            line_start = text_data.rfind("\n", 0, idx)
+            line_end = text_data.find("\n", idx)
+
+            # Ottieni la riga completa dove e presente l'errore
+            if line_end == -1:
+                line_end = len(text_data)
+
+            line = text_data[line_start + 1:line_end]
+            # Trova la posizione relativa all'interno della riga
+            char_pos_in_line = line.find("�")
+
+            line_number = text_data.count("\n", 0, idx) + 1
+
+            # Stampa il risultato formattato
+            rich.print(
+                f"\t[bold yellow]Found illegal character at position {idx}, "
+                f"line {line_number} in file {os.path.basename(file_path)}[/bold yellow]"
+            )
+            # Creiamo una versione evidenziata della riga
+            # highlighted_line = (
+            #     line[:char_pos_in_line]
+            #     + f"[bold red]{line[char_pos_in_line]}[/bold red]"
+            #     + line[char_pos_in_line + 1:]
+            # )
+            # rich.print("\t" + highlighted_line)
+
+            # Aggiungi il risultato all'array, utilizzando MissingCharResult
+            result = MissingCharResult(
+                is_commented=is_line_commented(file_path, line_number),
+                string=line.lstrip(" \t"),
+                line=line_number,
+                file_name=os.path.basename(file_path),
+                char_position=char_pos_in_line,
+                char_found=char_pos_in_line != -1,
+                byte_sequence_file_pos=idx,
+            )
+
+            results.append(result)
+
+    return results

cutf/controller/fileController.py

@@ -0,0 +1,119 @@
+import os
+
+import chardet
+import rich
+
+from cutf.controller.fileChecker import check_illegal_chars
+from cutf.model.AppSetting import AppSetting
+from cutf.model.FileScanResult import FileScanResult
+from cutf.util.iconv import convert_to_utf8_with_iconv
+from cutf.util.log import format_log_path
+from cutf.util.path import copy_old_encoded_file
+
+
+def handle_file(file_path: str, setting: AppSetting) -> FileScanResult:
+    """Scan and optionally convert a single file according to current settings.
+
+    Args:
+        file_path: Full path of the file to process.
+        setting: Runtime application options that control checks/conversion behavior.
+
+    Returns:
+        FileScanResult: Structured outcome including conversion, checks, and errors.
+    """
+    # Starting
+    file_name = os.path.basename(file_path)
+    encoding = None
+
+    try:
+        # Checking extension
+        _, extension = os.path.splitext(file_path)
+        normalized_extensions = {value.lower() for value in setting.extensions}
+        has_supported_extension = extension.lower() in normalized_extensions
+        if not has_supported_extension:
+            if setting.verbose:
+                rich.print(f"File {file_name} has no supported extension ({extension}). Skipping...")
+            return FileScanResult(
+                file_path=file_path,
+                file_name=file_name,
+                skipped=True,
+            )
+        # Load encoding
+        if setting.verbose:
+            rich.print(f"## Checking file \"{format_log_path(file_path)}\"...")
+
+        if setting.verbose:
+            rich.print(f"Opening file \"{file_path}\"...")
+        with open(file_path, "rb") as f:
+            raw_data = f.read()
+            result = chardet.detect(raw_data)
+            encoding = result["encoding"]
+
+        # Check encoding
+        if encoding is None:
+            raise RuntimeError(f"Cannot detect encoding of {file_name}")
+        is_already_utf8 = (
+            encoding.lower() in {"utf-8", "utf-8-sig", "utf-16", "utf-16le", "utf-16be"}
+        )
+
+        # Check if need to be converted
+        needs_convert = (not is_already_utf8) and setting.convert
+
+        # Copy old encoded (if enabled and needed)
+        if needs_convert and setting.copy_old_encoded:
+            old_copy_path = copy_old_encoded_file(file_path)
+            rich.print(f"Copied old encoded file to {format_log_path(old_copy_path)}")
+
+        # Exec operations
+        if needs_convert:
+            rich.print(f"File \"{file_name}\" has encoding {encoding}. Proceeding to convert and check...")
+            output_encoding = "utf-8"
+            convert_to_utf8_with_iconv(file_path, encoding, output_encoding)
+            missing_chars = check_illegal_chars(file_path, output_encoding)
+            if setting.verbose:
+                rich.print(f"Finished checking and converting file \"{file_name}\"!")
+            return FileScanResult(
+                file_path=file_path,
+                file_name=file_name,
+                encoding_before=encoding,
+                encoding_after=f"{output_encoding}(BOM)",
+                check_missing_char=missing_chars,
+                converted=True,
+            )
+        elif setting.checks:
+            rich.print(f"File \"{file_name}\" has encoding {encoding}. Proceeding to check...")
+            missing_chars = check_illegal_chars(file_path, encoding)
+            if setting.verbose:
+                rich.print(f"Finished checking file \"{file_name}\"!")
+            return FileScanResult(
+                file_path=file_path,
+                file_name=file_name,
+                encoding_before=encoding,
+                check_missing_char=missing_chars,
+            )
+        else:
+            rich.print(f"No operation to do on {file_name}")
+            return FileScanResult(
+                file_path=file_path,
+                file_name=file_name,
+                skipped=True,
+            )
+
+    except RuntimeError as e:
+        rich.print(f"[bold red]Conversion/checking of {file_name} interrupted because of an error: {e}[/bold red]")
+        return FileScanResult(
+            file_path=file_path,
+            file_name=file_name,
+            encoding_before=encoding,
+            error_skipped=True,
+            error_description=str(e),
+        )
+    # except FileNotFoundError as e:
+    #     rich.print(f"[bold red]Conversion/checking of {file_name} interrupted because of an error: {e}[/bold red]")
+    #     return FileScanResult(
+    #         file_path=file_path,
+    #         file_name=file_name,
+    #         encoding_before=encoding,
+    #         error_skipped=True,
+    #         error_description=str(e),
+    #     )

cutf/controller/resultHandler.py

@@ -0,0 +1,174 @@
+from collections import Counter
+
+import rich
+
+from cutf.model import AppSetting
+from cutf.model.FileScanResult import FileScanResult
+from cutf.util.log import format_log_error
+
+
+def __print_encoding_before(results: list[FileScanResult]):
+    """Print a count of detected original encodings.
+
+    Args:
+        results: Collection of per-file scan outcomes.
+    """
+    encoding_counter = Counter()
+
+    # Scorri ogni FileScanResult
+    for result in results:
+        # Aggiungi l'encoding_before se non e None
+        if result.encoding_before:
+            encoding_counter[result.encoding_before] += 1
+
+    # Stampa ogni encoding e il numero di occorrenze
+    rich.print(f"@ List of encodings found during scanning ({len(encoding_counter.items())}):")
+    for encoding, count in encoding_counter.items():
+        rich.print(f"{encoding}: {count}")
+
+
+def __print_converted_files(results: list[FileScanResult]):
+    """Print all files that were converted during processing.
+
+    Args:
+        results: Collection of per-file scan outcomes.
+    """
+    count = 0
+    rich.print("@ List of converted files:")
+    for result in results:
+        if result.converted:
+            count += 1
+            rich.print(f"Converted file {result.file_name} from encoding {result.encoding_before} to encoding {result.encoding_after}.")
+    if count == 0:
+        rich.print("0 Files converted.")
+
+
+def __print_skipped_files(results: list[FileScanResult], print_all: bool):
+    """Print files skipped because no action was required.
+
+    Args:
+        results: Collection of per-file scan outcomes.
+        print_all: If ``True``, prints one row per skipped file.
+    """
+    count = 0
+    rich.print("@ List of skipped files:")
+    if print_all:
+        for result in results:
+            if result.skipped:
+                count += 1
+                rich.print(f"File {result.file_name} skipped because no action is required.")
+        if count == 0:
+            rich.print("0 skipped file founds.")
+    else:
+        for result in results:
+            if result.skipped:
+                count += 1
+        if count == 0:
+            rich.print("0 skipped file founds.")
+        else:
+            rich.print(f"{count} file skipped because no action was required.")
+
+
+def __print_skipped_error_files(results: list[FileScanResult]):
+    """Print files skipped because of processing errors.
+
+    Args:
+        results: Collection of per-file scan outcomes.
+    """
+    count = 0
+    rich.print("@ List of skipped files (from errors):")
+    for result in results:
+        if result.error_skipped:
+            count += 1
+            rich.print(format_log_error(f"File {result.file_path} skipped because of an error: {result.error_description}"))
+    if count == 0:
+        rich.print("0 errors founds.")
+
+
+def __print_missing_chars_on_comments(results: list[FileScanResult], print_mis_char_string: bool):
+    """Print missing character occurrences detected in comments.
+
+    Args:
+        results: Collection of per-file scan outcomes.
+        print_mis_char_string: If ``True``, include the original line string.
+    """
+    rich.print("@ List of missing chars found on comments:")
+    for result in results:
+        if result.check_missing_char is not None:
+            for file in result.check_missing_char:
+                if file.is_commented:
+                    rich.print(f"File = {file.file_name} | Missing char Visibile = {file.char_found} | Line = {file.line} | Line Pos = {file.char_position} | File pos = {file.byte_sequence_file_pos}")
+                    if print_mis_char_string:
+                        rich.print(f"String = {file.string}")
+                        rich.print("-------------------")
+
+
+def __print_missing_chars_on_code(results: list[FileScanResult], print_mis_char_string: bool, only_relevant: bool):
+    """Print missing character occurrences detected in code lines.
+
+    Args:
+        results: Collection of per-file scan outcomes.
+        print_mis_char_string: If ``True``, include the original line string.
+        only_relevant: If ``True``, hide missing-char entries where the symbol is not visible.
+    """
+    rich.print("@ List of missing chars found on code:")
+    count = 0
+    for result in results:
+        if result.check_missing_char is not None:
+            for file in result.check_missing_char:
+                if not file.is_commented:
+                    count += 1
+                    if file.char_found:
+                        rich.print(f"File = {file.file_name} | Missing char Visibile = {file.char_found} | Line = {file.line} | Line Pos = {file.char_position} | File pos = {file.byte_sequence_file_pos}")
+                    else:
+                        if not only_relevant:
+                            rich.print(f"File = {file.file_name} | Missing char Visibile = {file.char_found} | Line = {file.line} | Line Pos = {file.char_position} | File pos = {file.byte_sequence_file_pos}")
+                    if print_mis_char_string:
+                        rich.print(f"String = {file.string}")
+                        rich.print("-------------------")
+    if count == 0:
+        rich.print("0 missing chars on code founds.")
+
+
+def print_results(results: list[FileScanResult], setting: AppSetting):
+    """Print the complete scan summary to the console.
+
+    Args:
+        results: Collection of per-file scan outcomes.
+        setting: Runtime settings controlling verbosity and filtering.
+    """
+
+    rich.print("\n\n")
+
+    rich.print("########################################################") if setting.verbose else None
+    rich.print("### START OF RESULTS ###################################")
+    rich.print("########################################################") if setting.verbose else None
+
+    # Print list of encoding before all
+    __print_encoding_before(results)
+    rich.print("\n")
+
+    # Print file converted
+    __print_converted_files(results)
+    rich.print("\n")
+
+    # File skipped
+    __print_skipped_files(results, setting.print_skipped_file_no_action)
+    rich.print("\n")
+
+    # File skipped (Error)
+    __print_skipped_error_files(results)
+    rich.print("\n")
+
+    # Missing chars (comments)
+    if not setting.print_result_only_relevant:
+        __print_missing_chars_on_comments(results, setting.print_missing_char_str)
+        rich.print("\n")
+
+    # Missing chars (code)
+    __print_missing_chars_on_code(results, setting.print_missing_char_str, setting.print_result_only_relevant)
+
+    rich.print("\n\n")
+    rich.print("########################################################") if setting.verbose else None
+    rich.print("### END OF RESULTS #####################################")
+    rich.print("########################################################") if setting.verbose else None

cutf/model/AppSetting.py

@@ -0,0 +1,29 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class AppSetting:
+    """Runtime configuration loaded from CLI flags.
+
+    Attributes:
+        input_path: Path of the input file or directory selected by the user.
+        is_file: ``True`` when ``input_path`` points to a file, ``False`` for directories.
+        extensions: Allowed file extensions to include in the scan.
+        checks: Enables illegal-character checks.
+        convert: Enables conversion to UTF-8 with BOM when needed.
+        copy_old_encoded: Saves a copy of legacy-encoded files before conversion.
+        print_missing_char_str: Prints the line text where missing characters are detected.
+        print_skipped_file_no_action: Prints all skipped files instead of just a count.
+        print_result_only_relevant: Hides less relevant missing-char entries.
+        verbose: Enables detailed progress logs.
+    """
+    input_path: str
+    is_file: bool
+    extensions: list[str]
+    checks: bool = False
+    convert: bool = False
+    copy_old_encoded: bool = False
+    print_missing_char_str: bool = False
+    print_skipped_file_no_action: bool = False
+    print_result_only_relevant: bool = False
+    verbose: bool = False

cutf/model/FileScanResult.py

@@ -0,0 +1,31 @@
+from dataclasses import dataclass
+
+from cutf.model.MissingCharResult import MissingCharResult
+
+
+@dataclass
+class FileScanResult:
+    """Result payload produced when processing a single file.
+
+    Attributes:
+        file_path: Absolute or relative file path that was scanned.
+        file_name: File name extracted from ``file_path``.
+        encoding_before: Detected source encoding before any operation.
+        encoding_after: Target encoding after conversion, if conversion happened.
+        converted: ``True`` when conversion was executed successfully.
+        check_missing_char: List of missing-character findings, if checks were run.
+        error_skipped: ``True`` when the file was skipped because of an error.
+        error_name: Optional short error name (reserved for future use).
+        error_description: Human-readable error details.
+        skipped: ``True`` when no operation was needed for the file.
+    """
+    file_path: str
+    file_name: str
+    encoding_before: str | None = None
+    encoding_after: str | None = None
+    converted: bool = False
+    check_missing_char: list[MissingCharResult] | None = None
+    error_skipped: bool = False
+    error_name: str | None = None
+    error_description: str | None = None
+    skipped: bool = False

cutf/model/MissingCharResult.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class MissingCharResult:
+    """Details about one replacement-character occurrence in a file.
+
+    Attributes:
+        is_commented: ``True`` if the line is considered part of a comment.
+        string: Original line content where the issue was found.
+        line: 1-based line number in the file.
+        file_name: Name of the file that contains the issue.
+        char_position: Character index of ``�`` inside the line, or ``-1`` when not visible.
+        char_found: ``True`` when the replacement character is visible in decoded text.
+        byte_sequence_file_pos: Byte index in the raw file where ``EF BF BD`` starts.
+    """
+    is_commented: bool
+    string: str
+    line: int
+    file_name: str
+    char_position: int
+    char_found: bool
+    byte_sequence_file_pos: int

cutf/model/__init__.py

@@ -0,0 +1,8 @@
+"""Data models used by CUFT."""
+
+from cutf.model.AppSetting import AppSetting
+from cutf.model.FileScanResult import FileScanResult
+from cutf.model.MissingCharResult import MissingCharResult
+
+__all__ = ["AppSetting", "FileScanResult", "MissingCharResult"]
+

cutf/util/code.py

@@ -0,0 +1,43 @@
+def is_line_commented(file_path: str, line_number: int) -> bool:
+    """Determine whether a specific line is inside a comment block.
+
+    Supports C-like single-line comments (``//``) and block comments
+    delimited by ``/*`` and ``*/``.
+
+    Args:
+        file_path: Path to the source file.
+        line_number: 1-based target line index.
+
+    Returns:
+        bool: ``True`` if the line is recognized as commented, otherwise ``False``.
+    """
+    in_block_comment = False
+    with open(file_path, "r", encoding="utf-8", errors="replace") as file:
+        for current_line_number, line in enumerate(file, start=1):
+            # Se siamo nella linea di interesse
+            if current_line_number == line_number:
+                # Verifica se la linea e commentata
+                line = line.strip().lstrip("\ufeff")
+                if in_block_comment:
+                    # La riga e dentro un blocco di commento
+                    return True
+                # Commenti su singola riga (//)
+                if line.startswith("//"):
+                    return True
+                # Controllo se la riga e dentro un commento di blocco
+                if "/*" in line:
+                    in_block_comment = True
+                    if "*/" in line:
+                        in_block_comment = False
+                    return False
+                # La riga non e commentata
+                return False
+            # Gestisci l'inizio e la fine di un blocco di commento
+            if in_block_comment:
+                if "*/" in line:
+                    in_block_comment = False
+                continue
+            if "/*" in line:
+                in_block_comment = True
+
+    return False  # Se non troviamo mai la linea, significa che non e commentata

cutf/util/iconv.py

@@ -0,0 +1,51 @@
+import os
+import subprocess
+
+import rich
+
+from cutf.util.log import format_log_path
+
+
+def convert_to_utf8_with_iconv(path: str, source_encoding: str, target_encoding: str):
+    """Convert a file encoding with iconv and write UTF-8 BOM output in place.
+
+    The function invokes the ``iconv`` executable, writes converted content to a
+    temporary file, prepends UTF-8 BOM bytes, and atomically replaces the original file.
+
+    Args:
+        path: File path to convert in place.
+        source_encoding: Input encoding used by iconv (``-f``).
+        target_encoding: Output encoding used by iconv (``-t``), usually ``utf-8``.
+    """
+    file_name = os.path.basename(path)
+    rich.print(f"Converting {file_name} to {target_encoding} with iconv...")
+
+    temp_file_path = path + ".tmp"
+    temp_bom_file_path = path + ".bom"
+
+    try:
+        command = ["iconv", "-f", source_encoding, "-t", target_encoding, path]
+
+        with open(temp_file_path, "w", encoding=target_encoding) as temp_file:
+            subprocess.run(command, stdout=temp_file, stderr=subprocess.PIPE, check=True)
+
+        # Aggiungi il BOM al file convertito
+        with open(temp_bom_file_path, "wb") as bom_file:
+            bom_file.write(b"\xef\xbb\xbf")  # Scrivi il BOM (UTF-8)
+            with open(temp_file_path, "rb") as temp_file:
+                bom_file.write(temp_file.read())  # Aggiungi il contenuto del file convertito
+
+        # Sostituisci il file originale con il file con BOM
+        os.replace(temp_bom_file_path, path)
+        rich.print(f"Conversion completed for {format_log_path(os.path.basename(path))}")
+
+    except subprocess.CalledProcessError as e:
+        rich.print(f"Errore nella conversione di {path}: {e}")
+        if os.path.exists(temp_file_path):
+            os.remove(temp_file_path)
+    finally:
+        # Cancella i file temporanei, se esistono
+        if os.path.exists(temp_file_path):
+            os.remove(temp_file_path)
+        if os.path.exists(temp_bom_file_path):
+            os.remove(temp_bom_file_path)

cutf/util/log.py

@@ -0,0 +1,35 @@
+
+def format_log_path(path: str) -> str:
+    """Format a path string using a rich magenta style token.
+
+    Args:
+        path: Path text to format.
+
+    Returns:
+        str: Rich-markup styled path.
+    """
+    return f"[bold magenta]{path}[/bold magenta]"
+
+
+def format_log_warning(string: str) -> str:
+    """Format a warning message using a rich yellow style token.
+
+    Args:
+        string: Warning text to format.
+
+    Returns:
+        str: Rich-markup styled warning message.
+    """
+    return f"[bold yellow]{string}[/bold yellow]"
+
+
+def format_log_error(string: str) -> str:
+    """Format an error message using a rich red style token.
+
+    Args:
+        string: Error text to format.
+
+    Returns:
+        str: Rich-markup styled error message.
+    """
+    return f"[bold red]{string}[/bold red]"

cutf/util/path.py

@@ -0,0 +1,38 @@
+import os
+import shutil
+import tempfile
+
+
+def copy_old_encoded_file(file_path: str) -> str:
+    """Copy a source file to the system temp backup folder.
+
+    The destination folder is ``<tempdir>/SrcChE`` and is created on demand.
+
+    Args:
+        file_path: Path of the file that should be copied.
+
+    Returns:
+        str: Full path of the copied backup file.
+
+    Raises:
+        FileNotFoundError: If ``file_path`` does not exist.
+    """
+
+    # Controlliamo se il file esiste
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"File {file_path} does not exist.")
+
+    # Otteniamo la cartella temporanea di Windows (solitamente la variabile d'ambiente TEMP)
+    temp_dir = tempfile.gettempdir()
+
+    # Creiamo un percorso per la copia del file nella cartella temporanea
+    temp_file_path = os.path.join(temp_dir, "SrcChE")
+
+    if not os.path.exists(temp_file_path):
+        os.makedirs(temp_file_path)
+
+    # Copiamo il file nella cartella temporanea
+    dest = shutil.copy2(file_path, temp_file_path)
+
+    # Restituire il percorso del file temporaneo
+    return dest

cutf-0.0.8.dist-info/METADATA

@@ -0,0 +1,190 @@
+Metadata-Version: 2.4
+Name: cutf
+Version: 0.0.8
+Summary: CLI tool to scan and convert source files to UTF-8 with BOM.
+Author: Gabliz
+License: MIT License
+        
+        Copyright (c) 2025 GaaabLiz
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: bom,cli,encoding,iconv,utf-8
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Requires-Dist: chardet>=5.2.0
+Requires-Dist: rich>=13.9.4
+Description-Content-Type: text/markdown
+
+# CUFT
+
+CUFT is a CLI tool that scans source files, detects legacy encodings, and converts them to **UTF-8 with BOM**.
+
+It can also report replacement characters (`�`) introduced by decoding issues.
+
+## Features
+
+- Scan one file or an entire directory tree.
+- Filter files by extension.
+- Detect source encoding with `chardet`.
+- Convert files to UTF-8 with BOM through `iconv`.
+- Optional backup copy of original files.
+- Detailed report for converted, skipped, and problematic files.
+
+## Requirements
+
+- Python 3.10+
+- [uv](https://docs.astral.sh/uv/) *(only for local development)*
+- `iconv` available in your system `PATH`
+
+### Install `iconv`
+
+- macOS: usually preinstalled (`iconv --version`)
+- Linux: install from system package manager (for example `libc-bin` / `glibc` tools)
+- Windows: download and install [GNU iconv for Windows (GnuWin32)](https://gnuwin32.sourceforge.net/packages/libiconv.htm) and make sure `iconv.exe` is in `PATH`
+
+## Installation
+
+### Option A – Install from PyPI (recommended)
+
+No need to clone the repository. Just run:
+
+```bash
+pip install cutf
+```
+
+or with `uv`:
+
+```bash
+uv tool install cutf
+```
+
+Then use it directly:
+
+```bash
+cutf --path ./src --all --extensions .py .txt
+```
+
+### Option B – Clone and run locally
+
+#### 1) Clone the repository
+
+```bash
+git clone https://github.com/<your-org>/cutf.git
+cd cutf
+```
+
+#### 2) Create environment and install dependencies with uv
+
+```bash
+uv sync --all-groups
+```
+
+#### 3) Run CUFT
+
+```bash
+uv run cutf --path ./src --all --extensions .py .txt
+```
+
+## Usage
+
+```text
+usage: cutf --path PATH [--checks] [--convert] [--copyOld]
+            [--printMissingCharString] [--printAllSkippedFile]
+            [--all] [--verbose] [--only-relevant]
+            [--extensions EXT [EXT ...]]
+```
+
+### Main options
+
+- `--path`: file or directory to process.
+- `--checks`: run missing-character checks.
+- `--convert`: convert non-UTF files to UTF-8 with BOM.
+- `--all`: enable both `--checks` and `--convert`.
+- `--extensions`: list of extensions to scan (required), for example `.cpp .h .cs .ini`.
+- `--copyOld`: copy original file before conversion into temp folder.
+- `--printMissingCharString`: print the line content for each missing-character finding.
+- `--printAllSkippedFile`: print every skipped file instead of only the count.
+- `--only-relevant`: hide less relevant missing-character entries.
+- `--verbose`: print extra execution logs.
+
+## Typical Commands
+
+Run checks only:
+
+```bash
+uv run cutf --path ./project --checks --extensions .py .js .ts
+```
+
+Run conversion + checks:
+
+```bash
+uv run cutf --path ./project --all --extensions .cpp .h --copyOld
+```
+
+Process one file:
+
+```bash
+uv run cutf --path ./src/main.cpp --all --extensions .cpp
+```
+
+## Development
+
+Run tests:
+
+```bash
+uv run pytest
+```
+
+Run linter:
+
+```bash
+uv run ruff check .
+```
+
+Format code:
+
+```bash
+uv run ruff format .
+```
+
+## FAQ
+
+### Why does CUFT require `--extensions`?
+It prevents accidental processing of unrelated files and keeps scans predictable.
+
+### Why UTF-8 **with BOM**?
+Some tools and Windows-oriented workflows require BOM for UTF-8 detection.
+
+### What happens if `iconv` is missing?
+CUFT stops before processing and prints an error. Install `iconv` and retry.
+
+### Where are original files copied when `--copyOld` is enabled?
+They are copied to `<system-temp>/SrcChE`.
+
+### Does CUFT modify UTF-8 files?
+Only when conversion is requested and the file is detected as non-UTF. Otherwise files are skipped.
+
+## License
+
+This project is distributed under the license in `LICENSE`.
+

cutf-0.0.8.dist-info/RECORD

@@ -0,0 +1,20 @@
+cutf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cutf/app.py,sha256=Yze6qmTMh7ORMHUPPRjgPTeIUV3hQnXQrdECFMy5yfk,6595
+cutf/controller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cutf/controller/fileChecker.py,sha256=3OzoyAVA0P4J7y97EgAMgFxUJZtRTLYCKAUJuviXGO8,3322
+cutf/controller/fileController.py,sha256=84gB-wp8azGfu-kOf7fSDtEQGcUDgpZQA9mZVamHg88,4666
+cutf/controller/resultHandler.py,sha256=UfxQ9iz3SU1C9VGuL9NY6jJESzJCBVOwHP0eRv6wz-M,6770
+cutf/model/AppSetting.py,sha256=Iu-7Sy9mYsoy6-G7n6JtagOw2iP11RM5fBRvWTxlFmo,1193
+cutf/model/FileScanResult.py,sha256=So3R7sOGro03YV9Yw1ABYspX9Fj-uEXTWXLvRodt8Gs,1267
+cutf/model/MissingCharResult.py,sha256=BCdzZRDfPHNaMhIRTrJ29Cv6PyP9hJgUGyCmiUUCJXI,831
+cutf/model/__init__.py,sha256=1_JoZQ01gT5-Xs2l2m_bnxjWdtaRYT8MP8P2cpIka4M,256
+cutf/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cutf/util/code.py,sha256=HtjY6XEn67Rn1mxBXtPY1_zSxaZTAO3xvJdft4NpwYQ,1767
+cutf/util/iconv.py,sha256=jdnum1Nqu-IfQE8NUtJ0V-nViuClbSm01C8lesCFPQY,2030
+cutf/util/log.py,sha256=TNgP8oH1C5WVR8NvP1g9agUSsUc6-r9ZuXwUrCnKej4,807
+cutf/util/path.py,sha256=mnSvhj_oREcqUXZ-5lKRJh1Mw0KH8D7ybeEyMJRwTIk,1095
+cutf-0.0.8.dist-info/METADATA,sha256=VxYDDBWgsyGjfCa3Q6KkwotX-FJIZCph-wdW7UY1NyQ,5303
+cutf-0.0.8.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+cutf-0.0.8.dist-info/entry_points.txt,sha256=S-ygTSgHduL0RwSA24G2aCcvODm0EWIuHkF2hAXH_TA,39
+cutf-0.0.8.dist-info/licenses/LICENSE,sha256=vo-PhwUi9tU24GL_1jckQKXonOeMIXigqe69KiDGuxM,1065
+cutf-0.0.8.dist-info/RECORD,,

cutf-0.0.8.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

cutf-0.0.8.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cutf = cutf.app:main

cutf-0.0.8.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 GaaabLiz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.