Recent changes to Home

WikiPage Home modified by James Watts

James Watts — Wed, 04 Apr 2012 21:11:39 -0000

--- v8 
+++ v9 
@@ -95,7 +95,7 @@
 
 The callback for a routine can be any value considered by PHP as [callable](http://www.php.net/manual/en/language.types.callable.php). The callback for the **Routine** receives the arguments passed to the method.
 
-A routine can also optionally define a **PreCondition** and a **PostCondition**. These are executed before and after the routine's callback. These validators use **setHandler( callable $callback )** for the callback to execute when called, which should return a boolean value. In the case when *false* is returned by the **PreCondition** callback the routine will not execute, and a **PreConditionException** will be thrown. And in the case when "false" is returned by the **PostCondition** callback, the object will be returned to it's last state before the execution of the routine, and a **PostConditionException** will be thrown.
+A routine can also optionally define a **PreCondition** and a **PostCondition**. These are executed before and after the routine's callback. These validators use **setHandler( callable $callback )** for the callback to execute when called, which should return a boolean value. In the case when *false* is returned by the **PreCondition** callback the routine will not execute, and a **PreConditionException** will be thrown. And in the case when *false* is returned by the **PostCondition** callback, the object will be returned to it's last state before the execution of the routine, and a **PostConditionException** will be thrown.
 
     $preCondition = new PreCondition();
     $preCondition->setHandler( function( $object, $arguments ) {

WikiPage Home modified by James Watts

James Watts — Wed, 04 Apr 2012 21:02:21 -0000

--- v7 
+++ v8 
@@ -93,7 +93,7 @@
 

 If an argument is passed to the routine but is not of the data type specified by the routine in the arguments array, an **InvalidArgumentTypeException** will be thrown. Also, if a number of arguments is passed to the routine which is less than the number expected by the routine, defined by the length of the arguments array, a **MissingRequiredArgumentsException** will be thrown.
 
-The callback for a routine can be any value considered by PHP as [callable](http://www.php.net/manual/en/language.types.callable.php). The callback for the **Routine** receives 2 arguments, the object and the arguments passed.
+The callback for a routine can be any value considered by PHP as [callable](http://www.php.net/manual/en/language.types.callable.php). The callback for the **Routine** receives the arguments passed to the method.
 
 A routine can also optionally define a **PreCondition** and a **PostCondition**. These are executed before and after the routine's callback. These validators use **setHandler( callable $callback )** for the callback to execute when called, which should return a boolean value. In the case when *false* is returned by the **PreCondition** callback the routine will not execute, and a **PreConditionException** will be thrown. And in the case when "false" is returned by the **PostCondition** callback, the object will be returned to it's last state before the execution of the routine, and a **PostConditionException** will be thrown.

WikiPage Home modified by James Watts

James Watts — Wed, 04 Apr 2012 20:47:41 -0000

--- v6 
+++ v7 
@@ -116,6 +116,14 @@
     $this->__routine( $routine );
 
 

-Finally, the **Contract** class provides an **__invariant( void )** magic method. This method is called internally after every routine execution. The purpose of this method is to ensure the object is in a coherent state, and has not been corrupted. This method should return a boolean value. In the case when *false* is returned, the object will be returned to it's last state before the execution of the routine, and an **InvariantException** will be thrown.
+Finally, the **Contract** class provides an **__invariant( void )** magic method. This method is called internally after every routine execution. The purpose of this method is to ensure the object is in a coherent state, and has not been corrupted.
+
+    public function __invariant()
+    {
+        // check object state
+    }
+
+

+This method should return a boolean value. In the case when *false* is returned, the object will be returned to it's last state before the execution of the routine, and an **InvariantException** will be thrown.
 
 All exceptions related to the PHP Design by Contract package extend the **ContractException** class.

WikiPage Home modified by James Watts

James Watts — Wed, 04 Apr 2012 20:46:08 -0000

--- v5 
+++ v6 
@@ -103,9 +103,7 @@
     } );
 
     $postCondition = new PostCondition();
-    $postCondition->setHandler( function( $object, $return ) {
-        return true;
-    } );
+    $postCondition->setHandler( array( $this, 'testPostCondition' ) );
 
     $routine->setPreCondition( $preCondition );
     $routine->setPostCondition( $postCondition );

WikiPage Home modified by James Watts

James Watts — Wed, 04 Apr 2012 20:44:44 -0000

--- v4 
+++ v5 
@@ -3,121 +3,121 @@
 
 **PHP Design by Contract** provides a basic implementation of contract programming for PHP 5.3+ with namespaces.
 
-The base **Contract** class allows new or existing classes to define properties as protected **Attributes** and methods as **Routines**, which require argument type/class validation, aswell as **PreCondition** and **PostCondition** checks. Instances can also check for state consistency with an invariant check.
-
-Using the Contract helps maintain object access coherent by applying a command/query separation when accessing or modifying the instance.
-
+The base **Contract** class allows new or existing classes to define properties as protected **Attributes** and methods as **Routines**, which require argument type/class validation, aswell as **PreCondition** and **PostCondition** checks. Instances can also test for state consistency with an invariant check.
+
 Installation
 ------------
 
 To use the package it's highly recommended to use a [PSR-0](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-0.md) compatible autoloader for required classes.
 
 You can find a fully compatible autoloader here: [PHP AutoLoad](https://sourceforge.net/p/php-autoload)
 
 Once you've unpacked the files into your include path the package is ready for use.
 
 Configuration
 -------------
 
 This package does not require any pre-configuration.
 
 Implementation
 --------------
 
 To use the base **Contract** class simply extend it with a new or existing class, for example:
 
     class Person extends Contract {
         
         // class members are defined here
     }
 
 

-When extending the **Contract** class certain magic methods become available. The first of these methods is **__create()**. This method behaves as a constructor function for the instance object.
+When extending the **Contract** class certain magic methods become available. The first of these methods is **__create( void )**. This method behaves as a constructor function for the instance object.
 
     public function __create()
     {
         // object is defined here
     }
 
 

-To define the **Attributes** (properties) and **Routines** (functions) available for this object there are 2 additional magic method, **__attribute()** and **__routine()**.
-
-The **Attribute** class defines a property for the object, using **setName()** for the name of the property, **setType()** for the data type stored in the property, and **setValue()** for the default value of the property, for example:
+To define the **Attributes** (properties) and **Routines** (methods) available for this object there are 2 additional magic methods, **__attribute( Attribute $attribute )** and **__routine( Routine $routine )**.
+
+The **Attribute** class defines a property for the object, using **setName( string $name )** for the name of the property, **setType( int $type )** for the data type stored in the property, and **setValue( mixed $value )** for the default value of the property, for example:
 
     $attribute = new Attribute();
     $attribute->setName( 'example' );
     $attribute->setType( DataTypes::TYPE_STRING );
     $attribute->setValue( 'Hello World' );
     
 

 Only the routine of the same object can modify an attribute. If a routine of another object attempts to modify an attribute an **IllegalAttributeAccessException** will be thrown. Additionally, if the data type of the value being set to the attribute is not the same as the type defined by the attribute an **InvalidAttributeTypeException** will be thrown.
 
 Once the attribute has been defined it can be registered on the object.
 
     $this->__attribute( $attribute );
 
 

 The **DataTypes** class defines the data types available as the following constants:
 
 - **TYPE_NULL:** A discriminated null value
 - **TYPE_BOOLEAN:** A boolean logical value
 - **TYPE_NUMERIC:** A valid numeric value
 - **TYPE_INTEGER:** A whole number
 - **TYPE_DOUBLE:** A double precision floating point number
 - **TYPE_STRING:** A string of characters
 - **TYPE_ARRAY:** An array of values *(keys permitted)*
 - **TYPE_OBJECT:** An object
 - **TYPE_LAMBDA:** An instance of **Closure**
 - **TYPE_RESOURCE:** An external PHP resource
 
-A routine can be either a *procedure*, or a *function*. The difference between these types is that a procedure is used to modify the state of an object, but does not return a value, whilst a function is used to access the object and return a value, but not modify it's state. This concept is called *command/query spearation*.
-
-The **Routine** class defines a method for the object, using **setName()** for the name of the method, **setType()** for the type of the routine, **setArguments()** for the validation of the data types of the arguments expected and recieved by the method, and **setHandler()** for the callback to execute when called, for example:
+A routine can be either a *procedure* or a *function*. The difference between these types is that a *procedure* is used to modify the state of an object, but does not return a value, whilst a *function* is used to access the object and return a value, but not modify it's state. This concept is called *command/query spearation*.
+
+The **Routine** class defines a method for the object, using **setName( string $name )** for the name of the method, **setType( int $type )** for the type of the routine, **setArguments( array $arguments )** for the validation of the data types of the arguments expected and recieved by the method, and **setHandler( callable $callback )** for the callback to execute when called, for example:
 
     $routine = new Routine();
     $routine->setName( 'test' );
     $routine->setType( Routine::TYPE_PROCEDURE );
     $routine->setArguments( array(
         DataTypes::TYPE_NULL,
         DataTypes::TYPE_BOOLEAN,
         DataTypes::TYPE_NUMERIC,
         DataTypes::TYPE_INTEGER,
         DataTypes::TYPE_DOUBLE,
         DataTypes::TYPE_STRING,
         DataTypes::TYPE_ARRAY,
         DataTypes::TYPE_OBJECT,
         DataTypes::TYPE_LAMBDA,
         DataTypes::TYPE_RESOURCE,
         'Test\MyContract'
     ) );
     $routine->setHandler( array( $this, 'testRoutine' ) );
 
 

-If an argument is passed to the routine but is not of the data type specified by the routine with the arguments array, an **InvalidArgumentTypeException** will be thrown. Also, if a number of arguments is passed to the routine which is less than the number expected by the routine, defined by the length of the arguments array, a **MissingRequiredArgumentsException** will be thrown.
-
-The callback for a routine can be any value considered by PHP as [callable](http://www.php.net/manual/en/language.types.callable.php).
-
-A routine can also optionally define a **PreCondition** and a **PostCondition**. These are executed before and after the routine's callback. These validators should return a boolean value. In the case when *false* is returned by the **PreCondition** callback the routine will not execute and a **PreConditionException** will be thrown. And in the case when "false" is returned by the **PostCondition** callback, the object will be returned to it's last state before the execution of the routine, and a **PostConditionException** will be thrown.
+If an argument is passed to the routine but is not of the data type specified by the routine in the arguments array, an **InvalidArgumentTypeException** will be thrown. Also, if a number of arguments is passed to the routine which is less than the number expected by the routine, defined by the length of the arguments array, a **MissingRequiredArgumentsException** will be thrown.
+
+The callback for a routine can be any value considered by PHP as [callable](http://www.php.net/manual/en/language.types.callable.php). The callback for the **Routine** receives 2 arguments, the object and the arguments passed.
+
+A routine can also optionally define a **PreCondition** and a **PostCondition**. These are executed before and after the routine's callback. These validators use **setHandler( callable $callback )** for the callback to execute when called, which should return a boolean value. In the case when *false* is returned by the **PreCondition** callback the routine will not execute, and a **PreConditionException** will be thrown. And in the case when "false" is returned by the **PostCondition** callback, the object will be returned to it's last state before the execution of the routine, and a **PostConditionException** will be thrown.
 
     $preCondition = new PreCondition();
-    $preCondition->setHandler( array( $this, 'testPreCondition' ) );
+    $preCondition->setHandler( function( $object, $arguments ) {
+        return true;
+    } );
 
     $postCondition = new PostCondition();
-    $postCondition->setHandler( function( $object, $arguments ) {
+    $postCondition->setHandler( function( $object, $return ) {
         return true;
     } );
 
     $routine->setPreCondition( $preCondition );
     $routine->setPostCondition( $postCondition );
 
 

-The callbacks for a conditions can be any value considered by PHP as [callable](http://www.php.net/manual/en/language.types.callable.php).
+The callbacks for a conditions can be any value considered by PHP as [callable](http://www.php.net/manual/en/language.types.callable.php). The callback for the **PreCondition** receives 2 arguments, the object and the arguments passed to the routine, whilst the callback for the **PostCondition** callback also receives 2 arguments, except the second argument is the return value of the routine.
 
 Once the routine has been defined it can be registered on the object.
 
     $this->__routine( $routine );
 
 

-Finally, the **Contract** class provides an **__invariant()** magic method. This method is called internally after every routine execution. The purpose of this method is to ensure the object is in a coherent state, and has not been corrupted. This method should return a boolean value. In the case when *false* is returned, the object will be returned to it's last state before the execution of the routine, and an **InvariantException** will be thrown.
+Finally, the **Contract** class provides an **__invariant( void )** magic method. This method is called internally after every routine execution. The purpose of this method is to ensure the object is in a coherent state, and has not been corrupted. This method should return a boolean value. In the case when *false* is returned, the object will be returned to it's last state before the execution of the routine, and an **InvariantException** will be thrown.
 
 All exceptions related to the PHP Design by Contract package extend the **ContractException** class.

WikiPage Home modified by James Watts

James Watts — Wed, 04 Apr 2012 20:26:57 -0000

--- v3 
+++ v4 
@@ -50,61 +50,74 @@
     $attribute->setValue( 'Hello World' );
     
 

+Only the routine of the same object can modify an attribute. If a routine of another object attempts to modify an attribute an **IllegalAttributeAccessException** will be thrown. Additionally, if the data type of the value being set to the attribute is not the same as the type defined by the attribute an **InvalidAttributeTypeException** will be thrown.
+
 Once the attribute has been defined it can be registered on the object.
 
     $this->__attribute( $attribute );
 
 

 The **DataTypes** class defines the data types available as the following constants:
 
 - **TYPE_NULL:** A discriminated null value
 - **TYPE_BOOLEAN:** A boolean logical value
 - **TYPE_NUMERIC:** A valid numeric value
 - **TYPE_INTEGER:** A whole number
 - **TYPE_DOUBLE:** A double precision floating point number
 - **TYPE_STRING:** A string of characters
 - **TYPE_ARRAY:** An array of values *(keys permitted)*
 - **TYPE_OBJECT:** An object
 - **TYPE_LAMBDA:** An instance of **Closure**
 - **TYPE_RESOURCE:** An external PHP resource
 
 A routine can be either a *procedure*, or a *function*. The difference between these types is that a procedure is used to modify the state of an object, but does not return a value, whilst a function is used to access the object and return a value, but not modify it's state. This concept is called *command/query spearation*.
 
 The **Routine** class defines a method for the object, using **setName()** for the name of the method, **setType()** for the type of the routine, **setArguments()** for the validation of the data types of the arguments expected and recieved by the method, and **setHandler()** for the callback to execute when called, for example:
 
     $routine = new Routine();
     $routine->setName( 'test' );
     $routine->setType( Routine::TYPE_PROCEDURE );
     $routine->setArguments( array(
         DataTypes::TYPE_NULL,
         DataTypes::TYPE_BOOLEAN,
         DataTypes::TYPE_NUMERIC,
         DataTypes::TYPE_INTEGER,
         DataTypes::TYPE_DOUBLE,
         DataTypes::TYPE_STRING,
         DataTypes::TYPE_ARRAY,
         DataTypes::TYPE_OBJECT,
         DataTypes::TYPE_LAMBDA,
         DataTypes::TYPE_RESOURCE,
         'Test\MyContract'
     ) );
-    $routine->setHandler( array( $this, 'test_callback' ) );
-
-

-A routine can also optionally define a **PreCondition** and a **PostCondition**. These are executed before and after the routine's callback.
-
-    $preCondition = new PreCondition( array( $this, 'validate' ) );
-
-    $postCondition = new PostCondition( function( $object, $arguments ) {
+    $routine->setHandler( array( $this, 'testRoutine' ) );
+
+

+If an argument is passed to the routine but is not of the data type specified by the routine with the arguments array, an **InvalidArgumentTypeException** will be thrown. Also, if a number of arguments is passed to the routine which is less than the number expected by the routine, defined by the length of the arguments array, a **MissingRequiredArgumentsException** will be thrown.
+
+The callback for a routine can be any value considered by PHP as [callable](http://www.php.net/manual/en/language.types.callable.php).
+
+A routine can also optionally define a **PreCondition** and a **PostCondition**. These are executed before and after the routine's callback. These validators should return a boolean value. In the case when *false* is returned by the **PreCondition** callback the routine will not execute and a **PreConditionException** will be thrown. And in the case when "false" is returned by the **PostCondition** callback, the object will be returned to it's last state before the execution of the routine, and a **PostConditionException** will be thrown.
+
+    $preCondition = new PreCondition();
+    $preCondition->setHandler( array( $this, 'testPreCondition' ) );
+
+    $postCondition = new PostCondition();
+    $postCondition->setHandler( function( $object, $arguments ) {
         return true;
     } );
 
     $routine->setPreCondition( $preCondition );
     $routine->setPostCondition( $postCondition );
 
 

+The callbacks for a conditions can be any value considered by PHP as [callable](http://www.php.net/manual/en/language.types.callable.php).
+
 Once the routine has been defined it can be registered on the object.
 
     $this->__routine( $routine );
 
-Finally, the **Contract** class .
+

+Finally, the **Contract** class provides an **__invariant()** magic method. This method is called internally after every routine execution. The purpose of this method is to ensure the object is in a coherent state, and has not been corrupted. This method should return a boolean value. In the case when *false* is returned, the object will be returned to it's last state before the execution of the routine, and an **InvariantException** will be thrown.
+
+All exceptions related to the PHP Design by Contract package extend the **ContractException** class.

WikiPage Home modified by James Watts

James Watts — Wed, 04 Apr 2012 19:59:12 -0000

--- v2 
+++ v3 
@@ -19,38 +19,92 @@
 Configuration
 -------------
 
-This package does not require any preconfiguration.
-
-Implementation:
----------------
-
+This package does not require any pre-configuration.
+
+Implementation
+--------------
+
 To use the base **Contract** class simply extend it with a new or existing class, for example:
 
     class Person extends Contract {
         
         // class members are defined here
     }
 
 

 When extending the **Contract** class certain magic methods become available. The first of these methods is **__create()**. This method behaves as a constructor function for the instance object.
 
     public function __create()
     {
         // object is defined here
     }
 
 

 To define the **Attributes** (properties) and **Routines** (functions) available for this object there are 2 additional magic method, **__attribute()** and **__routine()**.
 
-The **Attribute** class defines a property for the object, using the **setName()** for the name of the property, **setType()** for the data type stored in the property, and **setValue()** for the default value of the property, for example:
-
-    $example = new Attribute();
-    $example->setName( 'example' );
-    $example->setType( DataTypes::TYPE_STRING );
-    $example->setValue( 'Hello World' );
+The **Attribute** class defines a property for the object, using **setName()** for the name of the property, **setType()** for the data type stored in the property, and **setValue()** for the default value of the property, for example:
+
+    $attribute = new Attribute();
+    $attribute->setName( 'example' );
+    $attribute->setType( DataTypes::TYPE_STRING );
+    $attribute->setValue( 'Hello World' );
     
 

+Once the attribute has been defined it can be registered on the object.
+
+    $this->__attribute( $attribute );
+
+

 The **DataTypes** class defines the data types available as the following constants:
 
-- **TYPE_NULL:** A Null value
-- ****
+- **TYPE_NULL:** A discriminated null value
+- **TYPE_BOOLEAN:** A boolean logical value
+- **TYPE_NUMERIC:** A valid numeric value
+- **TYPE_INTEGER:** A whole number
+- **TYPE_DOUBLE:** A double precision floating point number
+- **TYPE_STRING:** A string of characters
+- **TYPE_ARRAY:** An array of values *(keys permitted)*
+- **TYPE_OBJECT:** An object
+- **TYPE_LAMBDA:** An instance of **Closure**
+- **TYPE_RESOURCE:** An external PHP resource
+
+A routine can be either a *procedure*, or a *function*. The difference between these types is that a procedure is used to modify the state of an object, but does not return a value, whilst a function is used to access the object and return a value, but not modify it's state. This concept is called *command/query spearation*.
+
+The **Routine** class defines a method for the object, using **setName()** for the name of the method, **setType()** for the type of the routine, **setArguments()** for the validation of the data types of the arguments expected and recieved by the method, and **setHandler()** for the callback to execute when called, for example:
+
+    $routine = new Routine();
+    $routine->setName( 'test' );
+    $routine->setType( Routine::TYPE_PROCEDURE );
+    $routine->setArguments( array(
+        DataTypes::TYPE_NULL,
+        DataTypes::TYPE_BOOLEAN,
+        DataTypes::TYPE_NUMERIC,
+        DataTypes::TYPE_INTEGER,
+        DataTypes::TYPE_DOUBLE,
+        DataTypes::TYPE_STRING,
+        DataTypes::TYPE_ARRAY,
+        DataTypes::TYPE_OBJECT,
+        DataTypes::TYPE_LAMBDA,
+        DataTypes::TYPE_RESOURCE,
+        'Test\MyContract'
+    ) );
+    $routine->setHandler( array( $this, 'test_callback' ) );
+
+

+A routine can also optionally define a **PreCondition** and a **PostCondition**. These are executed before and after the routine's callback.
+
+    $preCondition = new PreCondition( array( $this, 'validate' ) );
+
+    $postCondition = new PostCondition( function( $object, $arguments ) {
+        return true;
+    } );
+
+    $routine->setPreCondition( $preCondition );
+    $routine->setPostCondition( $postCondition );
+
+

+Once the routine has been defined it can be registered on the object.
+
+    $this->__routine( $routine );
+
+Finally, the **Contract** class .

WikiPage Home modified by James Watts

James Watts — Wed, 04 Apr 2012 17:28:26 -0000

--- v1 
+++ v2 
@@ -1,8 +1,56 @@
-Welcome to your wiki!
-
-This is the default page, edit it as you see fit. To add a new page simply reference it within brackets, e.g.: [SamplePage].
-
-The wiki uses [Markdown](/p/php-contract/wiki/markdown_syntax/) syntax.
-
-[[project_admins]]
-[[download_button]]
+PHP Design by Contract
+======================
+
+**PHP Design by Contract** provides a basic implementation of contract programming for PHP 5.3+ with namespaces.
+
+The base **Contract** class allows new or existing classes to define properties as protected **Attributes** and methods as **Routines**, which require argument type/class validation, aswell as **PreCondition** and **PostCondition** checks. Instances can also check for state consistency with an invariant check.
+
+Using the Contract helps maintain object access coherent by applying a command/query separation when accessing or modifying the instance.
+
+Installation
+------------
+
+To use the package it's highly recommended to use a [PSR-0](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-0.md) compatible autoloader for required classes.
+
+You can find a fully compatible autoloader here: [PHP AutoLoad](https://sourceforge.net/p/php-autoload)
+
+Once you've unpacked the files into your include path the package is ready for use.
+
+Configuration
+-------------
+
+This package does not require any preconfiguration.
+
+Implementation:
+---------------
+
+To use the base **Contract** class simply extend it with a new or existing class, for example:
+
+    class Person extends Contract {
+        
+        // class members are defined here
+    }
+
+

+When extending the **Contract** class certain magic methods become available. The first of these methods is **__create()**. This method behaves as a constructor function for the instance object.
+
+    public function __create()
+    {
+        // object is defined here
+    }
+
+

+To define the **Attributes** (properties) and **Routines** (functions) available for this object there are 2 additional magic method, **__attribute()** and **__routine()**.
+
+The **Attribute** class defines a property for the object, using the **setName()** for the name of the property, **setType()** for the data type stored in the property, and **setValue()** for the default value of the property, for example:
+
+    $example = new Attribute();
+    $example->setName( 'example' );
+    $example->setType( DataTypes::TYPE_STRING );
+    $example->setValue( 'Hello World' );
+    
+

+The **DataTypes** class defines the data types available as the following constants:
+
+- **TYPE_NULL:** A Null value
+- ****

WikiPage Home modified by James Watts

James Watts — Sat, 24 Mar 2012 14:02:56 -0000

Welcome to your wiki! This is the default page, edit it as you see fit. To add a new page simply reference it within brackets, e.g.: [SamplePage]. The wiki uses [Markdown](/p/php-contract/wiki/markdown_syntax/) syntax. [[project_admins]] [[download_button]]