Merge pull request #10815 from albertcansado/deprecated-dirty

3.next - Update dirty method for get/set

src/ORM/Association/BelongsToMany.php

@@ -841,7 +841,7 @@ class BelongsToMany extends Association
             }
 
             $e->set($jointProperty, $joint);
-            $e->dirty($jointProperty, false);
+            $e->setDirty($jointProperty, false);
         }
 
         return true;
@@ -966,7 +966,7 @@ class BelongsToMany extends Association
         }
 
         $sourceEntity->set($property, array_values($existing));
-        $sourceEntity->dirty($property, false);
+        $sourceEntity->setDirty($property, false);
 
         return true;
     }
@@ -1223,7 +1223,7 @@ class BelongsToMany extends Association
 
                 ksort($targetEntities);
                 $sourceEntity->set($property, array_values($targetEntities));
-                $sourceEntity->dirty($property, false);
+                $sourceEntity->setDirty($property, false);
 
                 return true;
             }

src/ORM/Association/HasMany.php

@@ -304,7 +304,7 @@ class HasMany extends Association
 
         if ($ok) {
             $sourceEntity->set($property, $savedEntity->get($property));
-            $sourceEntity->dirty($property, false);
+            $sourceEntity->setDirty($property, false);
         }
 
         return $ok;
@@ -391,7 +391,7 @@ class HasMany extends Association
             );
         }
 
-        $sourceEntity->dirty($property, false);
+        $sourceEntity->setDirty($property, false);
     }
 
     /**

src/ORM/AssociationCollection.php

@@ -250,7 +250,7 @@ class AssociationCollection implements IteratorAggregate
      */
     protected function _save($association, $entity, $nested, $options)
     {
-        if (!$entity->dirty($association->getProperty())) {
+        if (!$entity->isDirty($association->getProperty())) {
             return true;
         }
         if (!empty($nested)) {

src/ORM/Behavior/CounterCacheBehavior.php

@@ -133,7 +133,7 @@ class CounterCacheBehavior extends Behavior
                 if (!is_callable($config) &&
                     isset($config['ignoreDirty']) &&
                     $config['ignoreDirty'] === true &&
-                    $entity->$entityAlias->dirty($field)
+                    $entity->$entityAlias->isDirty($field)
                 ) {
                     $this->_ignoreDirty[$registryAlias][$field] = true;
                 }

src/ORM/Behavior/TimestampBehavior.php

@@ -172,7 +172,7 @@ class TimestampBehavior extends Behavior
         foreach ($events[$eventName] as $field => $when) {
             if (in_array($when, ['always', 'existing'])) {
                 $return = true;
-                $entity->dirty($field, false);
+                $entity->setDirty($field, false);
                 $this->_updateField($entity, $field, $refresh);
             }
         }
@@ -190,7 +190,7 @@ class TimestampBehavior extends Behavior
      */
     protected function _updateField($entity, $field, $refreshTimestamp)
     {
-        if ($entity->dirty($field)) {
+        if ($entity->isDirty($field)) {
             return;
         }
         $entity->set($field, $this->timestamp(null, $refreshTimestamp));

src/ORM/Behavior/TranslateBehavior.php

@@ -603,7 +603,7 @@ class TranslateBehavior extends Behavior implements PropertyMarshalInterface
     {
         $translations = (array)$entity->get('_translations');
 
-        if (empty($translations) && !$entity->dirty('_translations')) {
+        if (empty($translations) && !$entity->isDirty('_translations')) {
             return;
         }
 

src/ORM/Behavior/TreeBehavior.php

@@ -100,7 +100,7 @@ class TreeBehavior extends Behavior
         $config = $this->getConfig();
         $parent = $entity->get($config['parent']);
         $primaryKey = $this->_getPrimaryKey();
-        $dirty = $entity->dirty($config['parent']);
+        $dirty = $entity->isDirty($config['parent']);
         $level = $config['level'];
 
         if ($parent && $entity->get($primaryKey) == $parent) {
@@ -585,7 +585,7 @@ class TreeBehavior extends Behavior
         $this->_table->updateAll($node->extract($fields), [$primary => $node->get($primary)]);
 
         foreach ($fields as $field) {
-            $node->dirty($field, false);
+            $node->setDirty($field, false);
         }
 
         return $node;
@@ -675,8 +675,8 @@ class TreeBehavior extends Behavior
         $node->set($left, $targetLeft);
         $node->set($right, $targetLeft + ($nodeRight - $nodeLeft));
 
-        $node->dirty($left, false);
-        $node->dirty($right, false);
+        $node->setDirty($left, false);
+        $node->setDirty($right, false);
 
         return $node;
     }
@@ -765,8 +765,8 @@ class TreeBehavior extends Behavior
         $node->set($left, $targetRight - ($nodeRight - $nodeLeft));
         $node->set($right, $targetRight);
 
-        $node->dirty($left, false);
-        $node->dirty($right, false);
+        $node->setDirty($left, false);
+        $node->setDirty($right, false);
 
         return $node;
     }
@@ -960,7 +960,7 @@ class TreeBehavior extends Behavior
         $entity->set($fresh->extract($fields), ['guard' => false]);
 
         foreach ($fields as $field) {
-            $entity->dirty($field, false);
+            $entity->setDirty($field, false);
         }
     }
 

src/ORM/LazyEagerLoader.php

@@ -155,7 +155,7 @@ class LazyEagerLoader
             foreach ($associations as $assoc) {
                 $property = $properties[$assoc];
                 $object->set($property, $loaded->get($property), ['useSetters' => false]);
-                $object->dirty($property, false);
+                $object->setDirty($property, false);
             }
             $injected[$k] = $object;
         }

src/ORM/Marshaller.php

@@ -579,7 +579,7 @@ class Marshaller
 
             foreach ($properties as $field => $value) {
                 if ($value instanceof EntityInterface) {
-                    $entity->dirty($field, $value->dirty());
+                    $entity->setDirty($field, $value->isDirty());
                 }
             }
 
@@ -590,7 +590,7 @@ class Marshaller
             if (array_key_exists($field, $properties)) {
                 $entity->set($field, $properties[$field]);
                 if ($properties[$field] instanceof EntityInterface) {
-                    $entity->dirty($field, $properties[$field]->dirty());
+                    $entity->setDirty($field, $properties[$field]->isDirty());
                 }
             }
         }

src/ORM/Table.php

@@ -1722,7 +1722,7 @@ class Table implements RepositoryInterface, EventListenerInterface, EventDispatc
             return false;
         }
 
-        if ($entity->isNew() === false && !$entity->dirty()) {
+        if ($entity->isNew() === false && !$entity->isDirty()) {
             return $entity;
         }
 

tests/TestCase/ORM/Association/BelongsToManyTest.php

@@ -687,7 +687,7 @@ class BelongsToManyTest extends TestCase
 
         $assoc->replaceLinks($entity, []);
         $this->assertSame([], $entity->tags, 'Property should be empty');
-        $this->assertFalse($entity->dirty('tags'), 'Property should be cleaned');
+        $this->assertFalse($entity->isDirty('tags'), 'Property should be cleaned');
 
         $new = $articles->get(1, ['contain' => 'Tags']);
         $this->assertSame([], $entity->tags, 'Should not be data in db');
@@ -724,7 +724,7 @@ class BelongsToManyTest extends TestCase
         $result = $assoc->replaceLinks($entity, $tagData, ['associated' => false]);
         $this->assertTrue($result);
         $this->assertSame($tagData, $entity->tags, 'Tags should match replaced objects');
-        $this->assertFalse($entity->dirty('tags'), 'Should be clean');
+        $this->assertFalse($entity->isDirty('tags'), 'Should be clean');
 
         $fresh = $articles->get(1, ['contain' => 'Tags']);
         $this->assertCount(3, $fresh->tags, 'Records should be in db');
@@ -759,7 +759,7 @@ class BelongsToManyTest extends TestCase
         $result = $assoc->replaceLinks($entity, [], ['associated' => false]);
         $this->assertTrue($result);
         $this->assertSame([], $entity->tags, 'Tags should match replaced objects');
-        $this->assertFalse($entity->dirty('tags'), 'Should be clean');
+        $this->assertFalse($entity->isDirty('tags'), 'Should be clean');
 
         $fresh = $articles->get(1, ['contain' => 'Tags']);
         $this->assertCount(0, $fresh->tags, 'Association should be empty');

tests/TestCase/ORM/Behavior/Translate/TranslateTraitTest.php

@@ -40,7 +40,7 @@ class TranslateTraitTest extends TestCase
         $entity->translation('eng')->set('title', 'My Title');
         $this->assertEquals('My Title', $entity->translation('eng')->get('title'));
 
-        $this->assertTrue($entity->dirty('_translations'));
+        $this->assertTrue($entity->isDirty('_translations'));
 
         $entity->translation('spa')->set('body', 'Contenido');
         $this->assertEquals('My Title', $entity->translation('eng')->get('title'));
@@ -95,6 +95,6 @@ class TranslateTraitTest extends TestCase
         ]);
         $entity->clean();
         $this->assertEquals('My Title', $entity->translation('eng')->get('title'));
-        $this->assertTrue($entity->dirty('_translations'));
+        $this->assertTrue($entity->isDirty('_translations'));
     }
 }

