Rework tests (#85)

I've did a review of the lib and did some cleanup, tweaks and added missing tests.

- Bumped minimal version to PHP 5.6.
- Fixed the PHPUnit config to exclude `deep_copy.php` from the coverage report
- Fixed a bug when using `useCloneMethod`: the old object was returned unchanged instead of returning the cloned object
- Make the coverage stricter by adding the `@covers` annotations
- Add missing tests
- Cosmetic cleanup

Author: theofidry

.travis.yml

@@ -3,7 +3,6 @@ language: php
 sudo: false
 
 php:
-  - '5.5'
   - '5.6'
   - '7.0'
   - '7.1'
@@ -12,7 +11,7 @@ php:
 matrix:
   fast_finish: true
   include:
-    - php: '5.4'
+    - php: '5.6'
       env: COMPOSER_FLAGS="--prefer-lowest"
   allow_failures:
     - php: nightly
@@ -23,7 +22,7 @@ cache:
 
 before_install:
   - |
-    if [ "$TRAVIS_PHP_VERSION" = "nightly" ] || "$TRAVIS_PHP_VERSION" = "7.1" ]; then
+    if [ "$TRAVIS_PHP_VERSION" = "nightly" ]; then
       COMPOSER_FLAGS="$COMPOSER_FLAGS --ignore-platform-reqs"
     fi;
 

README.md

