wip

Author: wanguardd

module/move/unilang/roadmap.md

@@ -30,19 +30,19 @@ The project has successfully completed its foundational phases (1-3), culminatin
 *   **Goal:** To implement the mandatory performance NFR for a zero-overhead static command system, enabling utilities with thousands of commands to start instantly.
 *   **Outcome:** A framework with a hybrid command registry where all compile-time commands are stored in a Perfect Hash Function (PHF), eliminating runtime registration costs and ensuring sub-millisecond command resolution.
 
-*   [⚫] **M4.1: registry_design_hybrid_architecture:**
+*   [✅] **M4.1: registry_design_hybrid_architecture:**
     *   **Spec Reference:** FR-PERF-1, NFR-Performance
     *   **Deliverable:** A detailed task plan for implementing a zero-overhead static command registry.
     *   **Description:** Design a build-time mechanism (using `build.rs` and the `phf` crate) to generate a Perfect Hash Function (PHF) map from a command manifest. This plan will outline the steps to refactor the `CommandRegistry` into a hybrid model.
-*   [⚫] **M4.2: phf_implement_build_time_generation:**
+*   [✅] **M4.2: phf_implement_build_time_generation:**
     *   **Prerequisites:** M4.1
     *   **Deliverable:** A `build.rs` script that generates a `.rs` file containing the static PHF map from `unilang.commands.yaml`.
     *   **Description:** Implement the build script that parses the YAML manifest and uses `phf_codegen` to construct the perfect hash map.
-*   [⚫] **M4.3: registry_refactor_to_hybrid_model:**
+*   [✅] **M4.3: registry_refactor_to_hybrid_model:**
     *   **Prerequisites:** M4.2
     *   **Deliverable:** An updated `CommandRegistry` that uses the generated PHF for static commands and a `HashMap` for dynamic commands.
     *   **Description:** Refactor all lookup methods to query the static PHF first before falling back to the dynamic `HashMap`.
-*   [⚫] **M4.4: test_implement_performance_stress_harness:**
+*   [✅] **M4.4: test_implement_performance_stress_harness:**
     *   **Prerequisites:** M4.3
     *   **Spec Reference:** FR-PERF-1
     *   **Deliverable:** A new integration test that generates a large YAML manifest (1000+ commands) and a test binary that proves the performance NFRs are met.
@@ -52,15 +52,15 @@ The project has successfully completed its foundational phases (1-3), culminatin
 *   **Goal:** To implement the remaining mandatory functional requirements from Spec v2.2.0, ensuring the framework fully supports REPL, interactive CLI, and WebAssembly (WASM) modalities.
 *   **Outcome:** A functionally complete and validated API for building sophisticated, user-friendly command-line applications that can run in native and web environments.
 
-*   [⚫] **M5.1: pipeline_refactor_for_reusability:**
+*   [✅] **M5.1: pipeline_refactor_for_reusability:**
     *   **Spec Reference:** FR-REPL-1
     *   **Deliverable:** An audited and confirmed stateless core pipeline and a new example file (`repl_example.rs`).
     *   **Description:** Audit the core pipeline components (`Parser`, `SemanticAnalyzer`, `Interpreter`) to ensure they are stateless and can be reused in a REPL loop.
-*   [⚫] **M5.2: argument_implement_interactive_signaling:**
+*   [✅] **M5.2: argument_implement_interactive_signaling:**
     *   **Spec Reference:** FR-INTERACTIVE-1
     *   **Deliverable:** The `SemanticAnalyzer` correctly returns the `UNILANG_ARGUMENT_INTERACTIVE_REQUIRED` error for missing interactive arguments.
     *   **Description:** Modify the `bind_arguments` logic to check for the `interactive: true` attribute on missing mandatory arguments and return the specific error code.
-*   [⚫] **M5.3: test_create_interactive_prompting_verification:**
+*   [✅] **M5.3: test_create_interactive_prompting_verification:**
     *   **Prerequisites:** M5.2
     *   **Deliverable:** A new unit test for the `SemanticAnalyzer` and an updated CLI binary demonstrating how to catch the interactive signal.
 *   [⚫] **M5.4: example_create_wasm_repl:**

module/move/unilang/src/error.rs

@@ -55,6 +55,165 @@ mod private
       Error::Execution( error )
     }
   }