tests/TestCase/ORM/EntityTest.php

@@ -531,9 +531,9 @@ class EntityTest extends TestCase
     public function testUnsetMakesClean()
     {
         $entity = new Entity(['id' => 1, 'name' => 'bar']);
-        $this->assertTrue($entity->dirty('name'));
+        $this->assertTrue($entity->isDirty('name'));
         $entity->unsetProperty('name');
-        $this->assertFalse($entity->dirty('name'), 'Removed properties are not dirty.');
+        $this->assertFalse($entity->isDirty('name'), 'Removed properties are not dirty.');
     }
 
     /**
@@ -873,14 +873,14 @@ class EntityTest extends TestCase
             'title' => 'Foo',
             'author_id' => 3
         ]);
-        $this->assertTrue($entity->dirty('id'));
-        $this->assertTrue($entity->dirty('title'));
-        $this->assertTrue($entity->dirty('author_id'));
+        $this->assertTrue($entity->isDirty('id'));
+        $this->assertTrue($entity->isDirty('title'));
+        $this->assertTrue($entity->isDirty('author_id'));
 
         $entity->clean();
-        $this->assertFalse($entity->dirty('id'));
-        $this->assertFalse($entity->dirty('title'));
-        $this->assertFalse($entity->dirty('author_id'));
+        $this->assertFalse($entity->isDirty('id'));
+        $this->assertFalse($entity->isDirty('title'));
+        $this->assertFalse($entity->isDirty('author_id'));
     }
 
     /**
@@ -1472,7 +1472,7 @@ class EntityTest extends TestCase
         $entity->accessible('id', false);
         $entity->accessible('name', true);
         $entity->virtualProperties(['baz']);
-        $entity->dirty('foo', true);
+        $entity->setDirty('foo', true);
         $entity->errors('foo', ['An error']);
         $entity->invalid('foo', 'a value');
         $entity->source('foos');

tests/TestCase/ORM/MarshallerTest.php

@@ -193,7 +193,7 @@ class MarshallerTest extends TestCase
 
         $this->assertInstanceOf('Cake\ORM\Entity', $result);
         $this->assertEquals($data, $result->toArray());
-        $this->assertTrue($result->dirty(), 'Should be a dirty entity.');
+        $this->assertTrue($result->isDirty(), 'Should be a dirty entity.');
         $this->assertTrue($result->isNew(), 'Should be new');
         $this->assertEquals('Articles', $result->source());
     }
@@ -216,7 +216,7 @@ class MarshallerTest extends TestCase
         $marshall = new Marshaller($this->articles);
         $result = $marshall->one($data, []);
 
-        $this->assertFalse($result->dirty('id'));
+        $this->assertFalse($result->isDirty('id'));
         $this->assertNull($result->id);
     }
 
@@ -420,7 +420,7 @@ class MarshallerTest extends TestCase
         $result = $marshall->one($data, ['associated' => ['Users']]);
 
         $this->assertInstanceOf('Cake\ORM\Entity', $result);
-        $this->assertTrue($result->dirty(), 'Should be a dirty entity.');
+        $this->assertTrue($result->isDirty(), 'Should be a dirty entity.');
         $this->assertTrue($result->isNew(), 'Should be new');
         $this->assertFalse($result->has('Articles'), 'No prefixed field.');
         $this->assertEquals($data['title'], $result->title, 'Data from prefix should be merged.');
@@ -456,10 +456,10 @@ class MarshallerTest extends TestCase
 
         $this->assertInternalType('array', $result->comments);
         $this->assertEquals($data['comments'], $result->comments);
-        $this->assertTrue($result->dirty('comments'));
+        $this->assertTrue($result->isDirty('comments'));
 
         $this->assertInstanceOf('Cake\ORM\Entity', $result->user);
-        $this->assertTrue($result->dirty('user'));
+        $this->assertTrue($result->isDirty('user'));
         $this->assertEquals($data['user']['username'], $result->user->username);
         $this->assertEquals($data['user']['password'], $result->user->password);
     }
@@ -761,20 +761,20 @@ class MarshallerTest extends TestCase
 
         $this->assertNotEmpty($tag->articles);
         $this->assertCount(1, $tag->articles);
-        $this->assertTrue($tag->dirty('articles'), 'Updated prop should be dirty');
+        $this->assertTrue($tag->isDirty('articles'), 'Updated prop should be dirty');
         $this->assertInstanceOf('Cake\ORM\Entity', $tag->articles[0]);
         $this->assertSame('New tagged article', $tag->articles[0]->title);
         $this->assertFalse($tag->articles[0]->isNew());
 
         $this->assertNotEmpty($tag->articles[0]->user);
         $this->assertInstanceOf('Cake\ORM\Entity', $tag->articles[0]->user);
-        $this->assertTrue($tag->articles[0]->dirty('user'), 'Updated prop should be dirty');
+        $this->assertTrue($tag->articles[0]->isDirty('user'), 'Updated prop should be dirty');
         $this->assertSame('newuser', $tag->articles[0]->user->username);
         $this->assertTrue($tag->articles[0]->user->isNew());
 
         $this->assertNotEmpty($tag->articles[0]->comments);
         $this->assertCount(2, $tag->articles[0]->comments);
-        $this->assertTrue($tag->articles[0]->dirty('comments'), 'Updated prop should be dirty');
+        $this->assertTrue($tag->articles[0]->isDirty('comments'), 'Updated prop should be dirty');
         $this->assertInstanceOf('Cake\ORM\Entity', $tag->articles[0]->comments[0]);
         $this->assertTrue($tag->articles[0]->comments[0]->isNew());
         $this->assertTrue($tag->articles[0]->comments[1]->isNew());
@@ -827,7 +827,7 @@ class MarshallerTest extends TestCase
         $this->assertEquals($data['tags'][1]['id'], $result->tags[1]->id);
         $this->assertNotEmpty($result->tags[0]->_joinData);
         $this->assertNotEmpty($result->tags[1]->_joinData);
-        $this->assertTrue($result->dirty('tags'), 'Modified prop should be dirty');
+        $this->assertTrue($result->isDirty('tags'), 'Modified prop should be dirty');
         $this->assertEquals(0, $result->tags[0]->_joinData->active);
         $this->assertEquals(1, $result->tags[1]->_joinData->active);
     }
@@ -1291,7 +1291,7 @@ class MarshallerTest extends TestCase
 
         $this->assertSame($entity, $result);
         $this->assertEquals($data + ['body' => 'My Content'], $result->toArray());
-        $this->assertTrue($result->dirty(), 'Should be a dirty entity.');
+        $this->assertTrue($result->isDirty(), 'Should be a dirty entity.');
         $this->assertFalse($result->isNew(), 'Should not change the entity state');
     }
 
@@ -1350,7 +1350,7 @@ class MarshallerTest extends TestCase
         $entity->clean();
 
         $entity = $marshall->merge($entity, ['author_id' => $value]);
-        $this->assertTrue($entity->dirty('author_id'), 'Field should be dirty');
+        $this->assertTrue($entity->isDirty('author_id'), 'Field should be dirty');
         $this->assertSame(0, $entity->get('author_id'), 'Value should be zero');
     }
 
@@ -1376,7 +1376,7 @@ class MarshallerTest extends TestCase
         $entity->clean();
         $result = $marshall->merge($entity, $data, []);
 
-        $this->assertFalse($entity->dirty('body'), 'unchanged null should not be dirty');
+        $this->assertFalse($entity->isDirty('body'), 'unchanged null should not be dirty');
     }
 
     /**
@@ -1485,7 +1485,7 @@ class MarshallerTest extends TestCase
             'associated' => ['Users' => []]
         ]);
         $this->assertSame($user, $article->user);
-        $this->assertTrue($article->dirty('user'));
+        $this->assertTrue($article->isDirty('user'));
     }
 
     /**
@@ -1515,9 +1515,9 @@ class MarshallerTest extends TestCase
             'crazy' => true
         ];
         $this->assertEquals($expected, $result->toArray());
-        $this->assertFalse($entity->dirty('title'));
-        $this->assertFalse($entity->dirty('author_id'));
-        $this->assertTrue($entity->dirty('crazy'));
+        $this->assertFalse($entity->isDirty('title'));
+        $this->assertFalse($entity->isDirty('author_id'));
+        $this->assertTrue($entity->isDirty('crazy'));
     }
 
     /**
@@ -1548,8 +1548,8 @@ class MarshallerTest extends TestCase
         $marshall = new Marshaller($this->articles);
         $marshall->merge($entity, $data, ['associated' => ['Users']]);
 
-        $this->assertTrue($entity->dirty('user'), 'association should be dirty');
-        $this->assertTrue($entity->dirty('body'), 'body should be dirty');
+        $this->assertTrue($entity->isDirty('user'), 'association should be dirty');
+        $this->assertTrue($entity->isDirty('body'), 'body should be dirty');
         $this->assertEquals('My Content', $entity->body);
         $this->assertSame($user, $entity->user);
         $this->assertEquals('mark', $entity->user->username);
@@ -1584,8 +1584,8 @@ class MarshallerTest extends TestCase
         $this->assertInstanceOf('Cake\ORM\Entity', $entity->user);
         $this->assertEquals('mark', $entity->user->username);
         $this->assertEquals('not a secret', $entity->user->password);
-        $this->assertTrue($entity->dirty('user'));
-        $this->assertTrue($entity->dirty('body'));
+        $this->assertTrue($entity->isDirty('user'));
+        $this->assertTrue($entity->isDirty('body'));
         $this->assertTrue($entity->user->isNew());
     }
 
@@ -1621,7 +1621,7 @@ class MarshallerTest extends TestCase
         ]);
         $this->assertNull($article->user);
         $this->assertSame('', $article->user_id);
-        $this->assertTrue($article->dirty('user'));
+        $this->assertTrue($article->isDirty('user'));
     }
 
     /**
@@ -1663,10 +1663,10 @@ class MarshallerTest extends TestCase
         $result = $marshall->merge($entity, $data, ['associated' => ['Users', 'Comments']]);
         $this->assertSame($entity, $result);
         $this->assertSame($user, $result->user);
-        $this->assertTrue($result->dirty('user'), 'association should be dirty');
+        $this->assertTrue($result->isDirty('user'), 'association should be dirty');
         $this->assertEquals('not so secret', $entity->user->password);
 
-        $this->assertTrue($result->dirty('comments'));
+        $this->assertTrue($result->isDirty('comments'));
         $this->assertSame($comment1, $entity->comments[0]);
         $this->assertSame($comment2, $entity->comments[1]);
         $this->assertEquals('Altered comment 1', $entity->comments[0]->comment);
@@ -1732,7 +1732,7 @@ class MarshallerTest extends TestCase
         $result = $marshall->merge($entity, $data, ['associated' => ['Tags']]);
 
         $this->assertCount(3, $result->tags);
-        $this->assertTrue($result->dirty('tags'), 'Updated prop should be dirty');
+        $this->assertTrue($result->isDirty('tags'), 'Updated prop should be dirty');
         $this->assertInstanceOf('Cake\ORM\Entity', $result->tags[0]);
         $this->assertInstanceOf('Cake\ORM\Entity', $result->tags[1]);
         $this->assertInstanceOf('Cake\ORM\Entity', $result->tags[2]);
@@ -1773,7 +1773,7 @@ class MarshallerTest extends TestCase
         $result = $marshall->merge($entity, $data, ['associated' => ['Tags']]);
 
         $this->assertCount(3, $result->tags);
-        $this->assertTrue($result->dirty('tags'));
+        $this->assertTrue($result->isDirty('tags'));
     }
 
     /**
@@ -1805,7 +1805,7 @@ class MarshallerTest extends TestCase
         $result = $marshall->merge($entity, $data, ['associated' => ['Tags']]);
 
         $this->assertCount(3, $result->tags);
-        $this->assertTrue($result->dirty('tags'));
+        $this->assertTrue($result->isDirty('tags'));
         $this->assertInstanceOf('Cake\ORM\Entity', $result->tags[0]);
         $this->assertInstanceOf('Cake\ORM\Entity', $result->tags[1]);
         $this->assertInstanceOf('Cake\ORM\Entity', $result->tags[2]);
@@ -1892,7 +1892,7 @@ class MarshallerTest extends TestCase
         ];
         $result = $marshall->merge($entity, $data, ['associated' => ['Tags']]);
         $this->assertCount(0, $result->tags);
-        $this->assertTrue($result->dirty('tags'));
+        $this->assertTrue($result->isDirty('tags'));
     }
 
     /**
@@ -1924,7 +1924,7 @@ class MarshallerTest extends TestCase
             'associated' => ['Tags' => ['onlyIds' => true]]
         ]);
         $this->assertCount(0, $result->tags);
-        $this->assertTrue($result->dirty('tags'));
+        $this->assertTrue($result->isDirty('tags'));
     }
 
     /**
@@ -1956,7 +1956,7 @@ class MarshallerTest extends TestCase
         ]);
         $this->assertCount(1, $result->tags);
         $this->assertEquals('tag3', $result->tags[0]->name);
-        $this->assertTrue($result->dirty('tags'));
+        $this->assertTrue($result->isDirty('tags'));
     }
 
     /**
@@ -1983,7 +1983,7 @@ class MarshallerTest extends TestCase
         $result = $marshall->merge($entity, $data, ['associated' => 'Tags._joinData']);
 
         $articles->save($entity, ['associated' => ['Tags._joinData']]);
-        $this->assertFalse($entity->tags[0]->dirty('_joinData'));
+        $this->assertFalse($entity->tags[0]->isDirty('_joinData'));
         $this->assertEmpty($entity->tags[0]->_joinData);
     }
 
@@ -2015,10 +2015,10 @@ class MarshallerTest extends TestCase
         $marshall = new Marshaller($articles);
         $result = $marshall->merge($entity, $data, ['associated' => 'Tags._joinData']);
 
-        $this->assertTrue($entity->dirty('tags'), 'Association data changed');
-        $this->assertTrue($entity->tags[0]->dirty('_joinData'));
-        $this->assertTrue($result->tags[0]->_joinData->dirty('author_id'), 'Field not modified');
-        $this->assertTrue($result->tags[0]->_joinData->dirty('highlighted'), 'Field not modified');
+        $this->assertTrue($entity->isDirty('tags'), 'Association data changed');
+        $this->assertTrue($entity->tags[0]->isDirty('_joinData'));
+        $this->assertTrue($result->tags[0]->_joinData->isDirty('author_id'), 'Field not modified');
+        $this->assertTrue($result->tags[0]->_joinData->isDirty('highlighted'), 'Field not modified');
         $this->assertSame(99, $result->tags[0]->_joinData->author_id);
         $this->assertTrue($result->tags[0]->_joinData->highlighted);
     }
@@ -2047,7 +2047,7 @@ class MarshallerTest extends TestCase
         $marshall = new Marshaller($articles);
         $result = $marshall->merge($entity, $data, ['associated' => 'Tags']);
 
-        $this->assertTrue($entity->dirty('tags'));
+        $this->assertTrue($entity->isDirty('tags'));
         $this->assertInstanceOf('Cake\ORM\Entity', $result->tags[0]->_joinData);
         $this->assertTrue($result->tags[0]->_joinData->highlighted);
 
@@ -2062,7 +2062,7 @@ class MarshallerTest extends TestCase
         $marshall = new Marshaller($articles);
         $result = $marshall->merge($entity, $data, ['associated' => 'Tags']);
 
-        $this->assertTrue($entity->dirty('tags'), 'association data changed');
+        $this->assertTrue($entity->isDirty('tags'), 'association data changed');
         $this->assertInstanceOf('Cake\ORM\Entity', $result->tags[0]->_joinData);
         $this->assertTrue($result->tags[0]->_joinData->highlighted);
     }
@@ -2100,7 +2100,7 @@ class MarshallerTest extends TestCase
         $article = $this->articles->get(1, ['associated' => 'Tags']);
         $result = $marshall->merge($article, $data, ['associated' => ['Tags._joinData.Users']]);
 
-        $this->assertTrue($result->dirty('tags'));
+        $this->assertTrue($result->isDirty('tags'));
         $this->assertInstanceOf('Cake\ORM\Entity', $result->tags[0]);
         $this->assertInstanceOf('Cake\ORM\Entity', $result->tags[1]);
         $this->assertInstanceOf('Cake\ORM\Entity', $result->tags[0]->_joinData->user);
@@ -2170,7 +2170,7 @@ class MarshallerTest extends TestCase
 
         $this->assertEquals($data['title'], $result->title);
         $this->assertEquals('My content', $result->body);
-        $this->assertTrue($result->dirty('tags'));
+        $this->assertTrue($result->isDirty('tags'));
         $this->assertSame($tag1, $entity->tags[0]);
         $this->assertSame($tag1->_joinData, $entity->tags[0]->_joinData);
         $this->assertSame(
@@ -2182,8 +2182,8 @@ class MarshallerTest extends TestCase
             $entity->tags[1]->_joinData->toArray()
         );
         $this->assertEquals('new tag', $entity->tags[1]->tag);
-        $this->assertTrue($entity->tags[0]->dirty('_joinData'));
-        $this->assertTrue($entity->tags[1]->dirty('_joinData'));
+        $this->assertTrue($entity->tags[0]->isDirty('_joinData'));
+        $this->assertTrue($entity->tags[1]->isDirty('_joinData'));
     }
 
     /**
@@ -2250,10 +2250,10 @@ class MarshallerTest extends TestCase
 
         $this->assertEquals($data['title'], $result->title);
         $this->assertEquals('My content', $result->body);
-        $this->assertTrue($entity->dirty('tags'));
+        $this->assertTrue($entity->isDirty('tags'));
         $this->assertSame($tag1, $entity->tags[0]);
 
-        $this->assertTrue($tag1->dirty('_joinData'));
+        $this->assertTrue($tag1->isDirty('_joinData'));
         $this->assertSame($tag1->_joinData, $entity->tags[0]->_joinData);
         $this->assertEquals('Bill', $entity->tags[0]->_joinData->user->username);
         $this->assertEquals('secret', $entity->tags[0]->_joinData->user->password);
@@ -2285,7 +2285,7 @@ class MarshallerTest extends TestCase
         $result = $marshall->merge($entity, $data, ['associated' => ['Tags']]);
 
         $this->assertCount(1, $result->tags);
-        $this->assertTrue($result->dirty('tags'));
+        $this->assertTrue($result->isDirty('tags'));
         $this->assertInstanceOf('Cake\ORM\Entity', $result->tags[0]);
         $this->assertInstanceOf('Cake\ORM\Entity', $result->tags[0]->_joinData);
         $this->assertSame($original, $result->tags[0]->_joinData, 'Should be same object');
@@ -2317,8 +2317,8 @@ class MarshallerTest extends TestCase
         $this->assertEquals('Changed 1', $result[0]->comment);
         $this->assertEquals(1, $result[0]->user_id);
         $this->assertEquals('Changed 2', $result[1]->comment);
-        $this->assertTrue($result[0]->dirty('user_id'));
-        $this->assertFalse($result[1]->dirty('user_id'));
+        $this->assertTrue($result[0]->isDirty('user_id'));
+        $this->assertFalse($result[1]->isDirty('user_id'));
     }
 
     /**
@@ -2719,7 +2719,7 @@ class MarshallerTest extends TestCase
         $this->assertEquals('mark', $entity->user->username);
         $this->assertEquals('secret', $entity->user->password);
         $this->assertEquals('data', $entity->user->extra);
-        $this->assertTrue($entity->dirty('user'));
+        $this->assertTrue($entity->isDirty('user'));
     }
 
     /**
@@ -2845,8 +2845,8 @@ class MarshallerTest extends TestCase
             $entity->tags[1]->_joinData->toArray()
         );
         $this->assertEquals('new tag', $entity->tags[1]->tag);
-        $this->assertTrue($entity->tags[0]->dirty('_joinData'));
-        $this->assertTrue($entity->tags[1]->dirty('_joinData'));
+        $this->assertTrue($entity->tags[0]->isDirty('_joinData'));
+        $this->assertTrue($entity->tags[1]->isDirty('_joinData'));
     }
 
     /**
@@ -3112,7 +3112,7 @@ class MarshallerTest extends TestCase
 
         $this->assertSame($entity, $result);
         $this->assertEmpty($result->errors());
-        $this->assertTrue($result->dirty('_translations'));
+        $this->assertTrue($result->isDirty('_translations'));
 
         $translations = $result->get('_translations');
         $this->assertCount(2, $translations);
@@ -3271,7 +3271,7 @@ class MarshallerTest extends TestCase
         $this->assertInstanceOf('Cake\ORM\Entity', $entity->user);
         $this->assertEquals('mark', $entity->user->username);
         $this->assertEquals('not a secret', $entity->user->password);
-        $this->assertFalse($entity->dirty('user'));
+        $this->assertFalse($entity->isDirty('user'));
         $this->assertTrue($entity->user->isNew());
     }
 
@@ -3294,7 +3294,7 @@ class MarshallerTest extends TestCase
         $marshall = new Marshaller($articles);
         $result = $marshall->one($data);
 
-        $this->assertFalse($result->dirty('id'));
+        $this->assertFalse($result->isDirty('id'));
         $this->assertNull($result->id);
     }
 

tests/TestCase/ORM/RulesCheckerIntegrationTest.php

@@ -119,7 +119,7 @@ class RulesCheckerIntegrationTest extends TestCase
         $this->assertTrue($entity->article->isNew());
         $this->assertNull($entity->article->id);
         $this->assertNull($entity->article->get('author_id'));
-        $this->assertFalse($entity->article->dirty('author_id'));
+        $this->assertFalse($entity->article->isDirty('author_id'));
         $this->assertNotEmpty($entity->article->errors('title'));
         $this->assertSame('A Title', $entity->article->invalid('title'));
     }
@@ -371,7 +371,7 @@ class RulesCheckerIntegrationTest extends TestCase
         $this->assertSame($entity, $table->save($entity));
 
         $entity = $table->get(1);
-        $entity->dirty('name', true);
+        $entity->setDirty('name', true);
         $this->assertSame($entity, $table->save($entity));
     }
 
@@ -428,7 +428,7 @@ class RulesCheckerIntegrationTest extends TestCase
         $this->assertSame($entity, $table->save($entity));
 
         $entity = $table->get(1);
-        $entity->dirty('author_id', true);
+        $entity->setDirty('author_id', true);
         $this->assertSame($entity, $table->save($entity));
     }
 
@@ -837,7 +837,7 @@ class RulesCheckerIntegrationTest extends TestCase
         $entity = $table->get(1);
         $entity->title = 'Foo';
         $entity->author_id = 1000;
-        $entity->dirty('author_id', false);
+        $entity->setDirty('author_id', false);
         $this->assertSame($entity, $table->save($entity));
     }
 

tests/TestCase/ORM/TableTest.php

@@ -1484,17 +1484,17 @@ class TableTest extends TestCase
         $results = $table->find('all')->contain(['Tags', 'Authors'])->toArray();
         $this->assertCount(3, $results);
         foreach ($results as $article) {
-            $this->assertFalse($article->dirty('id'));
-            $this->assertFalse($article->dirty('title'));
-            $this->assertFalse($article->dirty('author_id'));
-            $this->assertFalse($article->dirty('body'));
-            $this->assertFalse($article->dirty('published'));
-            $this->assertFalse($article->dirty('author'));
-            $this->assertFalse($article->author->dirty('id'));
-            $this->assertFalse($article->author->dirty('name'));
-            $this->assertFalse($article->dirty('tag'));
+            $this->assertFalse($article->isDirty('id'));
+            $this->assertFalse($article->isDirty('title'));
+            $this->assertFalse($article->isDirty('author_id'));
+            $this->assertFalse($article->isDirty('body'));
+            $this->assertFalse($article->isDirty('published'));
+            $this->assertFalse($article->isDirty('author'));
+            $this->assertFalse($article->author->isDirty('id'));
+            $this->assertFalse($article->author->isDirty('name'));
+            $this->assertFalse($article->isDirty('tag'));
             if ($article->tag) {
-                $this->assertFalse($article->tag[0]->_joinData->dirty('tag_id'));
+                $this->assertFalse($article->tag[0]->_joinData->isDirty('tag_id'));
             }
         }
     }
@@ -1821,7 +1821,7 @@ class TableTest extends TestCase
 
         $articleId = $entity->articles[0]->id;
         unset($entity->articles[0]);
-        $entity->dirty('articles', true);
+        $entity->setDirty('articles', true);
 
         $authors->save($entity, ['associated' => ['Articles']]);
 
@@ -1901,7 +1901,7 @@ class TableTest extends TestCase
 
         $articleId = $entity->articles[0]->id;
         unset($entity->articles[0]);
-        $entity->dirty('articles', true);
+        $entity->setDirty('articles', true);
 
         $authors->save($entity, ['associated' => ['Articles']]);
 
@@ -1961,7 +1961,7 @@ class TableTest extends TestCase
 
         $articleId = $entity->articles[0]->id;
         unset($entity->articles[0]);
-        $entity->dirty('articles', true);
+        $entity->setDirty('articles', true);
 
         $authors->save($entity, ['associated' => ['Articles']]);
 
@@ -2010,7 +2010,7 @@ class TableTest extends TestCase
         $this->assertTrue($articles->Comments->exists(['id' => $commentId]));
 
         unset($article->comments[0]);
-        $article->dirty('comments', true);
+        $article->setDirty('comments', true);
         $article = $articles->save($article, ['associated' => ['Comments']]);
 
         $this->assertEquals($sizeComments - 1, $articles->Comments->find('all')->where(['article_id' => $article->id])->count());
@@ -2064,7 +2064,7 @@ class TableTest extends TestCase
             'comment' => 'new comment'
         ]);
 
-        $article->dirty('comments', true);
+        $article->setDirty('comments', true);
         $article = $articles->save($article, ['associated' => ['Comments']]);
 
         $this->assertEquals($sizeComments, $articles->Comments->find('all')->where(['article_id' => $article->id])->count());
@@ -2121,7 +2121,7 @@ class TableTest extends TestCase
         $this->assertEquals(3, $Comments->target()->find()->where(['Comments.article_id' => $article->get('id')])->count());
 
         unset($article->comments[1]);
-        $article->dirty('comments', true);
+        $article->setDirty('comments', true);
 
         $article = $Articles->save($article);
         $this->assertNotEmpty($article);
@@ -2183,7 +2183,7 @@ class TableTest extends TestCase
 
         $article2 = $author->articles[1];
         unset($author->articles[1]);
-        $author->dirty('articles', true);
+        $author->setDirty('articles', true);
 
         $author = $Authors->save($author);
         $this->assertNotEmpty($author);
@@ -2344,7 +2344,7 @@ class TableTest extends TestCase
         $called = false;
         $listener = function ($e, $entity, $options) use ($data, &$called) {
             $this->assertSame($data, $entity);
-            $this->assertTrue($entity->dirty());
+            $this->assertTrue($entity->isDirty());
             $called = true;
         };
         $table->getEventManager()->on('Model.afterSave', $listener);
@@ -2352,7 +2352,7 @@ class TableTest extends TestCase
         $calledAfterCommit = false;
         $listenerAfterCommit = function ($e, $entity, $options) use ($data, &$calledAfterCommit) {
             $this->assertSame($data, $entity);
-            $this->assertTrue($entity->dirty());
+            $this->assertTrue($entity->isDirty());
             $this->assertNotSame($data->get('username'), $data->getOriginal('username'));
             $calledAfterCommit = true;
         };
@@ -2692,9 +2692,9 @@ class TableTest extends TestCase
             'updated' => new Time('2013-10-10 00:00')
         ]);
         $entity->clean();
-        $entity->dirty('username', true);
-        $entity->dirty('created', true);
-        $entity->dirty('updated', true);
+        $entity->setDirty('username', true);
+        $entity->setDirty('created', true);
+        $entity->setDirty('updated', true);
 
         $table = TableRegistry::get('users');
         $this->assertSame($entity, $table->save($entity));
@@ -2721,10 +2721,10 @@ class TableTest extends TestCase
         ]);
         $table = TableRegistry::get('users');
         $this->assertSame($entity, $table->save($entity));
-        $this->assertFalse($entity->dirty('usermane'));
-        $this->assertFalse($entity->dirty('password'));
-        $this->assertFalse($entity->dirty('created'));
-        $this->assertFalse($entity->dirty('updated'));
+        $this->assertFalse($entity->isDirty('usermane'));
+        $this->assertFalse($entity->isDirty('password'));
+        $this->assertFalse($entity->isDirty('created'));
+        $this->assertFalse($entity->isDirty('updated'));
     }
 
     /**
@@ -2769,8 +2769,8 @@ class TableTest extends TestCase
         $this->assertEquals($original->created, $row->created);
         $this->assertEquals($original->updated, $row->updated);
         $this->assertFalse($entity->isNew());
-        $this->assertFalse($entity->dirty('id'));
-        $this->assertFalse($entity->dirty('username'));
+        $this->assertFalse($entity->isDirty('id'));
+        $this->assertFalse($entity->isDirty('username'));
     }
 
     /**
@@ -3706,7 +3706,7 @@ class TableTest extends TestCase
         $this->assertFalse($entity->article->isNew());
         $this->assertEquals(4, $entity->article->id);
         $this->assertEquals(5, $entity->article->get('author_id'));
-        $this->assertFalse($entity->article->dirty('author_id'));
+        $this->assertFalse($entity->article->isDirty('author_id'));
     }
 
     /**
@@ -3846,7 +3846,7 @@ class TableTest extends TestCase
         $entity = $table->find()->contain('Tags')->first();
         // not associated to the article already.
         $entity->tags[] = $tags->get(3);
-        $entity->dirty('tags', true);
+        $entity->setDirty('tags', true);
 
         $this->assertSame($entity, $table->save($entity));
 
@@ -4396,7 +4396,7 @@ class TableTest extends TestCase
 
         $this->assertCount($sizeArticles, $authors->Articles->findAllByAuthorId($author->id));
         $this->assertCount($sizeArticles, $author->articles);
-        $this->assertFalse($author->dirty('articles'));
+        $this->assertFalse($author->isDirty('articles'));
     }
 
     /**
@@ -4448,7 +4448,7 @@ class TableTest extends TestCase
 
         $this->assertCount($sizeArticles, $authors->Articles->findAllByAuthorId($author->id));
         $this->assertCount($sizeArticles, $author->articles);
-        $this->assertFalse($author->dirty('articles'));
+        $this->assertFalse($author->isDirty('articles'));
     }
 
     /**
@@ -4503,7 +4503,7 @@ class TableTest extends TestCase
 
         $this->assertCount($sizeArticles, $authors->Articles->findAllByAuthorId($author->id));
         $this->assertCount($sizeArticles, $author->articles);
-        $this->assertFalse($author->dirty('articles'));
+        $this->assertFalse($author->isDirty('articles'));
     }
 
     /**
@@ -4551,7 +4551,7 @@ class TableTest extends TestCase
 
         $this->assertCount($sizeArticles - count($articlesToUnlink), $authors->Articles->findAllByAuthorId($author->id));
         $this->assertCount($sizeArticles - count($articlesToUnlink), $author->articles);
-        $this->assertFalse($author->dirty('articles'));
+        $this->assertFalse($author->isDirty('articles'));
     }
 
     /**
@@ -4599,7 +4599,7 @@ class TableTest extends TestCase
 
         $this->assertCount($sizeArticles - count($articlesToUnlink), $authors->Articles->findAllByAuthorId($author->id));
         $this->assertCount($sizeArticles, $author->articles);
-        $this->assertFalse($author->dirty('articles'));
+        $this->assertFalse($author->isDirty('articles'));
     }
 
     /**
@@ -4871,7 +4871,7 @@ class TableTest extends TestCase
         $table->association('tags')->unlink($article, [$article->tags[0]]);
         $this->assertCount(1, $article->tags);
         $this->assertEquals(2, $article->tags[0]->get('id'));
-        $this->assertFalse($article->dirty('tags'));
+        $this->assertFalse($article->isDirty('tags'));
     }
 
     /**
@@ -5028,7 +5028,7 @@ class TableTest extends TestCase
 
         $article = $articles->get(1);
         $article->tags = [];
-        $article->dirty('tags', true);
+        $article->setDirty('tags', true);
 
         $result = $articles->save($article, ['foo' => 'bar']);
         $this->assertNotEmpty($result);
@@ -5192,7 +5192,7 @@ class TableTest extends TestCase
 
         $author = $authors->get(1);
         $author->articles = [];
-        $author->dirty('articles', true);
+        $author->setDirty('articles', true);
 
         $result = $authors->save($author, ['foo' => 'bar']);
         $this->assertNotEmpty($result);
@@ -5228,7 +5228,7 @@ class TableTest extends TestCase
 
         $author = $authors->get(1);
         $author->articles = [];
-        $author->dirty('articles', true);
+        $author->setDirty('articles', true);
 
         $result = $articles->link($author, [$articles->target()->get(2)], ['foo' => 'bar']);
         $this->assertTrue($result);
@@ -5271,7 +5271,7 @@ class TableTest extends TestCase
 
         $author = $authors->get(1);
         $author->articles = [];
-        $author->dirty('articles', true);
+        $author->setDirty('articles', true);
 
         $articles->unlink($author, [$articles->target()->get(1)], ['foo' => 'bar']);
 
@@ -5401,7 +5401,7 @@ class TableTest extends TestCase
 
         $author = $authors->get(1);
         $author->articles = [];
-        $author->dirty('articles', true);
+        $author->setDirty('articles', true);
 
         $articles->unlink($author, [$articles->target()->get(1)], false);
         $this->assertArrayHasKey('cleanProperty', $actualOptions);
@@ -6274,14 +6274,14 @@ class TableTest extends TestCase
         $userTable->Comments
             ->getEventManager()
             ->on('Model.afterSave', function (Event $event, $entity) use (&$counter) {
-                if ($entity->dirty()) {
+                if ($entity->isDirty()) {
                     $counter++;
                 }
             });
 
         $savedUser->comments[] = $userTable->Comments->get(5);
         $this->assertCount(3, $savedUser->comments);
-        $savedUser->dirty('comments', true);
+        $savedUser->setDirty('comments', true);
         $userTable->save($savedUser);
         $this->assertEquals(1, $counter);
     }
@@ -6311,14 +6311,14 @@ class TableTest extends TestCase
         $table->Tags->junction()
             ->getEventManager()
             ->on('Model.afterSave', function (Event $event, $entity) use (&$counter) {
-                if ($entity->dirty()) {
+                if ($entity->isDirty()) {
                     $counter++;
                 }
             });
 
         $article->tags[] = $table->Tags->get(3);
         $this->assertCount(3, $article->tags);
-        $article->dirty('tags', true);
+        $article->setDirty('tags', true);
         $table->save($article);
         $this->assertEquals(1, $counter);
     }
@@ -6354,11 +6354,11 @@ class TableTest extends TestCase
         $validator = $table->getValidator()->requirePresence('body');
         $entity = $table->newEntity(['title' => 'mark']);
 
-        $entity->dirty('title', true);
+        $entity->setDirty('title', true);
         $entity->invalid('title', 'albert');
 
         $this->assertNotEmpty($entity->errors());
-        $this->assertTrue($entity->dirty());
+        $this->assertTrue($entity->isDirty());
         $this->assertEquals(['title' => 'albert'], $entity->invalid());
 
         $entity->title = 'alex';
@@ -6367,7 +6367,7 @@ class TableTest extends TestCase
         $entity->clean();
 
         $this->assertEmpty($entity->errors());
-        $this->assertFalse($entity->dirty());
+        $this->assertFalse($entity->isDirty());
         $this->assertEquals([], $entity->invalid());
         $this->assertSame($entity->getOriginal('title'), 'alex');
     }