[#2] add hasKey assert

+ hasKey assert
+ count assert
+ isSame assert
+ notSame assert
+ ArgumentCheckerTrait

Author: index0h

README.md

@@ -15,7 +15,7 @@ php-assert
 
 ## Yet another validator, WHY??
 
-## It's very fast, but ugly inside
+## It's very fast and designed to be used in any method
 
 There are many other cool asserts, but for their usability you must pay by time & memory of execution.
 This assert gives you very simple and fast API.
@@ -202,10 +202,52 @@ Assert::assert('c', 'var')->inArray(['a', 'b']);
 Assert::assert(['a'], 'var')->inArray('a');
 ```
 
+#### isSame($anotherValue) `Check if value is same as $anotherValue`
+
+* Antipode: **notSame**
+
+Arguments:
+
+* `$anotherValue` MUST be not object
+
+```php
+// OK
+Assert::assert('a', 'var')->isSame('a');
+
+// EXCEPTION
+Assert::assert('a', 'var')->isSame('b');
+
+// ----------
+
+// EXCEPTION: $anotherValue MUST be not object
+Assert::assert('a', 'var')->isSame(new \stdClass());
+```
+
+#### notSame($anotherValue) `Check if value is not same as $anotherValue`
+
+* Antipode: **isSame**
+
+Arguments:
+
+* `$anotherValue` MUST be not object
+
+```php
+// OK
+Assert::assert('a', 'var')->notSame('b');
+
+// EXCEPTION
+Assert::assert('a', 'var')->notSame('a');
+
+// ----------
+
+// EXCEPTION: $anotherValue MUST be not object
+Assert::assert('a', 'var')->notSame(new \stdClass());
+```
+
 -- --
 
 String asserts
------------------
+--------------
 
 All string asserts run previously:
 
@@ -456,6 +498,60 @@ Assert::assert('A', 'var')->between(1);
 
 -- --
 
+Array asserts
+--------------
+
+#### hasKey($key) `Check if array key exists`
+
+Arguments:
+
+* `$key` MUST be string or int
+
+```php
+// OK
+Assert::assert(['a' => 'b', 'c' => 'd'], 'data')->hasKey('a');
+
+// EXCEPTION
+Assert::assert(['a' => 'b', 'c' => 'd'], 'data')->hasKey('e');
+
+// ----------
+
+// EXCEPTION: data MUST be an array
+Assert::assert('notArray', 'data')->hasKey(1);
+
+// EXCEPTION: key MUST be string or int
+Assert::assert(['a' => 'b', 'c' => 'd'], 'data')->hasKey(null);
+
+```
+
+#### count($count) `Check if array elements count is same as $count`
+
+Arguments:
+
+* `$count` MUST be int and greater than 0
+
+```php
+// OK
+Assert::assert(['a', 'b', 'c'], 'data')->count(3);
+
+// EXCEPTION
+Assert::assert(['a', 'c', 'd'], 'data')->count(1);
+
+// ----------
+
+// EXCEPTION: data MUST be an array
+Assert::assert('notArray', 'data')->hasKey(1);
+
+// EXCEPTION: count MUST be int
+Assert::assert(['a', 'c', 'd'], 'data')->count(null);
+
+// EXCEPTION: count MUST be greater than 0
+Assert::assert(['a', 'c', 'd'], 'data')->count(-5);
+
+```
+
+-- --
+
 LOOP ASSERTS API
 ================
 

src/Assert.php

@@ -7,6 +7,8 @@
 
 namespace KoKoKo\assert;
 
+use KoKoKo\assert\exceptions\ArrayKeyNotExistsException;
+use KoKoKo\assert\exceptions\InvalidArrayCountException;
 use KoKoKo\assert\exceptions\InvalidArrayException;
 use KoKoKo\assert\exceptions\InvalidBoolException;
 use KoKoKo\assert\exceptions\InvalidDigitException;
@@ -15,14 +17,17 @@
 use KoKoKo\assert\exceptions\InvalidIntException;
 use KoKoKo\assert\exceptions\InvalidIntOrFloatException;
 use KoKoKo\assert\exceptions\InvalidIntOrFloatOrStringException;
+use KoKoKo\assert\exceptions\InvalidIntOrStringException;
 use KoKoKo\assert\exceptions\InvalidNotArrayException;
 use KoKoKo\assert\exceptions\InvalidNotEmptyException;
 use KoKoKo\assert\exceptions\InvalidNotNullException;
 use KoKoKo\assert\exceptions\InvalidNotObjectException;
+use KoKoKo\assert\exceptions\InvalidNotSameValueException;
 use KoKoKo\assert\exceptions\InvalidNullException;
 use KoKoKo\assert\exceptions\InvalidNumericException;
-use KoKoKo\assert\exceptions\InvalidRegexpPatternException;
+use KoKoKo\assert\exceptions\InvalidRegExpPatternException;
 use KoKoKo\assert\exceptions\InvalidResourceException;
+use KoKoKo\assert\exceptions\InvalidSameValueException;
 use KoKoKo\assert\exceptions\InvalidStringException;
 use KoKoKo\assert\exceptions\InvalidStringLengthException;
 use KoKoKo\assert\exceptions\LengthNotBetweenException;
@@ -305,6 +310,61 @@ public function isArray()
         return $this;
     }
 
+    /**
+     * Check if array key exists
+     *
+     * @param string|int $key
+     * @return $this
+     * @throws ArrayKeyNotExistsException
+     * @throws InvalidArrayException
+     * @throws InvalidIntOrStringException
+     */
+    public function hasKey($key)
+    {
+        if (!is_string($key) && !is_int($key)) {
+            throw new InvalidIntOrStringException('key', $key);
+        }
+
+        if (!is_array($this->value)) {
+            throw new InvalidArrayException($this->name, $this->value);
+        }
+
+        if (!array_key_exists($key, $this->value)) {
+            throw new ArrayKeyNotExistsException($this->name, $key);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Check if array elements count is same as $count
+     *
+     * @param int $count
+     * @return $this
+     * @throws InvalidArrayCountException
+     * @throws InvalidArrayException
+     * @throws InvalidIntException
+     * @throws NumberNotGreaterException
+     */
+    public function count($count)
+    {
+        if (!is_int($count)) {
+            throw new InvalidIntException('count', $count);
+        } elseif ($count < 0) {
+            throw new NumberNotGreaterException('count', $count, 0);
+        }
+
+        if (!is_array($this->value)) {
+            throw new InvalidArrayException($this->name, $this->value);
+        }
+
+        if (count($this->value) !== $count) {
+            throw new InvalidArrayCountException($this->name, $this->value, $count);
+        }
+
+        return $this;
+    }
+
     /**
      * Soft check that $from <= value <= $to
      *
@@ -646,6 +706,48 @@ public function positive()
         return $this;
     }
 
+    /**
+     * Check if value is same as $anotherValue
+     *
+     * @param int|float|bool|string|resource|array|null $anotherValue
+     * @return $this
+     * @throws InvalidNotObjectException
+     * @throws InvalidSameValueException
+     */
+    public function isSame($anotherValue)
+    {
+        if (is_object($anotherValue)) {
+            throw new InvalidNotObjectException('anotherValue');
+        }
+
+        if ($this->value !== $anotherValue) {
+            throw new InvalidSameValueException($this->name, $this->value, $anotherValue);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Check if value is not same as $anotherValue
+     *
+     * @param int|float|bool|string|resource|array|null $anotherValue
+     * @return $this
+     * @throws InvalidNotObjectException
+     * @throws InvalidNotSameValueException
+     */
+    public function notSame($anotherValue)
+    {
+        if (is_object($anotherValue)) {
+            throw new InvalidNotObjectException('anotherValue');
+        }
+
+        if ($this->value === $anotherValue) {
+            throw new InvalidNotSameValueException($this->name, $this->value);
+        }
+
+        return $this;
+    }
+
     /**
      * Check if value is null
      *

src/exceptions/ArrayKeyNotExistsException.php

@@ -0,0 +1,35 @@
+<?php
+/**
+ * @link      https://github.com/ko-ko-ko/php-assert
+ * @copyright Copyright (c) 2015 Roman Levishchenko <[email protected]>
+ * @license   https://raw.github.com/ko-ko-ko/php-assert/master/LICENSE
+ */
+
+namespace KoKoKo\assert\exceptions;
+
+class ArrayKeyNotExistsException extends ArgumentException
+{
+    /**
+     * @param string $variableName
+     * @param string $key
+     * @throws InvalidIntOrStringException
+     * @throws InvalidNotEmptyException
+     * @throws InvalidStringException
+     */
+    public function __construct($variableName, $key)
+    {
+        if (!is_string($variableName)) {
+            throw new InvalidStringException('variableName', $variableName);
+        } elseif (!is_int($key) && !is_string($key)) {
+            throw new InvalidIntOrStringException('key', $key);
+        }
+
+        parent::__construct(
+            sprintf(
+                'Variable "$%s" must contain key: "%s"',
+                $variableName,
+                $key
+            )
+        );
+    }
+}

src/exceptions/InvalidArrayCountException.php

@@ -0,0 +1,43 @@
+<?php
+/**
+ * @link      https://github.com/ko-ko-ko/php-assert
+ * @copyright Copyright (c) 2015 Roman Levishchenko <[email protected]>
+ * @license   https://raw.github.com/ko-ko-ko/php-assert/master/LICENSE
+ */
+
+namespace KoKoKo\assert\exceptions;
+
+class InvalidArrayCountException extends ArgumentException
+{
+    /**
+     * @param string $variableName
+     * @param array  $variableValue
+     * @param int    $count
+     * @throws InvalidArrayException
+     * @throws InvalidIntException
+     * @throws InvalidNotEmptyException
+     * @throws InvalidStringException
+     * @throws NumberNotGreaterException
+     */
+    public function __construct($variableName, $variableValue, $count)
+    {
+        if (!is_string($variableName)) {
+            throw new InvalidStringException('variableName', $variableName);
+        } elseif (!is_array($variableValue)) {
+            throw new InvalidArrayException('variableValue', $variableValue);
+        } elseif (!is_int($count)) {
+            throw new InvalidIntException('count', $count);
+        } elseif ($count < 0) {
+            throw new NumberNotGreaterException('count', $count, 0);
+        }
+
+        parent::__construct(
+            sprintf(
+                'Variable "$%s" must contain: "%d" elements, actual count: "%d"',
+                $variableName,
+                $count,
+                count($variableValue)
+            )
+        );
+    }
+}

src/exceptions/InvalidIntOrStringException.php

@@ -0,0 +1,35 @@
+<?php
+/**
+ * @link      https://github.com/ko-ko-ko/php-assert
+ * @copyright Copyright (c) 2015 Roman Levishchenko <[email protected]>
+ * @license   https://raw.github.com/ko-ko-ko/php-assert/master/LICENSE
+ */
+
+namespace KoKoKo\assert\exceptions;
+
+class InvalidIntOrStringException extends ArgumentException
+{
+    /**
+     * @param string                        $variableName
+     * @param int|float|bool|resource|array $variableValue
+     * @throws InvalidNotIntAndNotStringException
+     * @throws InvalidNotEmptyException
+     * @throws InvalidStringException
+     */
+    public function __construct($variableName, $variableValue)
+    {
+        if (!is_string($variableName)) {
+            throw new InvalidStringException('variableName', $variableName);
+        } elseif (is_int($variableValue) || is_string($variableValue)) {
+            throw new InvalidNotIntAndNotStringException($variableName);
+        }
+
+        parent::__construct(
+            sprintf(
+                'Variable "$%s" must be: "int" or "string", actual type: "%s"',
+                $variableName,
+                gettype($variableValue)
+            )
+        );
+    }
+}