+
+  #[cfg(test)]
+  mod tests
+  {
+    use super::*;
+    use crate::data::ErrorData;
+
+    #[test]
+    fn test_error_execution_display()
+    {
+      let error_data = ErrorData::new(
+        "TEST_ERROR".to_string(),
+        "This is a test error message".to_string(),
+      );
+      let error = Error::Execution(error_data);
+      
+      let error_string = error.to_string();
+      assert!(error_string.contains("Execution Error"));
+      assert!(error_string.contains("This is a test error message"));
+    }
+
+    #[test]
+    fn test_error_registration_display()
+    {
+      let error = Error::Registration("Failed to register command".to_string());
+      let error_string = error.to_string();
+      assert!(error_string.contains("Registration Error"));
+      assert!(error_string.contains("Failed to register command"));
+    }
+
+    #[test]
+    fn test_error_yaml_display()
+    {
+      let yaml_error = serde_yaml::from_str::<serde_yaml::Value>("invalid: yaml: {").unwrap_err();
+      let error = Error::Yaml(yaml_error);
+      let error_string = error.to_string();
+      assert!(error_string.contains("YAML Deserialization Error"));
+    }
+
+    #[test]
+    fn test_error_json_display()
+    {
+      let json_error = serde_json::from_str::<serde_json::Value>("{invalid json").unwrap_err();
+      let error = Error::Json(json_error);
+      let error_string = error.to_string();
+      assert!(error_string.contains("JSON Deserialization Error"));
+    }
+
+    #[test]
+    fn test_error_parse_display()
+    {
+      let parse_error = unilang_parser::error::ParseError::new(
+        unilang_parser::error::ErrorKind::Syntax("test parse error".to_string()),
+        unilang_parser::SourceLocation::StrSpan { start: 0, end: 5 }
+      );
+      let error = Error::Parse(parse_error);
+      let error_string = error.to_string();
+      assert!(error_string.contains("Parse Error"));
+      assert!(error_string.contains("test parse error"));
+    }
+
+    #[test]
+    fn test_type_error_conversion()
+    {
+      let type_error = crate::types::TypeError {
+        expected_kind: crate::data::Kind::Integer,
+        reason: "Invalid integer format".to_string(),
+      };
+      
+      let error: Error = type_error.into();
+      
+      if let Error::Execution(error_data) = error {
+        assert_eq!(error_data.code, "UNILANG_TYPE_MISMATCH");
+        assert!(error_data.message.contains("Type Error: Invalid integer format"));
+        assert!(error_data.message.contains("Please provide a valid value for this type"));
+      } else {
+        panic!("Expected Execution error");
+      }
+    }
+
+    #[test]
+    fn test_error_data_conversion()
+    {
+      let error_data = ErrorData::new(
+        "CUSTOM_ERROR".to_string(),
+        "Custom error message".to_string(),
+      );
+      
+      let error: Error = error_data.into();
+      
+      if let Error::Execution(data) = error {
+        assert_eq!(data.code, "CUSTOM_ERROR");
+        assert_eq!(data.message, "Custom error message");
+      } else {
+        panic!("Expected Execution error");
+      }
+    }
+
+    #[test]
+    fn test_yaml_error_from_conversion()
+    {
+      let yaml_error = serde_yaml::from_str::<serde_yaml::Value>("invalid: yaml: content: {").unwrap_err();
+      let error: Error = yaml_error.into();
+      
+      assert!(matches!(error, Error::Yaml(_)));
+    }
+
+    #[test]
+    fn test_json_error_from_conversion()
+    {
+      let json_error = serde_json::from_str::<serde_json::Value>("{malformed json").unwrap_err();
+      let error: Error = json_error.into();
+      
+      assert!(matches!(error, Error::Json(_)));
+    }
+
+    #[test]
+    fn test_parse_error_from_conversion()
+    {
+      let parse_error = unilang_parser::error::ParseError::new(
+        unilang_parser::error::ErrorKind::Syntax("parsing failed".to_string()),
+        unilang_parser::SourceLocation::StrSpan { start: 0, end: 3 }
+      );
+      let error: Error = parse_error.into();
+      
+      assert!(matches!(error, Error::Parse(_)));
+    }
+
+    #[test]
+    fn test_error_debug_format()
+    {
+      let error_data = ErrorData::new(
+        "DEBUG_ERROR".to_string(),
+        "Debug error message".to_string(),
+      );
+      let error = Error::Execution(error_data);
+      
+      let debug_string = format!("{:?}", error);
+      assert!(debug_string.contains("Execution"));
+      assert!(debug_string.contains("DEBUG_ERROR"));
+    }
+
+    #[test]
+    fn test_multiple_error_types()
+    {
+      let execution_error = Error::Execution(ErrorData::new(
+        "EXEC_ERROR".to_string(),
+        "Execution failed".to_string(),
+      ));
+      
+      let registration_error = Error::Registration("Registration failed".to_string());
+      
+      // Test that different error types display differently
+      assert!(execution_error.to_string().contains("Execution Error"));
+      assert!(registration_error.to_string().contains("Registration Error"));
+      assert!(!execution_error.to_string().contains("Registration"));
+      assert!(!registration_error.to_string().contains("Execution"));
+    }
+  }
 }
 
 mod_interface::mod_interface!