Merge branch 'testing'

Author: chrisdpurcell

src/main.py

@@ -11,6 +11,7 @@
 
 from src.services.file_service import FileService
 from src.services.text_processing_service import TextProcessingService
+from src.utils.constants import APP_NAME, APP_VERSION
 from src.viewmodels.main_viewmodel import MainViewModel
 from src.views.main_window import MainWindow
 
@@ -35,8 +36,9 @@ def main() -> None:
     """Application entry point."""
     logger.info("Starting TextTools")
     app = QApplication(sys.argv)
-    app.setApplicationName("TextTools")
-    app.setOrganizationName("TextTools")
+    app.setApplicationName(APP_NAME)
+    app.setApplicationVersion(APP_VERSION)
+    app.setOrganizationName(APP_NAME)
 
     window = create_application()
     window.show()

src/utils/constants.py

@@ -1,9 +1,16 @@
-"""Utility functions and constants for the application."""
+"""Utility constants for TextTools."""
 
-# Application constants
 APP_NAME = "TextTools"
-APP_VERSION = "1.0.0"
+APP_VERSION = "0.2.0"
 
-# Configuration
-DEFAULT_WINDOW_WIDTH = 800
-DEFAULT_WINDOW_HEIGHT = 600
+DEFAULT_WINDOW_WIDTH = 894
+DEFAULT_WINDOW_HEIGHT = 830
+
+# File extensions shown in the QFileSystemModel tree.
+# Covers common text, config, markup, and script formats.
+TEXT_FILE_EXTENSIONS = [
+    "*.txt", "*.md", "*.rst", "*.csv", "*.log",
+    "*.json", "*.yaml", "*.yml", "*.toml", "*.xml", "*.html", "*.htm",
+    "*.css", "*.js", "*.ts", "*.py", "*.sh", "*.bash",
+    "*.conf", "*.cfg", "*.ini", "*.env",
+]

src/viewmodels/main_viewmodel.py

@@ -37,21 +37,21 @@ class MainViewModel(QObject):
 
     Signals:
         document_loaded: Emitted with decoded file content ready for the editor.
+            Only load_file emits this — clears the modified flag in the View.
+        content_updated: Emitted by apply_cleaning and replace_all.
+            In-memory transformations only — the View must NOT clear the modified flag.
         encoding_detected: Emitted with encoding name on file open.
         file_saved: Emitted with filepath after a successful save.
         error_occurred: Emitted with error message on any failure.
         status_changed: Emitted with status bar text.
-        find_requested: Emitted with search term; view performs the find.
-        replace_requested: Emitted with (find, replace); view performs the replace.
     """
 
     document_loaded = Signal(str)
+    content_updated = Signal(str)  # emitted by apply_cleaning and replace_all
     encoding_detected = Signal(str)
     file_saved = Signal(str)
     error_occurred = Signal(str)
     status_changed = Signal(str)
-    find_requested = Signal(str)
-    replace_requested = Signal(str, str)
 
     def __init__(
         self,
@@ -99,36 +99,59 @@ def save_file(self, filepath: str, content: str) -> None:
             self.error_occurred.emit(msg)
             self.status_changed.emit("Error saving file")
 
-    @Slot(object)
-    def apply_cleaning(self, options: CleaningOptions) -> None:
-        """Apply text cleaning to current document content.
+    def apply_cleaning(
+        self, options: CleaningOptions, current_text: str | None = None
+    ) -> None:
+        """Apply text cleaning to the given text or current document content.
+
+        Args:
+            options: Cleaning flags to apply.
+            current_text: Live editor text from the View. When provided, takes
+                precedence over _current_document.content so user edits typed
+                after file-load are not discarded. When None, falls back to the
+                last-loaded document content (backward-compatible default).
 
         No-op when no document is loaded.
         """
         if self._current_document is None:
             self.status_changed.emit("No document loaded")
             return