@@ -20,15 +20,17 @@ DeepCopy helps you create deep copies (clones) of your objects. It is designed t
         1. [Specific property](#specific-property)
         1. [Type](#type)
     1. [Filters](#filters)
-        1. [`SetNullFilter`](#setnullfilter)
-        1. [`KeepFilter`](#keepfilter)
-        1. [`ReplaceFilter`](#replacefilter)
-        1. [`ShallowCopyFilter`](#doctrinecollectionfilter)
-        1. [`DoctrineCollectionFilter`](#doctrinecollectionfilter)
-        1. [`DoctrineEmptyCollectionFilter`](#doctrineemptycollectionfilter)
+        1. [`SetNullFilter`](#setnullfilter-filter)
+        1. [`KeepFilter`](#keepfilter-filter)
+        1. [`DoctrineCollectionFilter`](#doctrinecollectionfilter-filter)
+        1. [`DoctrineEmptyCollectionFilter`](#doctrineemptycollectionfilter-filter)
+        1. [`DoctrineProxyFilter`](#doctrineproxyfilter-filter)
+        1. [`ReplaceFilter`](#replacefilter-type-filter)
+        1. [`ShallowCopyFilter`](#doctrinecollectionfilter-type-filter)
 1. [Contributing](#contributing)
     1. [Tests](#tests)
 
+
 ## How?
 
 Install with Composer:
@@ -65,22 +67,27 @@ Now you're in for a big mess :(
 
 ![association graph](doc/graph.png)
 
+
 ### Using simply `clone`
 
 ![Using clone](doc/clone.png)
 
+
 ### Overridding `__clone()`
 
 ![Overridding __clone](doc/deep-clone.png)
 
+
 ### With `DeepCopy`
 
 ![With DeepCopy](doc/deep-copy.png)
 
+
 ## How it works
 
 DeepCopy recursively traverses all the object's properties and clones them. To avoid cloning the same object twice it keeps a hash map of all instances and thus preserves the object graph.
 
+
 ## Going further
 
 You can add filters to customize the copy process.
@@ -91,11 +98,13 @@ and `$matcher` implementing `DeepCopy\Matcher\Matcher`.
 
 We provide some generic filters and matchers.
 
+
 ### Matchers
 
   - `DeepCopy\Matcher` applies on a object attribute.
   - `DeepCopy\TypeMatcher` applies on any element found in graph, including array elements.
 
+
 #### Property name
 
 The `PropertyNameMatcher` will match a property by its name:
@@ -107,6 +116,7 @@ $matcher = new PropertyNameMatcher('id');
 // will apply a filter to any property of any objects named "id"
 ```
 
+
 #### Specific property
 
 The `PropertyMatcher` will match a specific property of a specific class:
@@ -118,6 +128,7 @@ $matcher = new PropertyMatcher('MyClass', 'id');
 // will apply a filter to the property "id" of any objects of the class "MyClass"
 ```
 
+
 #### Type
 
 The `TypeMatcher` will match any element by its type (instance of a class or any value that could be parameter of [gettype()](http://php.net/manual/en/function.gettype.php) function):
@@ -129,12 +140,14 @@ $matcher = new TypeMatcher('Doctrine\Common\Collections\Collection');
 // will apply a filter to any object that is an instance of Doctrine\Common\Collections\Collection
 ```
 
+
 ### Filters
 
   - `DeepCopy\Filter` applies a transformation to the object attribute matched by `DeepCopy\Matcher`.
   - `DeepCopy\TypeFilter` applies a transformation to any element matched by `DeepCopy\TypeMatcher`.
 
-#### `SetNullFilter`
+
+#### `SetNullFilter` (filter)
 
 Let's say for example that you are copying a database record (or a Doctrine entity), so you want the copy not to have any ID:
 
@@ -153,7 +166,8 @@ $myCopy = $deepCopy->copy($myObject);
 echo $myCopy->id; // null
 ```
 
-#### `KeepFilter`
+
+#### `KeepFilter` (filter)
 
 If you want a property to remain untouched (for example, an association to an object):
 
@@ -169,7 +183,60 @@ $myCopy = $deepCopy->copy($myObject);
 // $myCopy->category has not been touched
 ```
 
-#### `ReplaceFilter`
+
+#### `DoctrineCollectionFilter` (filter)
+
+If you use Doctrine and want to copy an entity, you will need to use the `DoctrineCollectionFilter`:
+
+```php
+use DeepCopy\DeepCopy;
+use DeepCopy\Filter\Doctrine\DoctrineCollectionFilter;
+use DeepCopy\Matcher\PropertyTypeMatcher;
+
+$deepCopy = new DeepCopy();
+$deepCopy->addFilter(new DoctrineCollectionFilter(), new PropertyTypeMatcher('Doctrine\Common\Collections\Collection'));
+$myCopy = $deepCopy->copy($myObject);
+```
+
+
+#### `DoctrineEmptyCollectionFilter` (filter)
+
+If you use Doctrine and want to copy an entity who contains a `Collection` that you want to be reset, you can use the `DoctrineEmptyCollectionFilter`
+
+```php
+use DeepCopy\DeepCopy;
+use DeepCopy\Filter\Doctrine\DoctrineEmptyCollectionFilter;
+use DeepCopy\Matcher\PropertyMatcher;
+
+$deepCopy = new DeepCopy();
+$deepCopy->addFilter(new DoctrineEmptyCollectionFilter(), new PropertyMatcher('MyClass', 'myProperty'));
+$myCopy = $deepCopy->copy($myObject);
+
+// $myCopy->myProperty will return an empty collection
+```
+
+
+#### `DoctrineProxyFilter` (filter)
+
+If you use Doctrine and use cloning on lazy loaded entities, you might encounter errors mentioning missing fields on a
+Doctrine proxy class (...\\\_\_CG\_\_\Proxy).
+You can use the `DoctrineProxyFilter` to load the actual entity behind the Doctrine proxy class.
+**Make sure, though, to put this as one of your very first filters in the filter chain so that the entity is loaded before other filters are applied!**
+
+```php
+use DeepCopy\DeepCopy;
+use DeepCopy\Filter\Doctrine\DoctrineProxyFilter;
+use DeepCopy\Matcher\Doctrine\DoctrineProxyMatcher;
+
+$deepCopy = new DeepCopy();
+$deepCopy->addFilter(new DoctrineProxyFilter(), new DoctrineProxyMatcher());
+$myCopy = $deepCopy->copy($myObject);
+
+// $myCopy should now contain a clone of all entities, including those that were not yet fully loaded.
+```
+
+
+#### `ReplaceFilter` (type filter)
 
   1. If you want to replace the value of a property:
 
@@ -208,7 +275,8 @@ $myCopy = $deepCopy->copy($myObject);
 
 The `$callback` parameter of the `ReplaceFilter` constructor accepts any PHP callable.
 
-#### `ShallowCopyFilter`
+
+#### `ShallowCopyFilter` (type filter)
 
 Stop *DeepCopy* from recursively copying element, using standard `clone` instead:
 
@@ -228,59 +296,12 @@ $myServiceWithMocks = new MyService(m::mock(MyDependency1::class), m::mock(MyDep
 // all mocks will be just cloned, not deep-copied
 ```
 
-#### `DoctrineCollectionFilter`
-
-If you use Doctrine and want to copy an entity, you will need to use the `DoctrineCollectionFilter`:
-
-```php
-use DeepCopy\DeepCopy;
-use DeepCopy\Filter\Doctrine\DoctrineCollectionFilter;
-use DeepCopy\Matcher\PropertyTypeMatcher;
-
-$deepCopy = new DeepCopy();
-$deepCopy->addFilter(new DoctrineCollectionFilter(), new PropertyTypeMatcher('Doctrine\Common\Collections\Collection'));
-$myCopy = $deepCopy->copy($myObject);
-```
-
-#### `DoctrineEmptyCollectionFilter`
-
-If you use Doctrine and want to copy an entity who contains a `Collection` that you want to be reset, you can use the `DoctrineEmptyCollectionFilter`
-
-```php
-use DeepCopy\DeepCopy;
-use DeepCopy\Filter\Doctrine\DoctrineEmptyCollectionFilter;
-use DeepCopy\Matcher\PropertyMatcher;
-
-$deepCopy = new DeepCopy();
-$deepCopy->addFilter(new DoctrineEmptyCollectionFilter(), new PropertyMatcher('MyClass', 'myProperty'));
-$myCopy = $deepCopy->copy($myObject);
-
-// $myCopy->myProperty will return an empty collection
-```
-
-#### `DoctrineProxyFilter`
-
-If you use Doctrine and use cloning on lazy loaded entities, you might encounter errors mentioning missing fields on a
-Doctrine proxy class (...\\\_\_CG\_\_\Proxy).
-You can use the `DoctrineProxyFilter` to load the actual entity behind the Doctrine proxy class.
-**Make sure, though, to put this as one of your very first filters in the filter chain so that the entity is loaded before other filters are applied!**
-
-```php
-use DeepCopy\DeepCopy;
-use DeepCopy\Filter\Doctrine\DoctrineProxyFilter;
-use DeepCopy\Matcher\Doctrine\DoctrineProxyMatcher;
-
-$deepCopy = new DeepCopy();
-$deepCopy->addFilter(new DoctrineProxyFilter(), new DoctrineProxyMatcher());
-$myCopy = $deepCopy->copy($myObject);
-
-// $myCopy should now contain a clone of all entities, including those that were not yet fully loaded.
-```
 
 ## Contributing
 
 DeepCopy is distributed under the MIT license.
 
+
 ### Tests
 
 Running the tests is simple:

composer.json

@@ -15,16 +15,18 @@
     },
     "autoload-dev": {
         "psr-4": {
+            "DeepCopy\\": "fixtures/",
             "DeepCopyTest\\": "tests/DeepCopyTest/"
         }
     },
 
     "require": {
-        "php": ">=5.4.0"
+        "php": "^5.6 || ^7.0"
     },
     "require-dev": {
         "doctrine/collections": "^1.0",
-        "phpunit/phpunit": "~4.1"
+        "doctrine/common": "^2.6",
+        "phpunit/phpunit": "^4.1"
     },
 
     "config": {

fixtures/f001/A.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace DeepCopy\f001;
+
+class A
+{
+    private $aProp;
+
+    public function getAProp()
+    {
+        return $this->aProp;
+    }
+
+    public function setAProp($prop)
+    {
+        $this->aProp = $prop;
+
+        return $this;
+    }
+}

fixtures/f001/B.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace DeepCopy\f001;
+
+class B extends A
+{
+    private $bProp;
+
+    public function getBProp()
+    {
+        return $this->bProp;
+    }
+
+    public function setBProp($prop)
+    {
+        $this->bProp = $prop;
+
+        return $this;
+    }
+}

fixtures/f002/A.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace DeepCopy\f002;
+
+class A
+{
+    private $prop1;
+    private $prop2;
+
+    public function getProp1()
+    {
+        return $this->prop1;
+    }
+
+    public function setProp1($prop)
+    {
+        $this->prop1 = $prop;
+
+        return $this;
+    }
+
+    public function getProp2()
+    {
+        return $this->prop2;
+    }
+
+    public function setProp2($prop)
+    {
+        $this->prop2 = $prop;
+
+        return $this;
+    }
+}

fixtures/f003/Foo.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace DeepCopy\f003;
+
+class Foo
+{
+    private $name;
+    private $prop;
+
+    public function __construct($name)
+    {
+        $this->name = $name;
+    }
+
+    public function getProp()
+    {
+        return $this->prop;
+    }
+
+    public function setProp($prop)
+    {
+        $this->prop = $prop;
+
+        return $this;
+    }
+}