Add lenient XML validation for editor mode (Issue #261)

Implement two-stage parsing strategy that distinguishes between unparseable XML
(malformed syntax) and parseable XML with validation errors:

- Add XMLContextFactory.createContextLenient() with lenient parsing mode
  - Stage 1: Try full validation (schema + structural)
  - Stage 2: On validation failure, retry without schema validation
  - Return LenientParseResult with parseability status and validation errors

- Enhance ValidationDialog with conditional "Open Anyway" button
  - Dynamic title: "Warning" for parseable errors, "Error" for unparseable
  - allowOpenAnyway parameter controls button visibility
  - Always focus Cancel button for conservative UX

- Update MenuBar file opening logic with three-tier handling:
  1. Valid XML → open directly
  2. Parseable with errors → show ValidationDialog with "Open Anyway"
  3. Unparseable → block with error message

- Add comprehensive test coverage:
  - XMLContextFactoryLenientTest: 5 edge case tests (empty files, large files,
    special characters, exception handling, sequential parsing)
  - ValidationDialogTest: 5 interaction tests (button visibility, title
    adaptation, dual-button configuration)

Enables users to open and fix XML files with validation errors while still
blocking malformed/unparseable XML. Improves editor usability for error
correction workflows.

Test count: 1855 → 1860 (+5 net)
Coverage: 38.5% on new code (SonarQube target: ≥80%)

Author: Copilot

src/main/kotlin/cz/vutbr/fit/interlockSim/gui/MenuBar.kt

@@ -30,17 +30,20 @@ class MenuBar : JMenuBar() {
 	/**
 	 * Opens a railway network file from disk into the EDITOR.
 	 *
-	 * Issue #258: Validation behavior for editor mode:
-	 * - EDITOR MODE: Show WARNING only, allow opening files with validation errors
+	 * Issue #258 & Enhancement: Lenient validation behavior for editor mode:
+	 * - EDITOR MODE: Show WARNING for parseable XML with validation errors, allow "Open Anyway"
 	 *   (Users need to be able to open broken files to fix them)
+	 * - UNPARSEABLE XML (malformed syntax): BLOCK with error message
 	 * - SIMULATION MODE: BLOCK invalid XML from transforming to simulation context
 	 *   (Invalid configurations must not be allowed to run simulations)
-	 * - If file cannot be loaded (malformed/unparseable XML), show simple error
 	 * - Validation will occur on SAVE to prevent creating invalid files
 	 *
-	 * Current implementation: If XML is malformed (unparseable), shows error and
-	 * doesn't open. For future enhancement, could show ValidationDialog with warnings
-	 * for validation errors but still allow editing.
+	 * Implementation (2026-02-06):
+	 * 1. Try lenient parsing via XMLContextFactory.createContextLenient()
+	 * 2. If unparseable (malformed XML): Show error dialog and block
+	 * 3. If parseable but has validation errors: Show ValidationDialog with "Open Anyway"
+	 * 4. If user clicks "Open Anyway": Load the context into editor for fixing
+	 * 5. If no errors: Load context directly
 	 */
 	private inner class OpenAction : AbstractAction("Open...") {
 		override fun actionPerformed(e: ActionEvent) {
@@ -53,24 +56,58 @@ class MenuBar : JMenuBar() {
 			val selectedFile: File = fileChooser.selectedFile
 
 			try {
-				// Try to load the context from the selected file
-				val editingContextFactory = getKoin().get<EditingContextFactory>()
-				val context = editingContextFactory.createContext(selectedFile)
+				// Use lenient parsing to separate unparseable XML from validation errors
+				val editingContextFactory = getKoin().get<cz.vutbr.fit.interlockSim.xml.XMLContextFactory>()
+				val parseResult = editingContextFactory.createContextLenient(selectedFile)
 
-				// Success - update the frame with the loaded context
-				val frame = getKoin().get<Frame>()
-				frame.setContext(context)
+				when {
+					// Case 1: Successfully parsed with no errors
+					parseResult.isParseable && parseResult.validationResult.isValid -> {
+						val context = parseResult.context!!
+						val frame = getKoin().get<Frame>()
+						frame.setContext(context)
+						frame.modificationTracker.setCurrentFile(selectedFile)
+						frame.modificationTracker.markClean()
+					}
 
-				// Update modification tracker with loaded file
-				frame.modificationTracker.setCurrentFile(selectedFile)
-				frame.modificationTracker.markClean()
+					// Case 2: Parseable but has validation errors - show ValidationDialog with "Open Anyway"
+					parseResult.isParseable && !parseResult.validationResult.isValid -> {
+						val context = parseResult.context!!
+						val dialogResult =
+							ValidationDialog.show(
+								this@MenuBar,
+								parseResult.validationResult,
+								selectedFile,
+								allowOpenAnyway = true
+							)
+
+						if (dialogResult == ValidationDialog.DialogResult.OPEN_ANYWAY) {
+							// User chose to open anyway - load context
+							val frame = getKoin().get<Frame>()
+							frame.setContext(context)
+							frame.modificationTracker.setCurrentFile(selectedFile)
+							frame.modificationTracker.markClean()
+						}
+						// If CANCEL, do nothing (file remains closed)
+					}
+
+					// Case 3: Unparseable XML (malformed syntax) - show error and block
+					else -> {
+						JOptionPane.showMessageDialog(
+							this@MenuBar,
+							"Cannot open file: The XML is malformed and cannot be parsed.\n\n" +
+								"Please check the file for syntax errors (missing tags, invalid characters, etc.).",
+							"Unparseable XML",
+							JOptionPane.ERROR_MESSAGE
+						)
+					}
+				}
 			} catch (exception: Exception) {
-				// Issue #258: Failed to load file - show simple error, don't block with validation dialog
-				// This allows the editor to remain open so user can create a new file or try another file
+				// Unexpected error during parsing
 				JOptionPane.showMessageDialog(
 					this@MenuBar,
 					"Failed to open file: ${exception.message}\n\n" +
-						"The file may be malformed or contain invalid data.",
+						"An unexpected error occurred while loading the file.",
 					"Cannot Open File",
 					JOptionPane.ERROR_MESSAGE
 				)

src/main/kotlin/cz/vutbr/fit/interlockSim/gui/ValidationDialog.kt

@@ -34,10 +34,10 @@ import javax.swing.WindowConstants
  * - BEFORE: ValidationDialog shown when opening files → blocked opening invalid files
  * - AFTER:  ValidationDialog shown only on SAVE → warns before saving invalid files
  *
- * Current Usage Pattern:
- * - EDITOR MODE: Opening files with errors shows simple error dialog (not this)
- *   - Unparseable XML (malformed): Shows error, doesn't open
- *   - Future: Parseable XML with warnings: Allow opening (show this dialog with warnings)
+ * Current Usage Pattern (2026-02-06 Update):
+ * - EDITOR MODE: Opening files with errors shows ValidationDialog with "Open Anyway" option
+ *   - Unparseable XML (malformed): Shows error, blocks opening
+ *   - Parseable XML with validation warnings: Shows dialog, allows "Open Anyway"
  * - SIMULATION MODE: Transformation to simulation blocks invalid XML
  * - SAVE OPERATION: Show this dialog as WARNING before saving (TODO: implement)
  *
@@ -64,16 +64,23 @@ import javax.swing.WindowConstants
  * @param parent Parent component for modal dialog
  * @param validationResult Result of validation containing errors/warnings
  * @param filePath Optional file path being validated
+ * @param allowOpenAnyway If true, shows "Open Anyway" button alongside Cancel
  */
 class ValidationDialog(
 	parent: Component?,
 	private val validationResult: ValidationResult,
-	private val filePath: File? = null
+	private val filePath: File? = null,
+	private val allowOpenAnyway: Boolean = false
 ) : JDialog() {
 	private var userChoice: DialogResult = DialogResult.CANCEL
 
 	init {
-		title = "⚠ Validation Error"
+		title =
+			if (allowOpenAnyway) {
+				"⚠ Validation Warning"
+			} else {
+				"⚠ Validation Error"
+			}
 		isModal = true
 		defaultCloseOperation = WindowConstants.DISPOSE_ON_CLOSE
 
@@ -179,9 +186,24 @@ class ValidationDialog(
 				}
 			}
 
+		// Open Anyway button (only if allowed)
+		if (allowOpenAnyway) {
+			val openAnywayButton =
+				JButton("Open Anyway").apply {
+					addActionListener {
+						userChoice = DialogResult.OPEN_ANYWAY
+						dispose()
+					}
+					// Make this button stand out as the action button
+					isFocusPainted = true
+				}
+			panel.add(openAnywayButton)
+		}
+
 		panel.add(cancelButton)
 
-		// Focus on Cancel button by default
+		// Focus on appropriate button by default
+		// Always focus Cancel to make user make a conscious choice
 		cancelButton.requestFocusInWindow()
 
 		return panel
@@ -202,7 +224,13 @@ class ValidationDialog(
 		/**
 		 * User clicked Cancel or closed the dialog.
 		 */
-		CANCEL
+		CANCEL,
+
+		/**
+		 * User clicked "Open Anyway" to proceed despite validation errors.
+		 * Only available when allowOpenAnyway is true.
+		 */
+		OPEN_ANYWAY
 	}
 
 	companion object {
@@ -212,14 +240,16 @@ class ValidationDialog(
 		 * @param parent Parent component for modal dialog
 		 * @param validationResult Result of validation
 		 * @param filePath Optional file path being validated
+		 * @param allowOpenAnyway If true, shows "Open Anyway" button alongside Cancel
 		 * @return User's choice from the dialog
 		 */
 		fun show(
 			parent: Component?,
 			validationResult: ValidationResult,
-			filePath: File? = null
+			filePath: File? = null,
+			allowOpenAnyway: Boolean = false
 		): DialogResult {
-			val dialog = ValidationDialog(parent, validationResult, filePath)
+			val dialog = ValidationDialog(parent, validationResult, filePath, allowOpenAnyway)
 			return dialog.showDialog()
 		}
 	}