-        cleaned = self._text_service.apply_options(
-            self._current_document.content, options
+        # Prefer live editor text over stale document state — avoids overwriting
+        # user edits when a cleaning checkbox is toggled after in-editor typing.
+        content = (
+            current_text if current_text is not None else self._current_document.content
         )
+        cleaned = self._text_service.apply_options(content, options)
         self._current_document = TextDocument(
             filepath=self._current_document.filepath,
             content=cleaned,
             encoding=self._current_document.encoding,
             modified=True,
         )
-        self.document_loaded.emit(cleaned)
+        self.content_updated.emit(cleaned)
         self.status_changed.emit("Text cleaned")
 
-    @Slot(str, str)
-    def replace_all(self, find_term: str, replace_term: str) -> None:
-        """Replace all occurrences of find_term in current document content.
+    def replace_all(
+        self, find_term: str, replace_term: str, current_text: str | None = None
+    ) -> None:
+        """Replace all occurrences of find_term in the given text or current document.
+
+        Args:
+            find_term: String to search for.
+            replace_term: String to substitute.
+            current_text: Live editor text from the View. When provided, takes
+                precedence over _current_document.content so user edits typed
+                after file-load are not discarded. When None, falls back to the
+                last-loaded document content (backward-compatible default).
 
         No-op when no document is loaded or find_term is empty.
         """
         if self._current_document is None or not find_term:
             return
-        content = self._current_document.content
+        # Prefer live editor text over stale document state — mirrors apply_cleaning.
+        content = (
+            current_text if current_text is not None else self._current_document.content
+        )
         count = content.count(find_term)
         new_content = content.replace(find_term, replace_term)
         self._current_document = TextDocument(
@@ -137,16 +160,6 @@ def replace_all(self, find_term: str, replace_term: str) -> None:
             encoding=self._current_document.encoding,
             modified=True,
         )
-        self.document_loaded.emit(new_content)
+        self.content_updated.emit(new_content)
         noun = "occurrence" if count == 1 else "occurrences"
         self.status_changed.emit(f"Replaced {count} {noun}")
-
-    @Slot(str)
-    def request_find(self, term: str) -> None:
-        """Signal the view to find the next occurrence of term."""
-        self.find_requested.emit(term)
-
-    @Slot(str, str)
-    def request_replace(self, find_term: str, replace_term: str) -> None:
-        """Signal the view to replace the current selection."""
-        self.replace_requested.emit(find_term, replace_term)

src/views/main_window.py

@@ -17,9 +17,12 @@
 from typing import TypeVar, cast
 
 from PySide6.QtCore import QDir, QFile, QModelIndex
+from PySide6.QtGui import QAction
 from PySide6.QtUiTools import QUiLoader
 from PySide6.QtWidgets import (
+    QApplication,
     QCheckBox,
+    QFileDialog,
     QFileSystemModel,
     QLabel,
     QLineEdit,
@@ -31,6 +34,7 @@
 )
 
 from src.models.cleaning_options import CleaningOptions
+from src.utils.constants import APP_VERSION, TEXT_FILE_EXTENSIONS
 from src.viewmodels.main_viewmodel import MainViewModel
 
 _W = TypeVar("_W")
@@ -66,6 +70,8 @@ class MainWindow:
 
     def __init__(self, viewmodel: MainViewModel) -> None:
         self._viewmodel = viewmodel
+        # Display-only filepath — ViewModel owns document state; this is for the title bar.
+        self._filepath: str = ""
         self._load_ui()
         self._setup_file_tree()
         self._connect_signals()
@@ -137,11 +143,31 @@ def _load_ui(self) -> None:
             self.ui.findChild(QPushButton, "convertEncodingButton"),
             "convertEncodingButton",
         )
+        self._action_quit = _require(
+            self.ui.findChild(QAction, "actionQuit"), "actionQuit"
+        )
+        self._action_save = _require(
+            self.ui.findChild(QAction, "actionSave"), "actionSave"
+        )
+        self._action_open = _require(
+            self.ui.findChild(QAction, "actionOpen"), "actionOpen"
+        )
+        self._action_save_as = _require(
+            self.ui.findChild(QAction, "actionSave_as"), "actionSave_as"
+        )
+        self._action_about = _require(
+            self.ui.findChild(QAction, "actionAbout"), "actionAbout"
+        )
+        self._action_preferences = _require(
+            self.ui.findChild(QAction, "actionPreferences"), "actionPreferences"
+        )
 
     def _setup_file_tree(self) -> None:
         """Configure QFileSystemModel rooted at the user's home directory."""
         self._fs_model = QFileSystemModel(self.ui)
         self._fs_model.setRootPath(QDir.homePath())
+        self._fs_model.setNameFilters(TEXT_FILE_EXTENSIONS)
+        self._fs_model.setNameFilterDisables(False)  # hide non-matches (not just grey them)
         self._file_tree_view.setModel(self._fs_model)
         self._file_tree_view.setRootIndex(self._fs_model.index(QDir.homePath()))
         # Hide size/type/date columns — name column only
@@ -172,13 +198,32 @@ def _connect_signals(self) -> None:
             lambda: self.ui.statusBar().showMessage("Encoding conversion — coming soon")
         )
 
+        # Menu actions
+        self._action_quit.triggered.connect(QApplication.quit)
+        self._action_save.triggered.connect(self._on_save_clicked)
+        self._action_open.triggered.connect(self._on_action_open)
+        self._action_save_as.triggered.connect(
+            lambda: self.ui.statusBar().showMessage("Save As — coming soon")
+        )
+        self._action_about.triggered.connect(self._on_action_about)
+        self._action_preferences.triggered.connect(
+            lambda: self.ui.statusBar().showMessage("Preferences — coming soon")
+        )
+
         # ViewModel → View
         self._viewmodel.document_loaded.connect(self._on_document_loaded)
+        self._viewmodel.content_updated.connect(self._on_content_updated)
         self._viewmodel.encoding_detected.connect(self._on_encoding_detected)
         self._viewmodel.file_saved.connect(self._on_file_saved)
         self._viewmodel.error_occurred.connect(self._on_error)
         self._viewmodel.status_changed.connect(self._on_status_changed)
 
