Merge branch 'release/0.7.4'

Author: ljonesfl

.version.json

@@ -2,6 +2,6 @@
   "strategy": "semver",
   "major": 0,
   "minor": 7,
-  "patch": 3,
+  "patch": 4,
   "build": 0
 }

VERSIONLOG.md

@@ -1,3 +1,6 @@
+## 0.7.4 2025-11-21
+* Added get and set magic methods to the Registry.
+
 ## 0.7.3 2025-11-11
 * Converted to camelcase.
 

src/Patterns/Registry.php

@@ -10,41 +10,31 @@
  * throughout the application lifecycle. It serves as a service locator and
  * dependency injection container, allowing components to share state and
  * communicate across the entire framework.
- * 
- * Key characteristics:
- * - Thread-safe singleton implementation
- * - Global state management for framework components
- * - Object lifecycle management and storage
- * - Service locator pattern for dependency resolution
- * - Memory-based storage with automatic cleanup
- * 
- * Usage patterns:
- * - Store framework configuration objects
- * - Cache expensive-to-create objects (database connections, etc.)
- * - Share state between disconnected components
- * - Implement service locator for dependency injection
- * 
- * Thread Safety:
- * The registry uses memory-based singleton storage, which is safe for
- * single-threaded PHP environments. For multi-threaded scenarios,
- * consider using alternative storage backends.
- * 
+ *
  * @package Neuron\Patterns
  * 
  * @example
  * ```php
  * $registry = Registry::instance();
- * 
- * // Store configuration
+ *
+ * // Store configuration (method syntax)
  * $registry->set('database.config', $dbConfig);
  * $registry->set('app.settings', $appSettings);
- * 
- * // Retrieve objects
+ *
+ * // Store configuration (property syntax using magic methods)
+ * $registry->databaseConfig = $dbConfig;
+ * $registry->appSettings = $appSettings;
+ *
+ * // Retrieve objects (method syntax)
  * $dbConfig = $registry->get('database.config');
- * $hasCache = $registry->has('cache.instance');
- * 
+ *
+ * // Retrieve objects (property syntax using magic methods)
+ * $dbConfig = $registry->databaseConfig;
+ *
+ * // Check existence
+ * $exists = isset($registry->databaseConfig);
+ *
  * // Cleanup
- * $registry->remove('temp.data');
  * $registry->reset(); // Clear all objects
  * ```
  */
@@ -87,4 +77,38 @@ public function reset() : void
 	{
 		$this->_objects = [];
 	}
+
+	/**
+	 * Magic method to get a registry value using property syntax.
+	 *
+	 * @param string $name The name of the registry key
+	 * @return mixed The value stored in the registry, or null if not found
+	 */
+	public function __get( string $name ) : mixed
+	{
+		return $this->get( $name );
+	}
+
+	/**
+	 * Magic method to set a registry value using property syntax.
+	 *
+	 * @param string $name The name of the registry key
+	 * @param mixed $value The value to store in the registry
+	 * @return void
+	 */
+	public function __set( string $name, mixed $value ) : void
+	{
+		$this->set( $name, $value );
+	}
+
+	/**
+	 * Magic method to check if a registry key exists using isset().
+	 *
+	 * @param string $name The name of the registry key
+	 * @return bool True if the key exists in the registry, false otherwise
+	 */
+	public function __isset( string $name ) : bool
+	{
+		return array_key_exists( $name, $this->_objects );
+	}
 }

tests/Patterns/RegistryTest.php

@@ -42,4 +42,74 @@ public function testReset()
 
 		$this->assertNull( $Reg2->get( 'test' ) );
 	}
+
+	public function testMagicSet()
+	{
+		$Reg1 = Registry::getInstance();
+		$Reg1->reset();
+
+		// Test magic __set
+		$Reg1->testKey = 'magic value';
+
+		// Verify using regular get method
+		$this->assertEquals( 'magic value', $Reg1->get( 'testKey' ) );
+
+		// Verify using getInstance
+		$Reg2 = Registry::getInstance();
+		$this->assertEquals( 'magic value', $Reg2->get( 'testKey' ) );
+	}
+
+	public function testMagicGet()
+	{
+		$Reg1 = Registry::getInstance();
+		$Reg1->reset();
+
+		// Set using regular method
+		$Reg1->set( 'testKey', 'test value' );
+
+		// Test magic __get
+		$this->assertEquals( 'test value', $Reg1->testKey );
+
+		// Verify null is returned for non-existent keys
+		$this->assertNull( $Reg1->nonExistentKey );
+	}
+
+	public function testMagicIsset()
+	{
+		$Reg1 = Registry::getInstance();
+		$Reg1->reset();
+
+		// Test isset on non-existent key
+		$this->assertFalse( isset( $Reg1->testKey ) );
+
+		// Set a value
+		$Reg1->testKey = 'some value';
+
+		// Test isset on existing key
+		$this->assertTrue( isset( $Reg1->testKey ) );
+
+		// Reset and verify isset returns false
+		$Reg1->reset();
+		$this->assertFalse( isset( $Reg1->testKey ) );
+	}
+
+	public function testMagicMethodsIntegration()
+	{
+		$Reg1 = Registry::getInstance();
+		$Reg1->reset();
+
+		// Mix magic methods and regular methods
+		$Reg1->magicKey = 'magic';
+		$Reg1->set( 'regularKey', 'regular' );
+
+		// Verify both can be retrieved with either syntax
+		$this->assertEquals( 'magic', $Reg1->magicKey );
+		$this->assertEquals( 'magic', $Reg1->get( 'magicKey' ) );
+		$this->assertEquals( 'regular', $Reg1->regularKey );
+		$this->assertEquals( 'regular', $Reg1->get( 'regularKey' ) );
+
+		// Verify isset works for both
+		$this->assertTrue( isset( $Reg1->magicKey ) );
+		$this->assertTrue( isset( $Reg1->regularKey ) );
+	}
 }