Ariadne-CMS / arc-prototype

src/prototype.php

Doc Comments +1 added lines, -1 removed lines

@@ -303,7 +303,7 @@
 
 	/**
 	 * Removes an observer callback for the given prototype.
-	 * @param \arc\prototype\Prototyp $prototype
+	 * @param prototype\Prototype $prototype
 	 * @param \Closure $callback the observer callback to be removed
 	 */
 	public static function unobserve($prototype, $callback) 

Indentation +355 added lines, -355 removed lines

@@ -17,308 +17,308 @@ 
 final class Prototype 
 {
 
-	/**
-	 * @var \SplObjectStorage contains a list of frozen objects and the observer
-	 */
-	private static $frozen = null;
-
-	/**
-	 * @var \SplObjectStorage contains a list of objects made unextensible and the observer
-	 */
-	private static $notExtensible = null;
-
-	/**
-	 * @var \SplObjectStorage contains a list of all 'child' instances for each prototype
-	 */
-	private static $instances = null;
-
-	/**
-	 * @var \SplObjectStorage contains a list of all observers for each prototype
-	 */
-	private static $observers = null;
-
-	/**
-	 * Returns a new \arc\prototype\Prototype object with the given properties. The 
-	 * properties array may contain closures, these will be available as methods on 
-	 * the new Prototype object.
-	 * @param array $properties List of properties and methods
-	 * @return \arc\prototype\Prototype
-	 */
-	public static function create($properties) 
-	{
-		return new prototype\Prototype($properties);
-	}
-
-	/**
-	 * Returns a new \arc\prototype\Prototype object with the given object as its
-	 * prototype and the given properties and methods set.
-	 * @param \arc\prototype\Prototype $prototype The prototype for this object
-	 * @param array $properties List of properties and methods
-	 * @return \arc\prototype\Prototype
-	 */
-	public static function extend($prototype, $properties) 
-	{
-		if ( self::isExtensible($prototype) ) {
-			if (!isset(self::$instances)) {
-				self::$instances = new \SplObjectStorage();
-			};
-			if (!isset(self::$instances[$prototype])) {
-				self::$instances[$prototype] = [];
-			}
-			$properties['prototype'] = $prototype;
-			$instance = new prototype\Prototype($properties);
-			$list = self::$instances[$prototype];
-			array_push($list,$instance);
-			self::$instances[$prototype] = $list;
-			return $instance;
-		} else {
-			return null;
-		}
-	}
-
-	/**
-	 * Helper method to remove cache information when a prototype is no longer needed.
-	 * @param \arc\prototype\Prototype $obj The object to be removed
-	 */
-	public static function _destroy($obj) 
-	{
-		self::unfreeze($obj);
-		if ( isset(self::$notExtensible[$obj]) ) {
-			unset(self::$notExtensible[$obj]);
-		}
-		if ( isset(self::$observers[$obj]) ) {
-			unset(self::$observers[$obj]);
-		}
-		if ( isset($obj->prototype) ) {
-			unset(self::$instances[$obj->prototype]);
-		}
-	}
-
-	/**
-	 * Returns a new \arc\prototype\Prototype with the given prototype set. In addition 
-	 * all properties on the extra objects passed to this method will be copied to the 
-	 * new Prototype object. For any property that is set on multiple objects, the value 
-	 * of the property in the later object overwrites values from other objects.
-	 * @param \arc\prototype\Prototype $prototype the prototype for the new object
-	 * @param \arc\prototype\Prototype ...$object the objects whose properties will be assigned
-	 */
-	public static function assign($prototype) 
-	{
-		$objects = func_get_args();
-		array_shift($objects);
-		$properties = [];
-		foreach ($objects as $obj) {
-			$properties = $obj->properties + $properties;
-		}
-		return self::extend($prototype, $properties);
-	}
-
-	/**
-	 * This makes changes to the given Prototype object impossible, untill you call 
-	 * \arc\prototype::unfreeze($prototype). The object becomes immutable. Any 
-	 * attempt to change the object will silently fail.
-	 * @param \arc\prototype\Prototype $prototype the object to freeze
-	 */
-	public static function freeze($prototype) 
-	{
-		if (!isset(self::$frozen)) {
-			self::$frozen = new \SplObjectStorage();
-		}
-		self::$frozen[$prototype] = function($name, $value) {
-			return false;
-		};
-		return self::observe($prototype, self::$frozen[$prototype]);	
-	}
-
-	/**
-	 * Makes the given object mutable again.
-	 * @param \arc\prototype\Prototype $prototype
-	 */
-	public static function unfreeze($prototype) 
-	{
-		if ( isset(self::$frozen) && isset(self::$frozen[$prototype]) ) {
-			self::unobserve($prototype, self::$frozen[$prototype]);
-			unset(self::$frozen[$prototype]);
-		}
-	}
-
-	/**
-	 * Returns a list of keys of all the properties in the given prototype
-	 * @param \arc\prototype\Prototype $prototype
-	 * @return array
-	 */
-	public static function keys($prototype) 
-	{
-		$entries = static::entries($prototype);
-		return array_keys($entries);
-	}
-
-	/**
-	 * Returns an array with key:value pairs for all properties in the given prototype
-	 * @param \arc\prototype\Prototype $prototype
-	 * @return array
-	 */
-	public static function entries($prototype) 
-	{
-		return $prototype->properties;
-	}
-
-	/**
-	 * Returns a list of all the property values in the given prototype
-	 * @param \arc\prototype\Prototype $prototype
-	 * @return array
-	 */
-	public static function values($prototype) 
-	{
-		$entries = static::entries($prototype);
-		return array_values($entries);
-	}
-
-	/**
-	 * Returns true if the the property name is available in this prototype
-	 * @param \arc\prototype\Prototype $prototype
-	 * @param string $property
-	 * @return bool
-	 */
-	public static function hasProperty($prototype, $property) 
-	{
-		$entries = static::entries($prototype);
-		return array_key_exists($property, $entries);
-	}
-
-	/**
-	 * Returns a list of all the property names defined in this prototype instance
-	 * without traversing its prototypes.
-	 * @param \arc\prototype\Prototype $prototype
-	 * @return array
-	 */
-	public static function ownKeys($prototype) 
-	{
-		$entries = static::ownEntries($prototype);
-		return array_keys($entries);
-	}
-
-	/**
-	 * Returns an array with key:value pairs for all properties in this prototype
-	 * instance wihtout traversing its prototypes.
-	 * @param \arc\prototype\Prototype $prototype
-	 * @return array
-	 */
-	public static function ownEntries($prototype) 
-	{
-		// this needs access to the private _ownProperties variable
-		// this is one way to do that.
-		$f = \Closure::bind(function() use ($prototype) {
-			return $prototype->_ownProperties;
-		}, $prototype, $prototype);
-		return $f();
-	}
-
-	/**
-	 * Returns a list of all the property values in the given prototype
-	 * instance wihtout traversing its prototypes.
-	 * @param \arc\prototype\Prototype $prototype
-	 * @return array
-	 */
-	public static function ownValues($prototype) 
-	{
-		$entries = static::ownEntries($prototype);
-		return array_values($entries);
-	}
-
-	/**
-	 * Returns true if the the property name is available in this prototype
-	 * instance wihtout traversing its prototypes.
-	 * @param \arc\prototype\Prototype $prototype
-	 * @param string $property
-	 * @return bool
-	 */
-	public static function hasOwnProperty($prototype, $property) 
-	{
-		$entries = static::ownEntries($prototype);
-		return array_key_exists($property, $entries);
-	}
-
-	/**
-	 * Returns true if the given prototype is made immutable by freeze()
-	 * @param \arc\prototype\Prototype $prototype
-	 * @return bool
-	 */
-	public static function isFrozen($prototype) 
-	{
-		return isset(self::$frozen[$prototype]);
-	}
-
-	/**
-	 * Returns true if the given prototype is made not Extensible
-	 * @param \arc\prototype\Prototype $prototype
-	 * @return bool
-	 */
-	public static function isExtensible($prototype) 
-	{
-		return !isset(self::$notExtensible[$prototype]);
-	}
-
-	/**
-	 * This calls the $callback function each time a property of $prototype is 
-	 * changed or unset. The callback is called with the prototype object, the 
-	 * name of the property and the new value (null if unset).
-	 * If the closure returns false exactly (no other 'falsy' values will work), 
-	 * the change will be cancelled
-	 * @param \arc\prototype\Prototype $prototype
-	 * @param \Closure $callback
-	 */
-	public static function observe($prototype, $callback) 
-	{
-		if ( !isset(self::$observers) ) {
-			self::$observers = new \SplObjectStorage();
-		}
-		if ( !isset(self::$observers[$prototype]) ) {
-			self::$observers[$prototype] = new \SplObjectStorage();
-		}
-		self::$observers[$prototype][$callback] = true;
-	}
-
-	/**
-	 * Returns a list of observers for the given prototype.
-	 * @param \arc\prototype\Prototype $prototype
-	 * @return array
-	 */
-	public static function getObservers($prototype) 
-	{
-		return (isset(self::$observers[$prototype]) ? self::$observers[$prototype] : [] );
-	}
-
-	/**
-	 * Makes an object no longer extensible.
-	 * @param \arc\prototype\Prototype $prototype
-	 */
-	public static function preventExtensions($prototype) 
-	{
-		if ( !isset(self::$notExtensible) ) {
-			self::$notExtensible = new \SplObjectStorage();
-		}
-		self::$notExtensible[$prototype] = true;
-	}
-
-	/**
-	 * Removes an observer callback for the given prototype.
-	 * @param \arc\prototype\Prototyp $prototype
-	 * @param \Closure $callback the observer callback to be removed
-	 */
-	public static function unobserve($prototype, $callback) 
-	{
-		if ( isset(self::$observers) && isset(self::$observers[$prototype]) ) {
-			unset(self::$observers[$prototype][$callback]);
-		}
-	}
-
-	/**
-	 * Returns true if the object as the given prototype somewhere in its
-	 * prototype chain, including itself.
-	 */
-	public static function hasPrototype($obj, $prototype) 
-	{
+    /**
+     * @var \SplObjectStorage contains a list of frozen objects and the observer
+     */
+    private static $frozen = null;
+
+    /**
+     * @var \SplObjectStorage contains a list of objects made unextensible and the observer
+     */
+    private static $notExtensible = null;
+
+    /**
+     * @var \SplObjectStorage contains a list of all 'child' instances for each prototype
+     */
+    private static $instances = null;
+
+    /**
+     * @var \SplObjectStorage contains a list of all observers for each prototype
+     */
+    private static $observers = null;
+
+    /**
+     * Returns a new \arc\prototype\Prototype object with the given properties. The 
+     * properties array may contain closures, these will be available as methods on 
+     * the new Prototype object.
+     * @param array $properties List of properties and methods
+     * @return \arc\prototype\Prototype
+     */
+    public static function create($properties) 
+    {
+        return new prototype\Prototype($properties);
+    }
+
+    /**
+     * Returns a new \arc\prototype\Prototype object with the given object as its
+     * prototype and the given properties and methods set.
+     * @param \arc\prototype\Prototype $prototype The prototype for this object
+     * @param array $properties List of properties and methods
+     * @return \arc\prototype\Prototype
+     */
+    public static function extend($prototype, $properties) 
+    {
+        if ( self::isExtensible($prototype) ) {
+            if (!isset(self::$instances)) {
+                self::$instances = new \SplObjectStorage();
+            };
+            if (!isset(self::$instances[$prototype])) {
+                self::$instances[$prototype] = [];
+            }
+            $properties['prototype'] = $prototype;
+            $instance = new prototype\Prototype($properties);
+            $list = self::$instances[$prototype];
+            array_push($list,$instance);
+            self::$instances[$prototype] = $list;
+            return $instance;
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Helper method to remove cache information when a prototype is no longer needed.
+     * @param \arc\prototype\Prototype $obj The object to be removed
+     */
+    public static function _destroy($obj) 
+    {
+        self::unfreeze($obj);
+        if ( isset(self::$notExtensible[$obj]) ) {
+            unset(self::$notExtensible[$obj]);
+        }
+        if ( isset(self::$observers[$obj]) ) {
+            unset(self::$observers[$obj]);
+        }
+        if ( isset($obj->prototype) ) {
+            unset(self::$instances[$obj->prototype]);
+        }
+    }
+
+    /**
+     * Returns a new \arc\prototype\Prototype with the given prototype set. In addition 
+     * all properties on the extra objects passed to this method will be copied to the 
+     * new Prototype object. For any property that is set on multiple objects, the value 
+     * of the property in the later object overwrites values from other objects.
+     * @param \arc\prototype\Prototype $prototype the prototype for the new object
+     * @param \arc\prototype\Prototype ...$object the objects whose properties will be assigned
+     */
+    public static function assign($prototype) 
+    {
+        $objects = func_get_args();
+        array_shift($objects);
+        $properties = [];
+        foreach ($objects as $obj) {
+            $properties = $obj->properties + $properties;
+        }
+        return self::extend($prototype, $properties);
+    }
+
+    /**
+     * This makes changes to the given Prototype object impossible, untill you call 
+     * \arc\prototype::unfreeze($prototype). The object becomes immutable. Any 
+     * attempt to change the object will silently fail.
+     * @param \arc\prototype\Prototype $prototype the object to freeze
+     */
+    public static function freeze($prototype) 
+    {
+        if (!isset(self::$frozen)) {
+            self::$frozen = new \SplObjectStorage();
+        }
+        self::$frozen[$prototype] = function($name, $value) {
+            return false;
+        };
+        return self::observe($prototype, self::$frozen[$prototype]);	
+    }
+
+    /**
+     * Makes the given object mutable again.
+     * @param \arc\prototype\Prototype $prototype
+     */
+    public static function unfreeze($prototype) 
+    {
+        if ( isset(self::$frozen) && isset(self::$frozen[$prototype]) ) {
+            self::unobserve($prototype, self::$frozen[$prototype]);
+            unset(self::$frozen[$prototype]);
+        }
+    }
+
+    /**
+     * Returns a list of keys of all the properties in the given prototype
+     * @param \arc\prototype\Prototype $prototype
+     * @return array
+     */
+    public static function keys($prototype) 
+    {
+        $entries = static::entries($prototype);
+        return array_keys($entries);
+    }
+
+    /**
+     * Returns an array with key:value pairs for all properties in the given prototype
+     * @param \arc\prototype\Prototype $prototype
+     * @return array
+     */
+    public static function entries($prototype) 
+    {
+        return $prototype->properties;
+    }
+
+    /**
+     * Returns a list of all the property values in the given prototype
+     * @param \arc\prototype\Prototype $prototype
+     * @return array
+     */
+    public static function values($prototype) 
+    {
+        $entries = static::entries($prototype);
+        return array_values($entries);
+    }
+
+    /**
+     * Returns true if the the property name is available in this prototype
+     * @param \arc\prototype\Prototype $prototype
+     * @param string $property
+     * @return bool
+     */
+    public static function hasProperty($prototype, $property) 
+    {
+        $entries = static::entries($prototype);
+        return array_key_exists($property, $entries);
+    }
+
+    /**
+     * Returns a list of all the property names defined in this prototype instance
+     * without traversing its prototypes.
+     * @param \arc\prototype\Prototype $prototype
+     * @return array
+     */
+    public static function ownKeys($prototype) 
+    {
+        $entries = static::ownEntries($prototype);
+        return array_keys($entries);
+    }
+
+    /**
+     * Returns an array with key:value pairs for all properties in this prototype
+     * instance wihtout traversing its prototypes.
+     * @param \arc\prototype\Prototype $prototype
+     * @return array
+     */
+    public static function ownEntries($prototype) 
+    {
+        // this needs access to the private _ownProperties variable
+        // this is one way to do that.
+        $f = \Closure::bind(function() use ($prototype) {
+            return $prototype->_ownProperties;
+        }, $prototype, $prototype);
+        return $f();
+    }
+
+    /**
+     * Returns a list of all the property values in the given prototype
+     * instance wihtout traversing its prototypes.
+     * @param \arc\prototype\Prototype $prototype
+     * @return array
+     */
+    public static function ownValues($prototype) 
+    {
+        $entries = static::ownEntries($prototype);
+        return array_values($entries);
+    }
+
+    /**
+     * Returns true if the the property name is available in this prototype
+     * instance wihtout traversing its prototypes.
+     * @param \arc\prototype\Prototype $prototype
+     * @param string $property
+     * @return bool
+     */
+    public static function hasOwnProperty($prototype, $property) 
+    {
+        $entries = static::ownEntries($prototype);
+        return array_key_exists($property, $entries);
+    }
+
+    /**
+     * Returns true if the given prototype is made immutable by freeze()
+     * @param \arc\prototype\Prototype $prototype
+     * @return bool
+     */
+    public static function isFrozen($prototype) 
+    {
+        return isset(self::$frozen[$prototype]);
+    }
+
+    /**
+     * Returns true if the given prototype is made not Extensible
+     * @param \arc\prototype\Prototype $prototype
+     * @return bool
+     */
+    public static function isExtensible($prototype) 
+    {
+        return !isset(self::$notExtensible[$prototype]);
+    }
+
+    /**
+     * This calls the $callback function each time a property of $prototype is 
+     * changed or unset. The callback is called with the prototype object, the 
+     * name of the property and the new value (null if unset).
+     * If the closure returns false exactly (no other 'falsy' values will work), 
+     * the change will be cancelled
+     * @param \arc\prototype\Prototype $prototype
+     * @param \Closure $callback
+     */
+    public static function observe($prototype, $callback) 
+    {
+        if ( !isset(self::$observers) ) {
+            self::$observers = new \SplObjectStorage();
+        }
+        if ( !isset(self::$observers[$prototype]) ) {
+            self::$observers[$prototype] = new \SplObjectStorage();
+        }
+        self::$observers[$prototype][$callback] = true;
+    }
+
+    /**
+     * Returns a list of observers for the given prototype.
+     * @param \arc\prototype\Prototype $prototype
+     * @return array
+     */
+    public static function getObservers($prototype) 
+    {
+        return (isset(self::$observers[$prototype]) ? self::$observers[$prototype] : [] );
+    }
+
+    /**
+     * Makes an object no longer extensible.
+     * @param \arc\prototype\Prototype $prototype
+     */
+    public static function preventExtensions($prototype) 
+    {
+        if ( !isset(self::$notExtensible) ) {
+            self::$notExtensible = new \SplObjectStorage();
+        }
+        self::$notExtensible[$prototype] = true;
+    }
+
+    /**
+     * Removes an observer callback for the given prototype.
+     * @param \arc\prototype\Prototyp $prototype
+     * @param \Closure $callback the observer callback to be removed
+     */
+    public static function unobserve($prototype, $callback) 
+    {
+        if ( isset(self::$observers) && isset(self::$observers[$prototype]) ) {
+            unset(self::$observers[$prototype][$callback]);
+        }
+    }
+
+    /**
+     * Returns true if the object as the given prototype somewhere in its
+     * prototype chain, including itself.
+     */
+    public static function hasPrototype($obj, $prototype) 
+    {
         if (!$obj->prototype) {
             return false;
         }
@@ -327,59 +327,59 @@ 
         }
 
         return static::hasPrototype($obj->prototype, $prototype );
-	}
-
-	/**
-	 * Returns a list of prototype objects that have this prototype object
-	 * in their prototype chain.
-	 * @param \arc\prototype\Prototype $prototype
-	 * @return array
-	 */
-	public static function getDescendants($prototype) 
-	{
-		$instances = self::getInstances($prototype);
-		$descendants = $instances;
-		foreach ($instances as $instance) {
-			$descendants += self::getDescendants($instance);
-		}
-		return $descendants;
-	}
-
-	/**
-	 * Returns a list of prototype objects that have this prototype object
-	 * as their direct prototype.
-	 * @param \arc\prototype\Prototype $prototype
-	 * @return array
-	 */
-	public static function getInstances($prototype) 
-	{
-		return (isset(self::$instances[$prototype]) ? self::$instances[$prototype] : [] );
-	}
-
-	/**
-	 * Returns the full prototype chain for the given object.
-	 * @param \arc\prototype\Prototype $obj
-	 * @return array
-	 */
-	public static function getPrototypes($obj) 
-	{
-		$prototypes = [];
-		while ( $prototype = $obj->prototype ) {
-			$prototypes[] = $prototype;
-			$obj = $prototype;
-		}
-		return $prototypes;
-	}
-
-	/**
-	 * Returns a new function that calls the given function just once and then simply
-	 * returns its result on each subsequent call.
-	 * @param callable function to call just once and then remember the result
-	 */
-	public static function memoize($f) 
-	{
-		return memoize($f);
-	}
+    }
+
+    /**
+     * Returns a list of prototype objects that have this prototype object
+     * in their prototype chain.
+     * @param \arc\prototype\Prototype $prototype
+     * @return array
+     */
+    public static function getDescendants($prototype) 
+    {
+        $instances = self::getInstances($prototype);
+        $descendants = $instances;
+        foreach ($instances as $instance) {
+            $descendants += self::getDescendants($instance);
+        }
+        return $descendants;
+    }
+
+    /**
+     * Returns a list of prototype objects that have this prototype object
+     * as their direct prototype.
+     * @param \arc\prototype\Prototype $prototype
+     * @return array
+     */
+    public static function getInstances($prototype) 
+    {
+        return (isset(self::$instances[$prototype]) ? self::$instances[$prototype] : [] );
+    }
+
+    /**
+     * Returns the full prototype chain for the given object.
+     * @param \arc\prototype\Prototype $obj
+     * @return array
+     */
+    public static function getPrototypes($obj) 
+    {
+        $prototypes = [];
+        while ( $prototype = $obj->prototype ) {
+            $prototypes[] = $prototype;
+            $obj = $prototype;
+        }
+        return $prototypes;
+    }
+
+    /**
+     * Returns a new function that calls the given function just once and then simply
+     * returns its result on each subsequent call.
+     * @param callable function to call just once and then remember the result
+     */
+    public static function memoize($f) 
+    {
+        return memoize($f);
+    }
 }
 
 /**

Spacing +16 added lines, -16 removed lines

@@ -58,7 +58,7 @@ 
 	 */
 	public static function extend($prototype, $properties) 
 	{
-		if ( self::isExtensible($prototype) ) {
+		if (self::isExtensible($prototype)) {
 			if (!isset(self::$instances)) {
 				self::$instances = new \SplObjectStorage();
 			};
@@ -68,7 +68,7 @@ 
 			$properties['prototype'] = $prototype;
 			$instance = new prototype\Prototype($properties);
 			$list = self::$instances[$prototype];
-			array_push($list,$instance);
+			array_push($list, $instance);
 			self::$instances[$prototype] = $list;
 			return $instance;
 		} else {
@@ -83,13 +83,13 @@ 
 	public static function _destroy($obj) 
 	{
 		self::unfreeze($obj);
-		if ( isset(self::$notExtensible[$obj]) ) {
+		if (isset(self::$notExtensible[$obj])) {
 			unset(self::$notExtensible[$obj]);
 		}
-		if ( isset(self::$observers[$obj]) ) {
+		if (isset(self::$observers[$obj])) {
 			unset(self::$observers[$obj]);
 		}
-		if ( isset($obj->prototype) ) {
+		if (isset($obj->prototype)) {
 			unset(self::$instances[$obj->prototype]);
 		}
 	}
@@ -136,7 +136,7 @@ 
 	 */
 	public static function unfreeze($prototype) 
 	{
-		if ( isset(self::$frozen) && isset(self::$frozen[$prototype]) ) {
+		if (isset(self::$frozen) && isset(self::$frozen[$prototype])) {
 			self::unobserve($prototype, self::$frozen[$prototype]);
 			unset(self::$frozen[$prototype]);
 		}
@@ -270,10 +270,10 @@ 
 	 */
 	public static function observe($prototype, $callback) 
 	{
-		if ( !isset(self::$observers) ) {
+		if (!isset(self::$observers)) {
 			self::$observers = new \SplObjectStorage();
 		}
-		if ( !isset(self::$observers[$prototype]) ) {
+		if (!isset(self::$observers[$prototype])) {
 			self::$observers[$prototype] = new \SplObjectStorage();
 		}
 		self::$observers[$prototype][$callback] = true;
@@ -286,7 +286,7 @@ 
 	 */
 	public static function getObservers($prototype) 
 	{
-		return (isset(self::$observers[$prototype]) ? self::$observers[$prototype] : [] );
+		return (isset(self::$observers[$prototype]) ? self::$observers[$prototype] : []);
 	}
 
 	/**
@@ -295,7 +295,7 @@ 
 	 */
 	public static function preventExtensions($prototype) 
 	{
-		if ( !isset(self::$notExtensible) ) {
+		if (!isset(self::$notExtensible)) {
 			self::$notExtensible = new \SplObjectStorage();
 		}
 		self::$notExtensible[$prototype] = true;
@@ -308,7 +308,7 @@ 
 	 */
 	public static function unobserve($prototype, $callback) 
 	{
-		if ( isset(self::$observers) && isset(self::$observers[$prototype]) ) {
+		if (isset(self::$observers) && isset(self::$observers[$prototype])) {
 			unset(self::$observers[$prototype][$callback]);
 		}
 	}
@@ -326,7 +326,7 @@ 
             return true;
         }
 
-        return static::hasPrototype($obj->prototype, $prototype );
+        return static::hasPrototype($obj->prototype, $prototype);
 	}
 
 	/**
@@ -353,7 +353,7 @@ 
 	 */
 	public static function getInstances($prototype) 
 	{
-		return (isset(self::$instances[$prototype]) ? self::$instances[$prototype] : [] );
+		return (isset(self::$instances[$prototype]) ? self::$instances[$prototype] : []);
 	}
 
 	/**
@@ -364,7 +364,7 @@ 
 	public static function getPrototypes($obj) 
 	{
 		$prototypes = [];
-		while ( $prototype = $obj->prototype ) {
+		while ($prototype = $obj->prototype) {
 			$prototypes[] = $prototype;
 			$obj = $prototype;
 		}
@@ -388,10 +388,10 @@ 
  */
 function memoize($f) 
 {
-    return function () use ($f) {
+    return function() use ($f) {
         static $result;
         if (null === $result) {
-            if ( $f instanceof \Closure && isset($this) ) {
+            if ($f instanceof \Closure && isset($this)) {
                 $f = \Closure::bind($f, $this);
             }
             $result = $f();

src/prototype/Prototype.php

Indentation +4 added lines, -4 removed lines

@@ -27,8 +27,8 @@ 
     private $_staticMethods = [];
 
     /**
-    * @var Object prototype Readonly reference to a prototype object. Can only be set in the constructor.
-    */
+     * @var Object prototype Readonly reference to a prototype object. Can only be set in the constructor.
+     */
     private $prototype = null;
 
     /**
@@ -38,7 +38,7 @@ 
     {
         foreach ($properties as $property => $value) {
             if ( !is_numeric( $property ) && $property!='properties' ) {
-                 if ( $property[0] == ':' ) {
+                    if ( $property[0] == ':' ) {
                     $property = substr($property, 1);
                     $this->_staticMethods[$property] = true;
                     $this->_ownProperties[$property] = $value;
@@ -222,7 +222,7 @@ 
      */
     public function __destruct()
     {
-    	\arc\prototype::_destroy($this);
+        \arc\prototype::_destroy($this);
         return $this->_tryToCall( $this->__destruct );
     }
 

Spacing +48 added lines, -48 removed lines

@@ -37,15 +37,15 @@ 
     public function __construct($properties = [])
     {
         foreach ($properties as $property => $value) {
-            if ( !is_numeric( $property ) && $property!='properties' ) {
-                 if ( $property[0] == ':' ) {
+            if (!is_numeric($property) && $property != 'properties') {
+                 if ($property[0] == ':') {
                     $property = substr($property, 1);
                     $this->_staticMethods[$property] = true;
                     $this->_ownProperties[$property] = $value;
                 } else if ($property == 'prototype') {
                     $this->prototype = $value;
                 } else {
-                    $this->_ownProperties[$property] = $this->_bind( $value );
+                    $this->_ownProperties[$property] = $this->_bind($value);
                 }
             }
         }
@@ -59,21 +59,21 @@ 
      */
     public function __call($name, $args)
     {
-        if (array_key_exists( $name, $this->_ownProperties ) && is_callable( $this->_ownProperties[$name] )) {
-            if ( array_key_exists($name, $this->_staticMethods) ) {
+        if (array_key_exists($name, $this->_ownProperties) && is_callable($this->_ownProperties[$name])) {
+            if (array_key_exists($name, $this->_staticMethods)) {
                 array_unshift($args, $this);
             }
-            return call_user_func_array( $this->_ownProperties[$name], $args );
-        } elseif (is_object( $this->prototype)) {
-            $method = $this->_getPrototypeProperty( $name );
-            if (is_callable( $method )) {
-                if ( array_key_exists($name, $this->_staticMethods) ) {
+            return call_user_func_array($this->_ownProperties[$name], $args);
+        } elseif (is_object($this->prototype)) {
+            $method = $this->_getPrototypeProperty($name);
+            if (is_callable($method)) {
+                if (array_key_exists($name, $this->_staticMethods)) {
                     array_unshift($args, $this);
                 }
-                return call_user_func_array( $method, $args );
+                return call_user_func_array($method, $args);
             }
         }
-        throw new \arc\ExceptionMethodNotFound( $name.' is not a method on this Object', \arc\exceptions::OBJECT_NOT_FOUND );
+        throw new \arc\ExceptionMethodNotFound($name.' is not a method on this Object', \arc\exceptions::OBJECT_NOT_FOUND);
     }
 
     /**
@@ -90,10 +90,10 @@ 
                 return $this->_getPublicProperties();
             break;
             default:
-                if ( array_key_exists($name, $this->_ownProperties) ) {
+                if (array_key_exists($name, $this->_ownProperties)) {
                     return $this->_ownProperties[$name];
                 }
-                return $this->_getPrototypeProperty( $name );
+                return $this->_getPrototypeProperty($name);
             break;
         }
     }
@@ -107,9 +107,9 @@ 
         // get public properties only, so use closure to escape local scope.
         // the anonymous function / closure is needed to make sure that get_object_vars
         // only returns public properties.
-        return ( is_object( $this->prototype )
-            ? array_merge( $this->prototype->properties, $this->_getLocalProperties() )
-            : $this->_getLocalProperties() );
+        return (is_object($this->prototype)
+            ? array_merge($this->prototype->properties, $this->_getLocalProperties())
+            : $this->_getLocalProperties());
     }
 
     /**
@@ -121,7 +121,7 @@ 
         //$getLocalProperties = \Closure::bind(function ($o) {
         //    return get_object_vars($o);
         //}, new dummy(), new dummy());
-        return [ 'prototype' => $this->prototype ] + $this->_ownProperties;
+        return ['prototype' => $this->prototype] + $this->_ownProperties;
     }
 
     /**
@@ -131,23 +131,23 @@ 
      */
     private function _getPrototypeProperty($name)
     {
-        if (is_object( $this->prototype )) {
+        if (is_object($this->prototype)) {
             // cache prototype access per property - allows fast but partial cache purging
-            if (!array_key_exists( $name, self::$properties )) {
-                self::$properties[ $name ] = new \SplObjectStorage();
+            if (!array_key_exists($name, self::$properties)) {
+                self::$properties[$name] = new \SplObjectStorage();
             }
-            if (!self::$properties[$name]->contains( $this->prototype )) {
+            if (!self::$properties[$name]->contains($this->prototype)) {
                 $property = $this->prototype->{$name};
-                if ( $property instanceof \Closure ) {
-                    if ( !array_key_exists($name, $this->prototype->_staticMethods)) {
-                        $property = $this->_bind( $property );
+                if ($property instanceof \Closure) {
+                    if (!array_key_exists($name, $this->prototype->_staticMethods)) {
+                        $property = $this->_bind($property);
                     } else {
                         $this->_staticMethods[$name] = true;
                     }
                 }
-                self::$properties[$name][ $this->prototype ] = $property;
+                self::$properties[$name][$this->prototype] = $property;
             }
-            return self::$properties[$name][ $this->prototype ];
+            return self::$properties[$name][$this->prototype];
         } else {
             return null;
         }
@@ -159,10 +159,10 @@ 
      */
     public function __set($name, $value)
     {
-        if (!in_array( $name, [ 'prototype', 'properties' ] )) {
+        if (!in_array($name, ['prototype', 'properties'])) {
             $observers = \arc\prototype::getObservers($this);
             $continue = true;
-            foreach($observers as $observer) {
+            foreach ($observers as $observer) {
                 $result = $observer($this, $name, $value);
                 if ($result === false) {
                     $continue = false;
@@ -170,13 +170,13 @@ 
             }
             if ($continue) {
                 if (!array_key_exists($name, $this->_staticMethods)) {
-                    $this->_ownProperties[$name] = $this->_bind( $value );
+                    $this->_ownProperties[$name] = $this->_bind($value);
                 } else {
                     $this->_ownProperties[$name] = $value;
                 }
                 // purge prototype cache for this property - this will clear too much but cache will be filled again
                 // clearing exactly the right entries from the cache will generally cost more performance than this
-                unset( self::$properties[ $name ] );
+                unset(self::$properties[$name]);
             }
         }
     }
@@ -187,19 +187,19 @@ 
      */
     public function __isset($name)
     {
-        $val = $this->_getPrototypeProperty( $name );
+        $val = $this->_getPrototypeProperty($name);
 
-        return isset( $val );
+        return isset($val);
     }
 
     /**
      * @param $name
      */
     public function __unset($name) {
-        if (!in_array( $name, [ 'prototype', 'properties' ] )) {
+        if (!in_array($name, ['prototype', 'properties'])) {
             $observers = \arc\prototype::getObservers($this);
             $continue = true;
-            foreach($observers as $observer) {
+            foreach ($observers as $observer) {
                 $result = $observer($this, $name, null);
                 if ($result === false) {
                     $continue = false;
@@ -212,7 +212,7 @@ 
                 unset($this->_ownProperties[$name]);
                 // purge prototype cache for this property - this will clear too much but cache will be filled again
                 // clearing exactly the right entries from the cache will generally cost more performance than this
-                unset( self::$properties[ $name ] );
+                unset(self::$properties[$name]);
             }
         }
     }
@@ -223,7 +223,7 @@ 
     public function __destruct()
     {
     	\arc\prototype::_destroy($this);
-        return $this->_tryToCall( $this->__destruct );
+        return $this->_tryToCall($this->__destruct);
     }
 
     /**
@@ -231,7 +231,7 @@ 
      */
     public function __toString()
     {
-        return $this->_tryToCall( $this->__toString );
+        return $this->_tryToCall($this->__toString);
     }
 
     /**
@@ -240,10 +240,10 @@ 
      */
     public function __invoke()
     {
-        if (is_callable( $this->__invoke )) {
-            return call_user_func_array( $this->__invoke, func_get_args() );
+        if (is_callable($this->__invoke)) {
+            return call_user_func_array($this->__invoke, func_get_args());
         } else {
-            throw new \arc\ExceptionMethodNotFound( 'No __invoke method found in this Object', \arc\exceptions::OBJECT_NOT_FOUND );
+            throw new \arc\ExceptionMethodNotFound('No __invoke method found in this Object', \arc\exceptions::OBJECT_NOT_FOUND);
         }
     }
 
@@ -253,10 +253,10 @@ 
     public function __clone()
     {
         // make sure all methods are bound to $this - the new clone.
-        foreach (get_object_vars( $this ) as $property) {
-            $this->{$property} = $this->_bind( $property );
+        foreach (get_object_vars($this) as $property) {
+            $this->{$property} = $this->_bind($property);
         }
-        $this->_tryToCall( $this->__clone );
+        $this->_tryToCall($this->__clone);
     }
 
     /**
@@ -266,9 +266,9 @@ 
      */
     private function _bind($property)
     {
-        if ($property instanceof \Closure ) {
+        if ($property instanceof \Closure) {
             // make sure any internal $this references point to this object and not the prototype or undefined
-            return \Closure::bind( $property, $this );
+            return \Closure::bind($property, $this);
         }
 
         return $property;
@@ -282,8 +282,8 @@ 
      */
     private function _tryToCall($f, $args = [])
     {
-        if (is_callable( $f )) {
-            return call_user_func_array( $f, $args );
+        if (is_callable($f)) {
+            return call_user_func_array($f, $args);
         }
     }
 }