+        # Title bar: modificationChanged fires only when isModified() flips, not on
+        # every keystroke — avoids redundant title repaints and gives a clean signal.
+        self._plain_text_edit.document().modificationChanged.connect(
+            lambda _: self._update_title()
+        )
+
     # ---------------------------------------------------------- user actions
 
     def _on_tree_item_clicked(self, index: QModelIndex) -> None:
@@ -201,13 +246,16 @@ def _on_save_clicked(self) -> None:
         self._viewmodel.save_file(filepath, self._plain_text_edit.toPlainText())
 
     def _on_clean_requested(self) -> None:
-        """Build CleaningOptions from checkbox states; delegate to ViewModel."""
+        """Build CleaningOptions from checkbox states; delegate to ViewModel.
+
+        Passes live editor text so user edits made since file-load are not lost.
+        """
         options = CleaningOptions(
             trim_whitespace=self._trim_cb.isChecked(),
             clean_whitespace=self._clean_cb.isChecked(),
             remove_tabs=self._remove_tabs_cb.isChecked(),
         )
-        self._viewmodel.apply_cleaning(options)
+        self._viewmodel.apply_cleaning(options, self._plain_text_edit.toPlainText())
 
     def _on_find_clicked(self) -> None:
         """Find next occurrence of the search term in the editor."""
@@ -234,19 +282,85 @@ def _on_replace_clicked(self) -> None:
         self._on_find_clicked()
 
     def _on_replace_all_clicked(self) -> None:
-        """Delegate replace-all to ViewModel (operates on stored content)."""
-        self._viewmodel.replace_all(self._find_edit.text(), self._replace_edit.text())
+        """Delegate replace-all to ViewModel, passing live editor text.
+
+        Passes live editor text so user edits made since file-load are not lost.
+        """
+        self._viewmodel.replace_all(
+            self._find_edit.text(),
+            self._replace_edit.text(),
+            self._plain_text_edit.toPlainText(),
+        )
+
+    def _on_action_open(self) -> None:
+        """Open a file dialog and load the selected file."""
+        _glob = " ".join(TEXT_FILE_EXTENSIONS)
+        path, _ = QFileDialog.getOpenFileName(
+            self.ui,
+            "Open File",
+            QDir.homePath(),
+            f"Text Files ({_glob});;All Files (*)",
+        )
+        if path:
+            self._file_name_edit.setText(path)
+            self._viewmodel.load_file(path)
+
+    def _on_action_about(self) -> None:
+        """Show an About dialog."""
+        QMessageBox.about(
+            self.ui,
+            "About TextTools",
+            f"TextTools v{APP_VERSION}\n\nText processing utility: encoding detection, "
+            "whitespace cleaning, find/replace, and file management.\n\n"
+            "Built with Python 3.14 and PySide6.",
+        )
+
+    # ---------------------------------------------------------- title-bar helpers
+
+    def _set_editor_text(self, content: str) -> None:
+        """Replace editor content as a single undoable operation.
+
+        Uses QTextCursor.insertText instead of setPlainText to preserve the undo
+        stack — setPlainText resets it entirely.
+        """
+        cursor = self._plain_text_edit.textCursor()
+        cursor.select(cursor.SelectionType.Document)
+        cursor.insertText(content)
+
+    def _update_title(self) -> None:
+        """Reflect current filepath and modified state in the window title."""
+        name = os.path.basename(self._filepath) if self._filepath else ""
+        modified = self._plain_text_edit.document().isModified()
+        suffix = " *" if modified else ""
+        self.ui.setWindowTitle(f"TextTools — {name}{suffix}" if name else "TextTools")
 
     # ------------------------------------------ ViewModel signal handlers
 
     def _on_document_loaded(self, content: str) -> None:
-        self._plain_text_edit.setPlainText(content)
+        self._set_editor_text(content)
+        self._plain_text_edit.document().setModified(False)
+        # fileNameEdit is always populated before load_file is called (see
+        # _on_tree_item_clicked and _on_action_open). Reading the widget here
+        # keeps the View in its own layer — never access ViewModel private state.
+        self._filepath = self._file_name_edit.text()
+        self._update_title()
+
+    def _on_content_updated(self, content: str) -> None:
+        """Handle in-place text transformation (cleaning, replace-all).
+
+        Does NOT clear the modified flag or update _filepath — content was
+        transformed, not loaded fresh from disk.
+        """
+        self._set_editor_text(content)
 
     def _on_encoding_detected(self, encoding: str) -> None:
         self._encoding_label.setText(encoding)
 
     def _on_file_saved(self, filepath: str) -> None:
+        self._filepath = filepath
+        self._plain_text_edit.document().setModified(False)
         self.ui.statusBar().showMessage(f"Saved: {filepath}")
+        self._update_title()
 
     def _on_error(self, message: str) -> None:
         QMessageBox.critical(self.ui, "Error", message, QMessageBox.StandardButton.Ok)