Collection > add() method > treat empty string as not provided index (same as null)

Miscellaneous > remove getCurlResponseWithHeaders() method

.env.dist

@@ -0,0 +1,15 @@
+# -----------------------------------------------------------------------------
+### Docker
+# -----------------------------------------------------------------------------
+
+#
+# All containers
+#
+DOCKER_CONTAINER_OWNER=meritoo
+DOCKER_CONTAINER_PROJECT=common-library
+
+#
+# PHP configuration:
+# - timezone
+#
+TIMEZONE=Europe/Warsaw

.gitignore

@@ -1,44 +1,58 @@
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+# Environment-related parameters
+# ------------------------------------------------------------------------------
+.env
+
+
+# ------------------------------------------------------------------------------
 ### Vendors
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 /vendor/
 
 
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 ### Composer
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+/composer.lock
 /composer.phar
 
 
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 ### Phing
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 /phing/properties
 
 
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 ### PHPUnit
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 /phpunit.xml
 
 
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
-### PHP Coding Standards Fixer generated files
+### PHP Coding Standards Fixer
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
+/.php_cs
 /.php_cs.cache
 
 
-# ----------------------------------------------------------------------------------------------------------------------
+# -----------------------------------------------------------------------------
+### Build files
+# -----------------------------------------------------------------------------
+/build/
+
+
+# ------------------------------------------------------------------------------
 ### Generated databases
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 /data/tmp
 *.sql
 *.sqlite
 
 
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 ### Compiled source
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 *.com
 *.class
 *.dll
@@ -47,23 +61,22 @@
 *.so
 
 
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 ### Shell scripts
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 /*.sh
 
 
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 ### JetBrains
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 /.idea
 
 
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 ### NetBeans template
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 nbproject/private/
-build/
 nbbuild/
 dist/
 nbdist/
@@ -71,9 +84,9 @@ nbactions.xml
 .nb-gradle/
 
 
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 ### OSX template
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 .DS_Store
 .AppleDouble
 .LSOverride
@@ -100,9 +113,9 @@ Temporary Items
 .apdisk
 
 
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 ### Linux template
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 *~
 
 # temporary files which can be created if a process still has a handle open of a deleted file
@@ -115,9 +128,9 @@ Temporary Items
 .Trash-*
 
 
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 ### Windows template
-# ----------------------------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------
 # Windows image file caches
 Thumbs.db
 ehthumbs.db

.php_cs.dist

@@ -1,13 +1,6 @@
 <?php
 
 $finder = PhpCsFixer\Finder::create()
-    /*
-     * Do not verify:
-     * - all DependencyInjection/Configuration classes: the Configuration.php files
-     * - autoloader from /app directory: autoload.php
-     */
-    ->notPath('/DependencyInjection\/Configuration\.php/')
-    ->notPath('/autoload\.php/')
     ->in([
         __DIR__ . '/src',
         __DIR__ . '/tests',
@@ -15,16 +8,20 @@ $finder = PhpCsFixer\Finder::create()
 
 return PhpCsFixer\Config::create()
     ->setRules([
-        '@Symfony'               => true,
+        '@Symfony'                            => true,
-        'phpdoc_summary'         => false,
+        'binary_operator_spaces'              => [
-        'phpdoc_separation'      => false,
-        'phpdoc_align'           => false,
-        'cast_spaces'            => false,
-        'binary_operator_spaces' => [
             'align_double_arrow' => true,
         ],
-        'concat_space'           => [
+        'blank_line_before_return'            => false,
+        'cast_spaces'                         => false,
+        'concat_space'                        => [
             'spacing' => 'one',
         ],
+        'phpdoc_add_missing_param_annotation' => true,
+        'phpdoc_align'                        => false,
+        'phpdoc_order'                        => true,
+        'phpdoc_separation'                   => false,
+        'phpdoc_summary'                      => false,
+        'trim_array_spaces'                   => false,
     ])
     ->setFinder($finder);

.styleci.yml

@@ -1,8 +0,0 @@
-preset: symfony
-
-disabled:
-    - phpdoc_annotation_without_dot
-    - cast_spaces
-    - concat_without_spaces
-    - blank_line_before_return
-    - trim_array_spaces

.travis.yml

@@ -5,8 +5,12 @@ php:
   - 7.0
   - 7.1
 
+before_install:
+  - sudo locale-gen de_DE.UTF-8 es_ES.UTF-8 en_GB.UTF-8 en_US.UTF-8 fr_FR.UTF-8 it_IT.UTF-8 pl_PL.UTF-8 ru_RU.UTF-8
+  - composer global require hirak/prestissimo
+
 install:
-  - composer install
+  - travis_wait 30 composer install -vvv
 
 script:
   - php ./vendor/bin/phpunit

CHANGELOG.md

@@ -0,0 +1,17 @@
+# Meritoo Common Library
+Common and useful classes, methods, exceptions etc.
+
+# 0.0.20
+
+1. Collection > add() method > treat empty string as not provided index (same as null)
+
+# 0.0.19
+
+1. Add this changelog
+2. Reorganize documentation & update [Readme](README.md)
+3. Docker: use project-related binaries globally
+4. StyleCI & PHP Coding Standards Fixer: update configuration
+5. Documentation > Docker > add paragraph for PHP Coding Standards Fixer
+6. Coding standard > fix automatically
+7. StyleCI configuration > fix bug "The provided fixer 'binary_operator_spaces' cannot be enabled again because it was already enabled"
+8. StyleCI > disable & remove

README.md

@@ -1,105 +1,26 @@
 # Meritoo Common Library
 Common and useful classes, methods, exceptions etc.
 
-[![Travis](https://img.shields.io/travis/rust-lang/rust.svg?style=flat-square)](https://travis-ci.org/meritoo/common-library) [![Packagist](https://img.shields.io/packagist/v/meritoo/common-library.svg?style=flat-square)](https://packagist.org/packages/meritoo/common-library) [![StyleCI](https://styleci.io/repos/101790028/shield?branch=master)](https://styleci.io/repos/101790028) [![license](https://img.shields.io/github/license/meritoo/common-library.svg?style=flat-square)](https://github.com/meritoo/common-library) [![GitHub commits](https://img.shields.io/github/commits-since/meritoo/common-library/0.0.1.svg?style=flat-square)](https://github.com/meritoo/common-library) [![Coverage Status](https://coveralls.io/repos/github/meritoo/common-library/badge.svg?branch=master)](https://coveralls.io/github/meritoo/common-library?branch=master)
+[![Travis](https://img.shields.io/travis/rust-lang/rust.svg?style=flat-square)](https://travis-ci.org/meritoo/common-library) [![Packagist](https://img.shields.io/packagist/v/meritoo/common-library.svg?style=flat-square)](https://packagist.org/packages/meritoo/common-library) [![license](https://img.shields.io/github/license/meritoo/common-library.svg?style=flat-square)](https://github.com/meritoo/common-library) [![GitHub commits](https://img.shields.io/github/commits-since/meritoo/common-library/0.0.1.svg?style=flat-square)](https://github.com/meritoo/common-library) [![Coverage Status](https://coveralls.io/repos/github/meritoo/common-library/badge.svg?branch=master)](https://coveralls.io/github/meritoo/common-library?branch=master)
 
-## Installation
+# Installation
 
 Run [Composer](https://getcomposer.org) to install this package in your project:
 
-    ```bash
+```bash
-    $ composer require meritoo/common-library
+composer require meritoo/common-library
-    ```
-
-> How to install Composer: https://getcomposer.org/download
-
-## Static methods
-
-This package contains a lot of class with static methods, so usage is not so complicated. Just run the static method who would you like to use. Example:
-
-```php
-use Meritoo\Common\Utilities\Arrays;
-
-$firstElement = Arrays::getFirstElement(['lorem', 'ipsum']);
-var_dump($firstElement); // string(5) "lorem"
 ```
 
-## Base test case with common methods and data providers
+> [How to install Composer?](https://getcomposer.org/download)
 
-Located here: `Meritoo\Common\Test\Base\BaseTestCase`. Just extend the `BaseTestCase` class and use it like in `Meritoo\Common\Test\Utilities\DateTest` class:
+# Usage
 
-```php
+1. [Base test case (with common methods and data providers)](docs/Base-test-case.md)
-class DateTest extends BaseTestCase
+2. [Collection of elements](docs/Collection-of-elements.md)
-{
+3. [Static methods](docs/Static-methods.md)
-    /**
-     * @param mixed $value Empty value, e.g. ""
-     * @dataProvider provideEmptyValue
-     */
-    public function testGetDateTimeEmptyValue($value)
-    {
-        self::assertFalse(Date::getDateTime($value));
-    }
 
-	(...)
+# Development
-}
-```
 
-or in `Meritoo\Common\Test\Utilities\MimeTypesTest` class:
+More information [you can find here](docs/Development.md)
-
-```php
-class MimeTypesTest extends BaseTestCase
-{
-	(...)
-
-    /**
-     * @param bool $mimeType The mime type, e.g. "video/mpeg"
-     * @dataProvider provideBooleanValue
-     */
-    public function testGetExtensionBooleanMimeType($mimeType)
-    {
-        self::assertEquals('', MimeTypes::getExtension($mimeType));
-    }
-
-	(...)
-}
-```
-
-## Collection of elements
-
-Located here: `Meritoo\Common\Collection\Collection`. It's a set of some elements, e.g. objects. It's iterable and countable. Provides very useful methods. Some of them:
-- `getFirst()` - returns the first element in the collection
-- `getLast()` - returns the last element in the collection
-- `isEmpty()` - returns information if collection is empty
-- `add($element, $index = null)` - adds given element (at the end of collection)
-- `addMultiple($elements, $useIndexes = false)` - adds given elements (at the end of collection)
-- `prepend($element)` - prepends given element (adds given element at the beginning of collection)
-- `remove($element)` - removes given element
-
-Examples of usage below.
-
-#### An empty collection
-
-```php
-use Meritoo\Common\Collection\Collection;
-
-$emptyCollection = new Collection();
-var_dump($emptyCollection->isEmpty()); // bool(true)
-```
-
-#### Simple collection
-
-```php
-use Meritoo\Common\Collection\Collection;
-
-$elements = [
-    'lorem',
-    'ipsum',
-    123 => 'dolor',
-    345 => 'sit',
-];
-
-$simpleCollection = new Collection($elements);
-var_dump($simpleCollection->has('dolor')); // bool(true)
-```
 
 Enjoy!

build.xml

@@ -4,10 +4,10 @@
     <if>
         <available file="phing/properties" property="custom.properties.available"/>
         <then>
-            <property file="phing/properties" />
+            <property file="phing/properties"/>
         </then>
         <else>
-            <property file="phing/properties.dist" />
+            <property file="phing/properties.dist"/>
         </else>
     </if>
 
@@ -18,12 +18,12 @@
 
     <!-- Build app -->
     <target name="build:app" description="Prepares app to build and tests">
-        <phing phingfile="phing/app.xml" haltonfailure="true" />
+        <phing phingfile="phing/app.xml" haltonfailure="true"/>
     </target>
 
     <!-- Build tests -->
     <target name="build:tests" description="Runs all tests, checks and creates docs">
-        <phing phingfile="phing/tests.xml" haltonfailure="true" />
+        <phing phingfile="phing/tests.xml" haltonfailure="true"/>
 
         <!--
         Conditional running of tests.

composer.json

@@ -2,7 +2,7 @@
     "name": "meritoo/common-library",
     "description": "Useful classes, methods, extensions etc.",
     "license": "MIT",
-    "version": "0.0.8",
+    "version": "0.0.20",
     "authors": [
         {
             "name": "Meritoo.pl",
@@ -11,24 +11,30 @@
         }
     ],
     "require": {
-        "php": ">=5.6.0",
+        "php": ">=5.5.9",
         "doctrine/orm": "^2.5",
-        "gedmo/doctrine-extensions": "^2.4",
+        "gedmo/doctrine-extensions": "^2.4"
-        "symfony/http-foundation": "^3.3"
     },
     "require-dev": {
-        "phpunit/phpunit": "^5.7",
+        "friendsofphp/php-cs-fixer": "^2.2",
-        "squizlabs/php_codesniffer": "^2.9",
-        "phpmd/phpmd": "^2.6",
-        "sebastian/phpcpd": "^3.0",
         "pdepend/pdepend": "^2.5",
-        "phploc/phploc": "^4.0",
+        "phploc/phploc": "^2.1",
-        "friendsofphp/php-cs-fixer": "^2.6"
+        "phpmd/phpmd": "^2.6",
+        "phpunit/phpunit": "^4.8",
+        "sebastian/phpcpd": "^2.0",
+        "squizlabs/php_codesniffer": "^2.9"
     },
     "autoload": {
         "psr-4": {
-            "Meritoo\\Common\\": "src/Meritoo/Common/",
+            "Meritoo\\Common\\": "src/"
-            "Meritoo\\Common\\Test\\": "tests/Meritoo/Common/Test/"
         }
+    },
+    "autoload-dev": {
+        "psr-4": {
+            "Meritoo\\Common\\Test\\": "tests/"
+        }
+    },
+    "config": {
+        "sort-packages": true
     }
 }

docker-compose.yml

@@ -0,0 +1,20 @@
+version: '3'
+
+services:
+    php-cli:
+        image: ${DOCKER_CONTAINER_OWNER}/${DOCKER_CONTAINER_PROJECT}-php-cli
+        container_name: ${DOCKER_CONTAINER_OWNER}-${DOCKER_CONTAINER_PROJECT}-php-cli
+        entrypoint: php
+        command: -S 0.0.0.0:9999
+        build:
+            context: ./docker/config
+            args:
+                - TIMEZONE=$TIMEZONE
+        volumes:
+            - .:/project
+    composer:
+        image: ${DOCKER_CONTAINER_OWNER}/${DOCKER_CONTAINER_PROJECT}-php-cli
+        container_name: ${DOCKER_CONTAINER_OWNER}-${DOCKER_CONTAINER_PROJECT}-composer
+        entrypoint: composer
+        volumes:
+            - .:/project

docker/config/Dockerfile

@@ -0,0 +1,131 @@
+FROM php:5.5-cli
+MAINTAINER Meritoo <github@meritoo.pl>
+
+#
+# Tools & libraries
+#
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends \
+        vim \
+        git \
+        unzip \
+        libicu-dev \
+        locales \
+    && apt-get clean \
+    && rm -rf \
+        /var/lib/apt/lists/* \
+        /tmp/* \
+        /var/tmp/*
+
+#
+# Generating locales:
+# - de_DE
+# - es_ES
+# - en_GB
+# - en_US
+# - fr_FR
+# - it_IT
+# - pl_PL
+# - ru_RU
+#
+RUN sed -i 's/^# de_DE/de_DE/g; \
+            s/^# es_ES/es_ES/g; \
+            s/^# en_GB/en_GB/g; \
+            s/^# en_US/en_US/g; \
+            s/^# fr_FR/fr_FR/g; \
+            s/^# it_IT/it_IT/g; \
+            s/^# pl_PL/pl_PL/g; \
+            s/^# ru_RU/ru_RU/g;' /etc/locale.gen \
+    && locale-gen
+
+#
+# Set default language
+#
+# Required to avoid problem with using strange language by error messages.
+# Example: "chmod(): Aucun fichier ou dossier de ce type"
+#
+ENV LANGUAGE=en_US.UTF-8
+
+#
+# PHP extensions
+#
+RUN docker-php-ext-install \
+    intl \
+    mbstring
+
+#
+# PHP extensions (PECL):
+# - Xdebug
+#
+RUN pecl install \
+        xdebug-2.5.5 \
+    && docker-php-ext-enable \
+        xdebug
+
+COPY xdebug.ini /usr/local/etc/php/conf.d/docker-php-ext-xdebug.ini
+
+#
+# PHP configuration:
+# - default configuration
+# - timezone
+#
+COPY php.ini /usr/local/etc/php/php.ini
+ARG TIMEZONE
+RUN ln -snf /usr/share/zoneinfo/${TIMEZONE} /etc/localtime \
+    && echo ${TIMEZONE} > /etc/timezone \
+    && printf '[PHP]\ndate.timezone = "%s"\n' ${TIMEZONE} > /usr/local/etc/php/conf.d/tzone.ini \
+    && "date"
+#RUN echo "\n""date.timezone = $TIMEZONE""\n" >> /usr/local/etc/php/php.ini
+
+#
+# Phing
+#
+RUN pear channel-discover pear.phing.info \
+    && pear install [--alldeps] phing/phing
+
+#
+# Composer - environment variables:
+# - disable warning about running commands as root/super user
+# - disable automatic clearing of sudo sessions
+#
+# More:
+# https://getcomposer.org/doc/03-cli.md#composer-allow-superuser
+#
+ENV COMPOSER_ALLOW_SUPERUSER 1
+
+#
+# Composer + https://packagist.org/packages/hirak/prestissimo package
+#
+RUN php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');" \
+    && php -r "if (hash_file('SHA384', 'composer-setup.php') === \
+        '544e09ee996cdf60ece3804abc52599c22b1f40f4323403c44d44fdfdd586475ca9813a858088ffbc1f233e9b180f061') { echo \
+        'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;" \
+    && php composer-setup.php --install-dir=/usr/local/bin --filename=composer \
+    && php -r "unlink('composer-setup.php');" \
+    && composer global require \
+        --no-plugins \
+        --no-scripts \
+        --no-progress \
+        --no-suggest \
+        --no-interaction \
+        --prefer-dist \
+        --optimize-autoloader \
+        --classmap-authoritative \
+        hirak/prestissimo \
+    && rm -rf ~/.composer/cache/* \
+    && composer clear-cache \
+    && composer --version
+
+#
+# Bash
+#
+RUN sed -i 's/^# export/export/g; \
+            s/^# alias/alias/g;' ~/.bashrc \
+    && echo 'COLUMNS=200'"\n" >> ~/.bashrc
+
+#
+# Use project-related binaries globally
+#
+ENV PATH="/project/vendor/bin:${PATH}"
+
+WORKDIR /project

docker/config/php.ini

@@ -0,0 +1,3 @@
+display_errors = On
+display_startup_errors = On
+error_reporting = E_ALL

docker/config/xdebug.ini

@@ -0,0 +1,6 @@
+[xdebug]
+zend_extension=xdebug.so
+
+xdebug.remote_enable=1
+xdebug.remote_port=9001
+xdebug.remote_host=10.254.254.254

docs/Base-test-case.md

@@ -0,0 +1,50 @@
+# Meritoo Common Library
+Common and useful classes, methods, exceptions etc.
+
+# Base test case (with common methods and data providers)
+
+Located here: `Meritoo\Common\Test\Base\BaseTestCase`. Just extend the `BaseTestCase` class and use it like in `Meritoo\Common\Test\Utilities\DateTest` class:
+
+```php
+class DateTest extends BaseTestCase
+{
+    /**
+     * @param mixed $value Empty value, e.g. ""
+     * @dataProvider provideEmptyValue
+     */
+    public function testGetDateTimeEmptyValue($value)
+    {
+        self::assertFalse(Date::getDateTime($value));
+    }
+
+	(...)
+}
+```
+
+or in `Meritoo\Common\Test\Utilities\MimeTypesTest` class:
+
+```php
+class MimeTypesTest extends BaseTestCase
+{
+	(...)
+
+    /**
+     * @param bool $mimeType The mime type, e.g. "video/mpeg"
+     * @dataProvider provideBooleanValue
+     */
+    public function testGetExtensionBooleanMimeType($mimeType)
+    {
+        self::assertEquals('', MimeTypes::getExtension($mimeType));
+    }
+
+	(...)
+}
+```
+
+# More
+
+1. [**Base test case (with common methods and data providers)**](Base-test-case.md)
+2. [Collection of elements](Collection-of-elements.md)
+3. [Static methods](Static-methods.md)
+
+[‹ Back to `Readme`](../README.md)

docs/Collection-of-elements.md

@@ -0,0 +1,48 @@
+# Meritoo Common Library
+Common and useful classes, methods, exceptions etc.
+
+# Collection of elements
+
+Located here: `Meritoo\Common\Collection\Collection`. It's a set of some elements, e.g. objects. It's iterable and countable. Provides very useful methods. Some of them:
+- `getFirst()` - returns the first element in the collection
+- `getLast()` - returns the last element in the collection
+- `isEmpty()` - returns information if collection is empty
+- `add($element, $index = null)` - adds given element (at the end of collection)
+- `addMultiple($elements, $useIndexes = false)` - adds given elements (at the end of collection)
+- `prepend($element)` - prepends given element (adds given element at the beginning of collection)
+- `remove($element)` - removes given element
+
+Examples of usage below.
+
+### An empty collection
+
+```php
+use Meritoo\Common\Collection\Collection;
+
+$emptyCollection = new Collection();
+var_dump($emptyCollection->isEmpty()); // bool(true)
+```
+
+### Simple collection
+
+```php
+use Meritoo\Common\Collection\Collection;
+
+$elements = [
+    'lorem',
+    'ipsum',
+    123 => 'dolor',
+    345 => 'sit',
+];
+
+$simpleCollection = new Collection($elements);
+var_dump($simpleCollection->has('dolor')); // bool(true)
+```
+
+# More
+
+1. [Base test case (with common methods and data providers)](Base-test-case.md)
+2. [**Collection of elements**](Collection-of-elements.md)
+3. [Static methods](Static-methods.md)
+
+[‹ Back to `Readme`](../README.md)

docs/Development.md

@@ -0,0 +1,118 @@
+# Meritoo Common Library
+Development-related information
+
+# Requirements
+
+* [Docker](https://www.docker.com)
+* Your favourite IDE :)
+
+# Getting started
+
+1. Build, create and start Docker's containers by running command:
+
+    ```bash
+    docker-compose up -d
+    ```
+
+2. Install packages by running command:
+
+    ```bash
+    docker-compose run composer install
+    ```
+
+> [What is Docker?](https://www.docker.com/what-docker)
+
+# Composer
+
+Available as `composer` service. You can run any Composer's command using the `composer` service:
+
+```bash
+docker-compose run composer <command>
+```
+
+Examples below.
+
+##### Install packages
+
+```bash
+docker-compose run composer install
+```
+
+##### Update packages
+
+```bash
+docker-compose run composer update
+```
+
+##### Add package
+
+```bash
+docker-compose run composer require <vendor>/<package>
+```
+
+##### Remove package
+
+```bash
+docker-compose run composer remove <vendor>/<package>
+```
+
+# Coding Standards Fixer
+
+Fix coding standard by running command:
+
+```bash
+docker-compose exec php-cli php-cs-fixer fix
+```
+
+Omit cache and run the Fixer from scratch by running command:
+
+```bash
+docker-compose exec php-cli rm .php_cs.cache && docker-compose exec php-cli php-cs-fixer fix
+```
+
+> [Want more?](https://cs.sensiolabs.org)
+
+# Tests
+
+### Prerequisites
+
+Install required packages by running command: `docker-compose run composer install`.
+
+### Running tests
+
+#### Simply & quick, without code coverage
+
+Tests are running using Docker and `php-cli` service defined in `docker-compose.yml`. Example:
+
+```bash
+docker-compose exec php-cli phpunit --no-coverage
+```
+
+You can also run them in container. In this case you have to run 2 commands:
+1. Enter container:
+
+    ```bash
+	docker-compose exec php-cli bash
+    ```
+
+2. Run tests:
+
+    ```bash
+    phpunit --no-coverage
+    ```
+
+#### With code coverage
+
+```bash
+docker-compose exec php-cli phpunit
+```
+
+# Other
+
+Rebuild project and run tests by running command:
+
+```bash
+docker-compose exec php-cli phing
+```
+
+[&lsaquo; Back to `Readme`](../README.md)

docs/Static-methods.md

@@ -0,0 +1,21 @@
+# Meritoo Common Library
+Common and useful classes, methods, exceptions etc.
+
+# Static methods
+
+This package contains a lot of class with static methods, so usage is not so complicated. Just run the static method who would you like to use. Example:
+
+```php
+use Meritoo\Common\Utilities\Arrays;
+
+$firstElement = Arrays::getFirstElement(['lorem', 'ipsum']);
+var_dump($firstElement); // string(5) "lorem"
+```
+
+# More
+
+1. [Base test case (with common methods and data providers)](Base-test-case.md)
+2. [Collection of elements](Collection-of-elements.md)
+3. [**Static methods**](Static-methods.md)
+
+[‹ Back to `Readme`](../README.md)

phing/app.xml

@@ -4,10 +4,10 @@
     <if>
         <available file="phing/properties" property="custom.properties.available"/>
         <then>
-            <property file="phing/properties" />
+            <property file="phing/properties"/>
         </then>
         <else>
-            <property file="phing/properties.dist" />
+            <property file="phing/properties.dist"/>
         </else>
     </if>
 
@@ -21,9 +21,9 @@
             depends="app:composer, app:vendors, app:checkout"
             description="Prepares app to build." />
 
-    <!-- Check / update composer -->
+    <!-- Updates Composer and validates composer.* files -->
-    <target name="app:composer" description="Checks / updates composer">
+    <target name="app:composer" description="Updates Composer and validates composer.* files">
-        <echo msg="Checking / updating composer..." />
+        <echo msg="Updating Composer and validating composer.* files..." />
 
         <if>
             <available file="composer.phar" />
@@ -42,7 +42,14 @@
                 </if>
             </else>
         </if>
+
+        <!-- Update Composer -->
         <composer command="selfupdate" />
+
+        <!-- Validate Composer -->
+        <composer command="validate">
+            <arg line="--no-check-all --strict" />
+        </composer>
     </target>
 
     <!-- Project Install/update vendors -->
@@ -68,6 +75,8 @@
             <then>
                 <composer php="${composer.php}" composer="${composer.path}" command="install">
                     <arg value="--optimize-autoloader" />
+                    <arg value="--prefer-dist" />
+                    <arg value="--classmap-authoritative" />
                 </composer>
             </then>
             <else>

phing/properties.dist

@@ -28,7 +28,13 @@ assets.installWithSymlink = true
 
 # Clear cache with the "warmup" option
 #
-cache.clearWithWarmup = true
+# The cache:clear command should always be called with the --no-warmup option. Warmup should be done via the cache:warmup command.
+# https://github.com/symfony/symfony/blob/master/UPGRADE-3.3.md#frameworkbundle
+#
+# Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+# 2017-06-06
+#
+cache.clearWithWarmup = false
 
 # --------------------------------------------------------------------------------
 # Composer
@@ -85,40 +91,15 @@ dir.reports.coverage = ${dir.reports}/phpunit_coverage
 # Data directories
 # --------------------------------------------------------------------------------
 
-dir.data.tests = ${dir.data}/tests
 dir.data.temporary = ${dir.data}/tmp
 
 # --------------------------------------------------------------------------------
 # Testing
 # --------------------------------------------------------------------------------
 
-# Test database path
+# Path of the framework used to run unit tests
 #
-tests.database = ${dir.data.temporary}/database.sqlite
+tests.framework.path = ./vendor/bin/phpunit --verbose --no-coverage --testdox
-
-#
-# Disabled, because unnecessary right now
-# PHPUnit is installed and loaded by Composer
-#
-# Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
-# 2017-02-22
-#
-# Run PHPUnit using exec task instead of phpunitTask
-#phpunit.useExec = false
-
-#
-# Disabled, because unnecessary right now
-# We want generate code coverage always
-#
-# Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
-# 2017-02-22
-#
-# Collect coverage data during tests
-#phpunit.withCoverage = true
-
-# Path of the PHPUnit (https://phpunit.de)
-#
-phpUnit.path = ./vendor/bin/phpunit
 
 # Path of the PHP Coding Standards Fixer (http://cs.sensiolabs.org)
 #

phing/tests.xml

@@ -13,10 +13,10 @@
     <if>
         <available file="phing/properties" property="custom.properties.available"/>
         <then>
-            <property file="phing/properties" />
+            <property file="phing/properties"/>
         </then>
         <else>
-            <property file="phing/properties.dist" />
+            <property file="phing/properties.dist"/>
         </else>
     </if>
 
@@ -87,7 +87,7 @@
 
     <!-- Test target -->
     <target name="build:test"
-            depends="test:phpunit"
+            depends="test:unit"
             description="Executes all tests" />
 
     <!-- Project build clean -->
@@ -103,8 +103,8 @@
         <!--<mkdir dir="${dir.docs}" />-->
         <!--<mkdir dir="${dir.docs.phpdoc2}" />-->
         <mkdir dir="${dir.reports}" />
-        <mkdir dir="${dir.reports.coverage}" />
         <mkdir dir="${dir.reports.pdepend}" />
+        <mkdir dir="${dir.reports.coverage}"/>
     </target>
 
     <!-- PHPDocumentor2 API documentation target -->
@@ -212,94 +212,9 @@
     </target>
 
     <!-- Unit tests -->
-    <target name="test:phpunit" description="Executes PHPUnit tests">
+    <target name="test:unit" description="Executes unit tests">
-        <!-- Check test database -->
-        <if>
-            <not>
-                <available file="${dir.data.tests}" type="dir" property="dir.data.tests.available" />
-            </not>
-            <then>
-                <mkdir dir="${dir.data.tests}" />
-            </then>
-        </if>
-        <if>
-            <not>
-                <available file="${tests.database}" property="tests.database.available" />
-            </not>
-            <then>
-                <touch file="${tests.database}" />
-            </then>
-        </if>
         <echo msg="Running unit tests..." />
-        <coverage-setup database="${dir.reports.coverage}/coverage.db">
+        <exec command="${tests.framework.path}" passthru="true"/>
-            <fileset refid="sourcecode" />
-        </coverage-setup>
-        <exec command="${phpUnit.path} --verbose --configuration ${project.basedir}/phpunit.xml.dist" passthru="true" />
-        <!--
-        I have to use ExecTask to run PHPUnit instead of PHPUnitTask, because tests are not running if PHPUnitTask is
-        used (don't know why):
-        Total tests run: 0, Failures: 0, Errors: 0, Incomplete: 0, Skipped: 0
-
-        Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
-        2017-02-23
-
-        <phpunit configuration="${project.basedir}/phpunit.xml.dist" printsummary="true">
-            <formatter type="xml" todir="${dir.reports}" outfile="phpunit.xml" />
-            <formatter type="plain" todir="${dir.reports}" outfile="phpunit.txt" />
-            <formatter type="clover" todir="${dir.reports.coverage}" />
-            <formatter type="summary" todir="${dir.reports}" outfile="phpunit_summary.txt" />
-        </phpunit>
-        -->
-
-        <!--
-        Previous / old version
-
-        Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
-        2017-02-22
-
-        <if>
-            <istrue value="${phpunit.useExec}" />
-            <then>
-                <if>
-                    <istrue value="${phpunit.withCoverage}" />
-                    <then>
-                        <echo message="Running tests with code coverage..." />
-                        <exec command="phpunit \-\-log-junit ${dir.reports}/phpunit.xml \-\-coverage-clover ${dir.reports.coverage}/clover-coverage.xml \-\-coverage-crap4j ${dir.reports.coverage}/crap4j-coverage.xml \-\-coverage-html ${dir.reports.coverage}/ -c ${project.basedir} \-\-colors" passthru="true" checkreturn="true" />
-                    </then>
-                    <else>
-                        <echo message="Running tests without code coverage..." />
-                        <exec command="phpunit \-\-log-junit ${dir.reports}/phpunit.xml -c ${project.basedir} \-\-colors" passthru="true" checkreturn="true" />
-                    </else>
-                </if>
-            </then>
-            <else>
-                <if>
-                    <istrue value="${phpunit.withCoverage}" />
-                    <then>
-                        <echo message="Running tests with code coverage..." />
-                        <coverage-setup database="${dir.reports.coverage}/coverage.db">
-                            <fileset refid="sourcecode" />
-                        </coverage-setup>
-                        <phpunit printsummary="true" codecoverage="true">
-                            <formatter type="xml" todir="${dir.reports}" outfile="phpunit.xml" />
-                            <formatter type="plain" todir="${dir.reports}" outfile="phpunit.txt" />
-                            <formatter type="clover" todir="${dir.reports.coverage}" />
-                            <formatter type="summary" todir="${dir.reports}" outfile="phpunit_summary.txt" />
-                        </phpunit>
-                    </then>
-                    <else>
-                        <echo message="Running tests without code coverage..." />
-                        <phpunit printsummary="true">
-                            <formatter todir="${dir.reports}" type="xml" outfile="phpunit.xml" />
-                            <batchtest>
-                                <fileset refid="tests" />
-                            </batchtest>
-                        </phpunit>
-                    </else>
-                </if>
-            </else>
-        </if>
-        -->
     </target>
 
     <!-- Checkout and finalization -->

phpunit.xml.dist

@@ -1,16 +1,34 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
-<phpunit backupGlobals="false"
+<phpunit
-         backupStaticAttributes="false"
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         colors="true"
+        xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/4.8/phpunit.xsd"
-         convertErrorsToExceptions="true"
+        backupGlobals="true"
-         convertNoticesToExceptions="true"
+        backupStaticAttributes="false"
-         convertWarningsToExceptions="true"
+        bootstrap="./vendor/autoload.php"
-         processIsolation="false"
+        cacheTokens="false"
-         stopOnFailure="false"
+        colors="true"
-         syntaxCheck="true"
+        convertErrorsToExceptions="true"
-         bootstrap="./vendor/autoload.php"
+        convertNoticesToExceptions="true"
+        convertWarningsToExceptions="true"
+        forceCoversAnnotation="false"
+        mapTestClassNameToCoveredClassName="false"
+        processIsolation="false"
+        stopOnError="false"
+        stopOnFailure="false"
+        stopOnIncomplete="false"
+        stopOnSkipped="false"
+        stopOnRisky="false"
+        testSuiteLoaderClass="PHPUnit_Runner_StandardTestSuiteLoader"
+        timeoutForSmallTests="1"
+        timeoutForMediumTests="10"
+        timeoutForLargeTests="60"
+        verbose="true"
 >
+    <php>
+        <ini name="error_reporting" value="-1"/>
+    </php>
+
     <testsuites>
         <testsuite name="Meritoo Package - Main Test Suite">
             <directory>./tests/</directory>
@@ -30,6 +48,6 @@
     </groups>
 
     <logging>
-        <log type="coverage-html" target="./build/logs/phpunit_coverage/html" />
+        <log type="coverage-html" target="./build/logs/phpunit_coverage/html"/>
     </logging>
 </phpunit>

src/Collection/Collection.php

@@ -109,7 +109,7 @@ class Collection implements Countable, ArrayAccess, IteratorAggregate
      */
     public function add($element, $index = null)
     {
-        if (null === $index) {
+        if (null === $index || '' === $index) {
             $this->elements[] = $element;
         } else {
             $this->elements[$index] = $element;

src/Exception/Bundle/IncorrectBundleNameException.php

@@ -0,0 +1,34 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Exception\Bundle;
+
+use Exception;
+
+/**
+ * An exception used while name of bundle is incorrect
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class IncorrectBundleNameException extends Exception
+{
+    /**
+     * Class constructor
+     *
+     * @param string $bundleName Incorrect name of bundle
+     */
+    public function __construct($bundleName)
+    {
+        $template = 'Name of bundle \'%s\' is incorrect. It should start with big letter and end with "Bundle". Is'
+            . ' there everything ok?';
+
+        $message = sprintf($template, $bundleName);
+        parent::__construct($message);
+    }
+}

src/Exception/File/EmptyFileException.php

@@ -0,0 +1,31 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Exception\File;
+
+/**
+ * An exception used while file with given path is empty (has no content)
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class EmptyFileException extends \Exception
+{
+    /**
+     * Class constructor
+     *
+     * @param string $emptyFilePath Path of the empty file
+     */
+    public function __construct($emptyFilePath)
+    {
+        $template = 'File with path \'%s\' is empty (has no content). Did you provide path of proper file?';
+        $message = sprintf($template, $emptyFilePath);
+
+        parent::__construct($message);
+    }
+}

src/Exception/File/EmptyFilePathException.php

@@ -0,0 +1,26 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Exception\File;
+
+/**
+ * An exception used while path of given file is empty
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class EmptyFilePathException extends \Exception
+{
+    /**
+     * Class constructor
+     */
+    public function __construct()
+    {
+        parent::__construct('Path of the file is empty. Did you provide path of proper file?');
+    }
+}

src/Exception/File/NotExistingFileException.php

@@ -0,0 +1,31 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Exception\File;
+
+/**
+ * An exception used while file with given path does not exist
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class NotExistingFileException extends \Exception
+{
+    /**
+     * Class constructor
+     *
+     * @param string $notExistingFilePath Path of not existing (or not readable) file
+     */
+    public function __construct($notExistingFilePath)
+    {
+        $template = 'File with path \'%s\' does not exist (or is not readable). Did you provide path of proper file?';
+        $message = sprintf($template, $notExistingFilePath);
+
+        parent::__construct($message);
+    }
+}

src/Exception/Method/DisabledMethodException.php

@@ -0,0 +1,38 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Exception\Method;
+
+use Exception;
+
+/**
+ * An exception used while method cannot be called, because is disabled
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class DisabledMethodException extends Exception
+{
+    /**
+     * Class constructor
+     *
+     * @param string $disabledMethod    Name of the disabled method
+     * @param string $alternativeMethod (optional) Name of the alternative method
+     */
+    public function __construct($disabledMethod, $alternativeMethod = '')
+    {
+        $template = 'Method %s() cannot be called, because is disabled.';
+
+        if (!empty($alternativeMethod)) {
+            $template .= ' Use %s() instead.';
+        }
+
+        $message = sprintf($template, $disabledMethod, $alternativeMethod);
+        parent::__construct($message);
+    }
+}

src/Exception/Reflection/CannotResolveClassNameException.php

@@ -21,7 +21,7 @@ class CannotResolveClassNameException extends Exception
     /**
      * Class constructor
      *
-     * @param array|object|string $source   Source of the class's / trait's name. It cane be an array of objects,
+     * @param array|object|string $source   Source of the class's / trait's name. It can be an array of objects,
      *                                      namespaces, object or namespace.
      * @param bool                $forClass (optional) If is set to true, message of this exception for class is
      *                                      prepared. Otherwise - for trait.

src/Exception/Regex/InvalidHtmlAttributesException.php

@@ -0,0 +1,29 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Exception\Regex;
+
+/**
+ * An exception used while html attributes are invalid
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class InvalidHtmlAttributesException extends \Exception
+{
+    /**
+     * Class constructor
+     *
+     * @param string $htmlAttributes Invalid html attributes
+     */
+    public function __construct($htmlAttributes)
+    {
+        $message = sprintf('HTML attributes \'%s\' are invalid. Is there everything ok?', $htmlAttributes);
+        parent::__construct($message);
+    }
+}

src/Meritoo/Common/Utilities/Bundle.php

@@ -1,46 +0,0 @@
-<?php
-
-/**
- * (c) Meritoo.pl, http://www.meritoo.pl
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-namespace Meritoo\Common\Utilities;
-
-/**
- * Useful methods for bundle
- *
- * @author     Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
- * @copyright  Meritoo.pl
- */
-class Bundle
-{
-    /**
-     * Returns path to view / template of given bundle
-     *
-     * @param string $viewPath   Path of the view / template, e.g. "MyDirectory/my-template"
-     * @param string $bundleName Name of the bundle, e.g. "MyExtraBundle"
-     * @param string $extension  (optional) Extension of the view / template
-     * @return string|null
-     */
-    public static function getBundleViewPath($viewPath, $bundleName, $extension = 'html.twig')
-    {
-        /*
-         * Unknown path, extension of the view / template or name of the bundle?
-         * Nothing to do
-         */
-        if (empty($viewPath) || empty($bundleName) || empty($extension)) {
-            return null;
-        }
-
-        /*
-         * Path of the view / template doesn't end with given extension?
-         */
-        if (!Regex::endsWith($viewPath, $extension)) {
-            $viewPath = sprintf('%s.%s', $viewPath, $extension);
-        }
-
-        return sprintf('%s:%s', $bundleName, $viewPath);
-    }
-}

src/Meritoo/Common/Utilities/Repository.php

@@ -1,109 +0,0 @@
-<?php
-
-/**
- * (c) Meritoo.pl, http://www.meritoo.pl
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-namespace Meritoo\Common\Utilities;
-
-use Doctrine\ORM\EntityRepository;
-use Doctrine\ORM\QueryBuilder;
-
-/**
- * Useful methods for repository
- *
- * @author     Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
- * @copyright  Meritoo.pl
- */
-class Repository
-{
-    /**
-     * Replenishes positions of given items
-     *
-     * @param array $items  The items
-     * @param bool  $asLast (optional) If is set to true, items are placed at the end. Otherwise - at the top.
-     * @param bool  $force  (optional) If is set to true, positions are set even there is no extreme position.
-     *                      Otherwise - if extreme position is not found (is null) replenishment is stopped / skipped.
-     */
-    public static function replenishPositions($items, $asLast = true, $force = false)
-    {
-        $position = self::getExtremePosition($items, $asLast);
-
-        if (null === $position && $force) {
-            $position = 0;
-        }
-
-        if (null !== $position && !empty($items)) {
-            foreach ($items as $item) {
-                if (method_exists($item, 'getPosition')) {
-                    if (null === $item->getPosition()) {
-                        if ($asLast) {
-                            ++$position;
-                        } else {
-                            --$position;
-                        }
-
-                        if (method_exists($item, 'setPosition')) {
-                            $item->setPosition($position);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * Returns extreme position (max or min) of given items
-     *
-     * @param array $items The items
-     * @param bool  $max   (optional) If is set to true, maximum value is returned. Otherwise - minimum.
-     * @return int
-     */
-    public static function getExtremePosition($items, $max = true)
-    {
-        $extreme = null;
-
-        if (!empty($items)) {
-            foreach ($items as $item) {
-                if (Reflection::hasMethod($item, 'getPosition')) {
-                    $position = $item->getPosition();
-
-                    if ($max) {
-                        if ($position > $extreme) {
-                            $extreme = $position;
-                        }
-                    } else {
-                        if ($position < $extreme) {
-                            $extreme = $position;
-                        }
-                    }
-                }
-            }
-        }
-
-        return $extreme;
-    }
-
-    /**
-     * Returns query builder for given entity's repository.
-     * The entity should contain given property, e.g. "name".
-     *
-     * @param EntityRepository $repository Repository of the entity
-     * @param string           $property   (optional) Name of property used by the ORDER BY clause
-     * @param string           $direction  (optional) Direction used by the ORDER BY clause ("ASC" or "DESC")
-     * @return QueryBuilder
-     */
-    public static function getEntityOrderedQueryBuilder(
-        EntityRepository $repository,
-        $property = 'name',
-        $direction = 'ASC'
-    ) {
-        $alias = 'qb';
-
-        return $repository
-            ->createQueryBuilder($alias)
-            ->orderBy(sprintf('%s.%s', $alias, $property), $direction);
-    }
-}

src/Test/Base/BaseTestCase.php

@@ -0,0 +1,23 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Base;
+
+use Meritoo\Common\Traits\Test\Base\BaseTestCaseTrait;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Base test case with common methods and data providers
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+abstract class BaseTestCase extends TestCase
+{
+    use BaseTestCaseTrait;
+}

src/Test/Base/BaseTypeTestCase.php

@@ -0,0 +1,22 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Base;
+
+use Meritoo\Common\Traits\Test\Base\BaseTypeTestCaseTrait;
+
+/**
+ * Base test case for the type of something
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+abstract class BaseTypeTestCase extends BaseTestCase
+{
+    use BaseTypeTestCaseTrait;
+}

src/Traits/Test/Base/BaseTestCaseTrait.php

@@ -6,24 +6,34 @@
  * file that was distributed with this source code.
  */
 
-namespace Meritoo\Common\Test\Base;
+namespace Meritoo\Common\Traits\Test\Base;
 
 use DateTime;
 use Generator;
 use Meritoo\Common\Exception\Type\UnknownOopVisibilityTypeException;
 use Meritoo\Common\Type\OopVisibilityType;
-use PHPUnit\Framework\TestCase;
+use Meritoo\Common\Utilities\Miscellaneous;
 use ReflectionClass;
+use ReflectionException;
 use ReflectionMethod;
+use stdClass;
 
 /**
- * Base test case with common methods and data providers
+ * BaseTestCaseTrait
+ * Created on 2017-11-02
  *
  * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
  * @copyright Meritoo.pl
  */
-abstract class BaseTestCase extends TestCase
+trait BaseTestCaseTrait
 {
+    /**
+     * Path of directory with data used by test cases
+     *
+     * @var string
+     */
+    private static $testsDataDirPath = 'data/tests';
+
     /**
      * Provides an empty value
      *
@@ -95,6 +105,26 @@ abstract class BaseTestCase extends TestCase
         yield['surprise/me/one/more/time.txt'];
     }
 
+    /**
+     * Provides non scalar value, e.g. [] or null
+     *
+     * @return Generator
+     */
+    public function provideNonScalarValue()
+    {
+        yield[
+            [],
+        ];
+
+        yield[
+            null,
+        ];
+
+        yield[
+            new stdClass(),
+        ];
+    }
+
     /**
      * Returns path of file used by tests.
      * It should be placed in /data/tests directory of this project.
@@ -103,13 +133,18 @@ abstract class BaseTestCase extends TestCase
      * @param string $directoryPath (optional) Path of directory containing the file
      * @return string
      */
-    public function getFilePathToTests($fileName, $directoryPath = '')
+    public function getFilePathForTesting($fileName, $directoryPath = '')
     {
-        if (!empty($directoryPath)) {
+        $rootPath = Miscellaneous::getProjectRootPath();
-            $directoryPath = '/' . $directoryPath;
-        }
 
-        return sprintf('%s/../../../../../data/tests/%s%s', __DIR__, $fileName, $directoryPath);
+        $paths = [
+            $rootPath,
+            self::$testsDataDirPath,
+            $directoryPath,
+            $fileName,
+        ];
+
+        return Miscellaneous::concatenatePaths($paths);
     }
 
     /**
@@ -124,12 +159,13 @@ abstract class BaseTestCase extends TestCase
      * @param int                     $requiredArgumentsCount (optional) Expected count/amount of required arguments
      *                                                        of the verified method
      * @throws UnknownOopVisibilityTypeException
+     * @throws ReflectionException
      *
      * Attention. 2nd argument, the $method, may be:
      * - string - name of the method
      * - instance of ReflectionMethod - just the method (provided by ReflectionClass::getMethod() method)
      */
-    protected function verifyMethodVisibilityAndArguments(
+    protected static function assertMethodVisibilityAndArguments(
         $classNamespace,
         $method,
         $visibilityType,
@@ -174,15 +210,16 @@ abstract class BaseTestCase extends TestCase
     /**
      * Verifies visibility and arguments of class constructor
      *
-     * @param string $classNamespace         Namespace of class that contains method to verify
+     * @param string $classNamespace         Namespace of class that contains constructor to verify
      * @param string $visibilityType         Expected visibility of verified method. One of OopVisibilityType class
      *                                       constants.
      * @param int    $argumentsCount         (optional) Expected count/amount of arguments of the verified method
      * @param int    $requiredArgumentsCount (optional) Expected count/amount of required arguments of the verified
      *                                       method
+     * @throws ReflectionException
      * @throws UnknownOopVisibilityTypeException
      */
-    protected function verifyConstructorVisibilityAndArguments(
+    protected static function assertConstructorVisibilityAndArguments(
         $classNamespace,
         $visibilityType,
         $argumentsCount = 0,
@@ -194,6 +231,33 @@ abstract class BaseTestCase extends TestCase
         $reflection = new ReflectionClass($classNamespace);
         $method = $reflection->getConstructor();
 
-        return $this->verifyMethodVisibilityAndArguments($classNamespace, $method, $visibilityType, $argumentsCount, $requiredArgumentsCount);
+        static::assertMethodVisibilityAndArguments($classNamespace, $method, $visibilityType, $argumentsCount, $requiredArgumentsCount);
+    }
+
+    /**
+     * Asserts that class with given namespace has no constructor
+     *
+     * @param string $classNamespace Namespace of class that contains constructor to verify
+     * @throws ReflectionException
+     */
+    protected static function assertHasNoConstructor($classNamespace)
+    {
+        /*
+         * Let's grab the constructor
+         */
+        $reflection = new ReflectionClass($classNamespace);
+        $constructor = $reflection->getConstructor();
+
+        static::assertNull($constructor);
+    }
+
+    /**
+     * Sets path of directory with data used by test cases
+     *
+     * @param string $testsDataDirPath Path of directory with data used by test cases
+     */
+    protected static function setTestsDataDirPath($testsDataDirPath)
+    {
+        static::$testsDataDirPath = $testsDataDirPath;
     }
 }

src/Traits/Test/Base/BaseTypeTestCaseTrait.php

@@ -1,17 +1,23 @@
 <?php
 
-namespace Meritoo\Common\Test\Base;
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Traits\Test\Base;
 
 use Generator;
 use Meritoo\Common\Type\Base\BaseType;
 
 /**
- * Base test case for the type of something
+ * Trait for the base test case for the type of something
  *
  * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
  * @copyright Meritoo.pl
  */
-abstract class BaseTypeTestCase extends BaseTestCase
+trait BaseTypeTestCaseTrait
 {
     /**
      * Verifies availability of all types

src/Type/DatePeriod.php

@@ -6,18 +6,20 @@
  * file that was distributed with this source code.
  */
 
-namespace Meritoo\Common\Utilities;
+namespace Meritoo\Common\Type;
 
 use DateTime;
+use Meritoo\Common\Type\Base\BaseType;
+use Meritoo\Common\Utilities\Date;
 
 /**
  * A date's period.
  * Contains start and end date of the period.
  *
- * @author     Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
- * @copyright  Meritoo.pl
+ * @copyright Meritoo.pl
  */
-class DatePeriod
+class DatePeriod extends BaseType
 {
     /**
      * The period constant: last month
@@ -108,17 +110,6 @@ class DatePeriod
         $this->endDate = $endDate;
     }
 
-    /**
-     * Returns information if given period is correct
-     *
-     * @param int $period The period to verify
-     * @return bool
-     */
-    public static function isCorrectPeriod($period)
-    {
-        return in_array($period, Reflection::getConstants(__CLASS__));
-    }
-
     /**
      * Returns formatted one of the period's date: start date or end date
      *

src/Utilities/Arrays.php

@@ -11,8 +11,8 @@ namespace Meritoo\Common\Utilities;
 /**
  * Useful arrays methods
  *
- * @author     Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
- * @copyright  Meritoo.pl
+ * @copyright Meritoo.pl
  */
 class Arrays
 {
@@ -48,23 +48,6 @@ class Arrays
 
                 if (is_array($value)) {
                     $effect .= self::values2string($value, $arrayColumnKey, $separator);
-                    /*
-                     * Previous version. Doesn't work with array containing arrays, e.g.:
-                     * array(
-                     *      1 => array(
-                     *          'item1',
-                     *          'item2'
-                     *      ),
-                     *      2 => array(
-                     *          'item3',
-                     *          'item4'
-                     *      )
-                     * )
-                     *
-                      if(isset($value[$arrayColumnKey])){
-                      $effect .= $value[$arrayColumnKey];
-                      }
-                     */
                 } else {
                     if (empty($arrayColumnKey)) {
                         $effect .= $value;
@@ -530,6 +513,10 @@ class Arrays
      */
     public static function removeElement(array $array, $item)
     {
+        /*
+         * No elements or the element does not exist?
+         * Nothing to do
+         */
         if (empty($array) || !in_array($item, $array)) {
             return false;
         }
@@ -626,6 +613,10 @@ class Arrays
      */
     public static function setKeysAsValues(array $array, $ignoreDuplicatedValues = true)
     {
+        /*
+         * No elements?
+         * Nothing to do
+         */
         if (empty($array)) {
             return [];
         }
@@ -1083,6 +1074,10 @@ class Arrays
      */
     public static function getAllValuesOfKey(array $array, $key)
     {
+        /*
+         * No elements?
+         * Nothing to do
+         */
         if (empty($array)) {
             return null;
         }

src/Utilities/Bundle.php

@@ -0,0 +1,89 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Utilities;
+
+use Meritoo\Common\Exception\Bundle\IncorrectBundleNameException;
+
+/**
+ * Useful methods for bundle
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class Bundle
+{
+    /**
+     * Returns path of given bundle to view / template with given extension
+     *
+     * @param string $viewPath   Path of the view / template, e.g. "MyDirectory/my-template"
+     * @param string $bundleName Full name of the bundle, e.g. "MyExtraBundle"
+     * @param string $extension  (optional) Extension of the view / template (default: "html.twig")
+     * @throws IncorrectBundleNameException
+     * @return string|null
+     */
+    public static function getBundleViewPath($viewPath, $bundleName, $extension = 'html.twig')
+    {
+        /*
+         * Unknown path, extension of the view / template or name of the bundle?
+         * Nothing to do
+         */
+        if (empty($viewPath) || empty($bundleName) || empty($extension)) {
+            return null;
+        }
+
+        /*
+         * Given name of bundle is invalid?
+         */
+        if (!Regex::isValidBundleName($bundleName)) {
+            throw new IncorrectBundleNameException($bundleName);
+        }
+
+        /*
+         * Path of the view / template doesn't end with given extension?
+         */
+        if (!Regex::endsWith($viewPath, $extension)) {
+            $viewPath = sprintf('%s.%s', $viewPath, $extension);
+        }
+
+        /*
+         * Prepare short name of bundle and path of view / template with "/" (instead of ":")
+         */
+        $shortBundleName = static::getShortBundleName($bundleName);
+        $viewPath = str_replace(':', '/', $viewPath);
+
+        return sprintf('@%s/%s', $shortBundleName, $viewPath);
+    }
+
+    /**
+     * Returns short name of bundle (without "Bundle")
+     *
+     * @param string $fullBundleName Full name of the bundle, e.g. "MyExtraBundle"
+     * @throws IncorrectBundleNameException
+     * @return string|null
+     */
+    public static function getShortBundleName($fullBundleName)
+    {
+        /*
+         * Given name of bundle is invalid?
+         */
+        if (!Regex::isValidBundleName($fullBundleName)) {
+            if (!is_string($fullBundleName)) {
+                $fullBundleName = gettype($fullBundleName);
+            }
+
+            throw new IncorrectBundleNameException($fullBundleName);
+        }
+
+        $matches = [];
+        $pattern = Regex::getBundleNamePattern();
+        preg_match($pattern, $fullBundleName, $matches);
+
+        return $matches[1];
+    }
+}

src/Utilities/Date.php

@@ -10,14 +10,16 @@ namespace Meritoo\Common\Utilities;
 
 use DateInterval;
 use DateTime;
+use Exception;
 use Meritoo\Common\Exception\Date\UnknownDatePartTypeException;
 use Meritoo\Common\Type\DatePartType;
+use Meritoo\Common\Type\DatePeriod;
 
 /**
  * Useful date methods
  *
- * @author     Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
- * @copyright  Meritoo.pl
+ * @copyright Meritoo.pl
  */
 class Date
 {
@@ -66,97 +68,106 @@ class Date
      * The dates are returned in an array with indexes 'start' and 'end'.
      *
      * @param int $period The period, type of period. One of DatePeriod class constants, e.g. DatePeriod::LAST_WEEK.
-     * @return DatePeriod
+     * @throws Exception
+     * @return null|DatePeriod
      */
     public static function getDatesForPeriod($period)
     {
-        $datePeriod = null;
+        /*
-
+         * Type of period is incorrect?
-        if (DatePeriod::isCorrectPeriod($period)) {
+         * Nothing to do
-            $dateStart = null;
+         */
-            $dateEnd = null;
+        if (!(new DatePeriod())->isCorrectType($period)) {
-
+            return null;
-            switch ($period) {
-                case DatePeriod::LAST_WEEK:
-                    $thisWeekStart = new DateTime('this week');
-
-                    $dateStart = clone $thisWeekStart;
-                    $dateEnd = clone $thisWeekStart;
-
-                    $dateStart->sub(new DateInterval('P7D'));
-                    $dateEnd->sub(new DateInterval('P1D'));
-
-                    break;
-                case DatePeriod::THIS_WEEK:
-                    $dateStart = new DateTime('this week');
-
-                    $dateEnd = clone $dateStart;
-                    $dateEnd->add(new DateInterval('P6D'));
-
-                    break;
-                case DatePeriod::NEXT_WEEK:
-                    $dateStart = new DateTime('this week');
-                    $dateStart->add(new DateInterval('P7D'));
-
-                    $dateEnd = clone $dateStart;
-                    $dateEnd->add(new DateInterval('P6D'));
-
-                    break;
-                case DatePeriod::LAST_MONTH:
-                    $dateStart = new DateTime('first day of last month');
-                    $dateEnd = new DateTime('last day of last month');
-
-                    break;
-                case DatePeriod::THIS_MONTH:
-                    $lastMonth = self::getDatesForPeriod(DatePeriod::LAST_MONTH);
-                    $nextMonth = self::getDatesForPeriod(DatePeriod::NEXT_MONTH);
-
-                    $dateStart = $lastMonth->getEndDate();
-                    $dateStart->add(new DateInterval('P1D'));
-
-                    $dateEnd = $nextMonth->getStartDate();
-                    $dateEnd->sub(new DateInterval('P1D'));
-
-                    break;
-                case DatePeriod::NEXT_MONTH:
-                    $dateStart = new DateTime('first day of next month');
-                    $dateEnd = new DateTime('last day of next month');
-
-                    break;
-                case DatePeriod::LAST_YEAR:
-                case DatePeriod::THIS_YEAR:
-                case DatePeriod::NEXT_YEAR:
-                    $dateStart = new DateTime();
-                    $dateEnd = new DateTime();
-
-                    if (DatePeriod::LAST_YEAR == $period || DatePeriod::NEXT_YEAR == $period) {
-                        $yearDifference = 1;
-
-                        if (DatePeriod::LAST_YEAR == $period) {
-                            $yearDifference *= -1;
-                        }
-
-                        $modifyString = sprintf('%s year', $yearDifference);
-                        $dateStart->modify($modifyString);
-                        $dateEnd->modify($modifyString);
-                    }
-
-                    $year = $dateStart->format('Y');
-                    $dateStart->setDate($year, 1, 1);
-                    $dateEnd->setDate($year, 12, 31);
-
-                    break;
-            }
-
-            if (null !== $dateStart && null !== $dateEnd) {
-                $dateStart->setTime(0, 0, 0);
-                $dateEnd->setTime(23, 59, 59);
-
-                $datePeriod = new DatePeriod($dateStart, $dateEnd);
-            }
         }
 
-        return $datePeriod;
+        $dateStart = null;
+        $dateEnd = null;
+
+        switch ($period) {
+            case DatePeriod::LAST_WEEK:
+                $thisWeekStart = new DateTime('this week');
+
+                $dateStart = clone $thisWeekStart;
+                $dateEnd = clone $thisWeekStart;
+
+                $dateStart->sub(new DateInterval('P7D'));
+                $dateEnd->sub(new DateInterval('P1D'));
+
+                break;
+            case DatePeriod::THIS_WEEK:
+                $dateStart = new DateTime('this week');
+
+                $dateEnd = clone $dateStart;
+                $dateEnd->add(new DateInterval('P6D'));
+
+                break;
+            case DatePeriod::NEXT_WEEK:
+                $dateStart = new DateTime('this week');
+                $dateStart->add(new DateInterval('P7D'));
+
+                $dateEnd = clone $dateStart;
+                $dateEnd->add(new DateInterval('P6D'));
+
+                break;
+            case DatePeriod::LAST_MONTH:
+                $dateStart = new DateTime('first day of last month');
+                $dateEnd = new DateTime('last day of last month');
+
+                break;
+            case DatePeriod::THIS_MONTH:
+                $lastMonth = self::getDatesForPeriod(DatePeriod::LAST_MONTH);
+                $nextMonth = self::getDatesForPeriod(DatePeriod::NEXT_MONTH);
+
+                $dateStart = $lastMonth->getEndDate();
+                $dateStart->add(new DateInterval('P1D'));
+
+                $dateEnd = $nextMonth->getStartDate();
+                $dateEnd->sub(new DateInterval('P1D'));
+
+                break;
+            case DatePeriod::NEXT_MONTH:
+                $dateStart = new DateTime('first day of next month');
+                $dateEnd = new DateTime('last day of next month');
+
+                break;
+            case DatePeriod::LAST_YEAR:
+            case DatePeriod::THIS_YEAR:
+            case DatePeriod::NEXT_YEAR:
+                $dateStart = new DateTime();
+                $dateEnd = new DateTime();
+
+                if (DatePeriod::LAST_YEAR == $period || DatePeriod::NEXT_YEAR == $period) {
+                    $yearDifference = 1;
+
+                    if (DatePeriod::LAST_YEAR == $period) {
+                        $yearDifference *= -1;
+                    }
+
+                    $modifyString = sprintf('%s year', $yearDifference);
+                    $dateStart->modify($modifyString);
+                    $dateEnd->modify($modifyString);
+                }
+
+                $year = $dateStart->format('Y');
+                $dateStart->setDate($year, 1, 1);
+                $dateEnd->setDate($year, 12, 31);
+
+                break;
+        }
+
+        /*
+         * Start or end date is unknown?
+         * Nothing to do
+         */
+        if (null === $dateStart || null === $dateEnd) {
+            return null;
+        }
+
+        $dateStart->setTime(0, 0, 0);
+        $dateEnd->setTime(23, 59, 59);
+
+        return new DatePeriod($dateStart, $dateEnd);
     }
 
     /**
@@ -209,6 +220,7 @@ class Date
     /**
      * Returns current day of week
      *
+     * @throws UnknownDatePartTypeException
      * @return int
      */
     public static function getCurrentDayOfWeek()
@@ -230,8 +242,8 @@ class Date
      * @param int $month The month value
      * @param int $day   The day value
      *
-     * @return int
      * @throws UnknownDatePartTypeException
+     * @return int
      */
     public static function getDayOfWeek($year, $month, $day)
     {
@@ -475,6 +487,7 @@ class Date
      * @param string   $intervalTemplate (optional) Template used to build date interval. It should contain "%d" as the
      *                                   placeholder which is replaced with a number that represents each iteration.
      *                                   Default: interval for days.
+     * @throws Exception
      * @return array
      */
     public static function getDatesCollection(DateTime $startDate, $datesCount, $intervalTemplate = 'P%dD')
@@ -520,6 +533,7 @@ class Date
      * @param int      $end              (optional) End of random partition
      * @param string   $intervalTemplate (optional) Template used to build date interval. The placeholder is replaced
      *                                   with next, iterated value.
+     * @throws Exception
      * @return DateTime
      */
     public static function getRandomDate(DateTime $startDate = null, $start = 1, $end = 100, $intervalTemplate = 'P%sD')

src/Utilities/Locale.php

@@ -11,8 +11,8 @@ namespace Meritoo\Common\Utilities;
 /**
  * Useful locale methods
  *
- * @author     Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
- * @copyright  Meritoo.pl
+ * @copyright Meritoo.pl
  */
 class Locale
 {
@@ -23,7 +23,7 @@ class Locale
      *                             setting. It's the same constant as required by setlocale() function.
      * @param string $languageCode Language code, in ISO 639-1 format. Short form of the locale, e.g. "fr".
      * @param string $countryCode  (optional) Country code, in ISO 3166-1 alpha-2 format, e.g. "FR"
-     * @return bool
+     * @return false|string
      *
      * Available categories (values of $category argument):
      * - LC_ALL for all of the below
@@ -57,9 +57,29 @@ class Locale
         }
 
         $localeLongForm = self::getLongForm($languageCode, $countryCode);
-        setlocale($category, $localeLongForm);
 
-        return true;
+        return setlocale($category, $localeLongForm);
+    }
+
+    /**
+     * Returns locale for given category
+     *
+     * @param int $category Named constant specifying the category of the functions affected by the locale setting.
+     *                      It's the same constant as required by setlocale() function.
+     * @return string
+     *
+     * Available categories (values of $category argument):
+     * - LC_ALL for all of the below
+     * - LC_COLLATE for string comparison, see strcoll()
+     * - LC_CTYPE for character classification and conversion, for example strtoupper()
+     * - LC_MONETARY for localeconv()
+     * - LC_NUMERIC for decimal separator (See also localeconv())
+     * - LC_TIME for date and time formatting with strftime()
+     * - LC_MESSAGES for system responses (available if PHP was compiled with libintl)
+     */
+    public static function getLocale($category)
+    {
+        return setlocale($category, '0');
     }
 
     /**

src/Utilities/MimeTypes.php

@@ -11,8 +11,8 @@ namespace Meritoo\Common\Utilities;
 /**
  * Useful methods for mime types of files
  *
- * @author     Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
- * @copyright  Meritoo.pl
+ * @copyright Meritoo.pl
  */
 class MimeTypes
 {
@@ -759,9 +759,8 @@ class MimeTypes
      * Returns mime type of given file
      *
      * @param string $filePath Path of the file to check
-     * @return string
-     *
      * @throws \RuntimeException
+     * @return string
      */
     public static function getMimeType($filePath)
     {

src/Utilities/Miscellaneous.php

@@ -9,14 +9,15 @@
 namespace Meritoo\Common\Utilities;
 
 use Gedmo\Sluggable\Util\Urlizer;
-use Symfony\Component\HttpFoundation\Cookie;
+use Meritoo\Common\Exception\Regex\IncorrectColorHexLengthException;
+use Meritoo\Common\Exception\Regex\InvalidColorHexValueException;
 use Transliterator;
 
 /**
  * Miscellaneous methods (only static functions)
  *
- * @author     Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
- * @copyright  Meritoo.pl
+ * @copyright Meritoo.pl
  */
 class Miscellaneous
 {
@@ -626,10 +627,10 @@ class Miscellaneous
      * Breaks long text
      *
      * @param string $text                   The text to check and break
-     * @param int    $perLine                (optional) Characters count per line
+     * @param int    $perLine                (optional) Characters count per line. Default: 100.
-     * @param string $separator              (optional) Separator that is placed beetwen lines
+     * @param string $separator              (optional) Separator that is placed between lines. Default: "<br>".
-     * @param string $encoding               (optional) Character encoding. Used by mb_substr().
+     * @param string $encoding               (optional) Character encoding. Used by mb_substr(). Default: "UTF-8".
-     * @param int    $proportionalAberration (optional) Proportional aberration for chars (percent value)
+     * @param int    $proportionalAberration (optional) Proportional aberration for chars (percent value). Default: 20.
      * @return string
      */
     public static function breakLongText(
@@ -716,15 +717,23 @@ class Miscellaneous
      *
      * @param string $directoryPath Directory path
      * @param bool   $contentOnly   (optional) If is set to true, only content of the directory is removed, not
-     *                              directory. Otherwise - directory is removed too.
+     *                              directory itself. Otherwise - directory is removed too (default behaviour).
-     * @return bool
+     * @return bool|null
      */
     public static function removeDirectory($directoryPath, $contentOnly = false)
     {
+        /*
+         * Directory does not exist?
+         * Nothing to do
+         */
         if (!file_exists($directoryPath)) {
-            return true;
+            return null;
         }
 
+        /*
+         * It's not a directory?
+         * Let's treat it like file
+         */
         if (!is_dir($directoryPath)) {
             return unlink($directoryPath);
         }
@@ -739,6 +748,9 @@ class Miscellaneous
             }
         }
 
+        /*
+         * Directory should be removed too?
+         */
         if (!$contentOnly) {
             return rmdir($directoryPath);
         }
@@ -1032,6 +1044,8 @@ class Miscellaneous
         $separator = DIRECTORY_SEPARATOR;
 
         foreach ($paths as $path) {
+            $path = trim($path);
+
             /*
              * Empty paths are useless
              */
@@ -1190,138 +1204,6 @@ class Miscellaneous
         return $value;
     }
 
-    /**
-     * Returns a CURL response with parsed HTTP headers as array with "headers", "cookies" and "content" keys
-     *
-     * The headers and cookies are parsed and returned as an array, and an array of Cookie objects. Returned array looks
-     * like this example:
-     * <code>
-     * [
-     *      'headers' => [
-     *          'Content-Type' => 'text/html; charset=UTF-8',
-     *          ...
-     *      ],
-     *      'cookies' => [
-     *          new Symfony\Component\HttpFoundation\Cookie(),
-     *          new Symfony\Component\HttpFoundation\Cookie(),
-     *          ...
-     *      ],
-     *      'content' => '<html>...</html>'
-     * ]
-     * </code>
-     *
-     * If you want to attach HTTP headers into response content by CURL you need to set "CURLOPT_HEADER" option
-     * to "true". To read exact length of HTTP headers from CURL you can use "curl_getinfo()" function
-     * and read "CURLINFO_HEADER_SIZE" option.
-     *
-     * @param string $response   the full content of response, including HTTP headers
-     * @param int    $headerSize The length of HTTP headers in content
-     * @return array
-     */
-    public static function getCurlResponseWithHeaders($response, $headerSize)
-    {
-        $headerContent = mb_substr($response, 0, $headerSize);
-        $content = mb_substr($response, $headerSize);
-        $headers = [];
-        $cookies = [];
-
-        /*
-         * Let's transform headers content into two arrays: headers and cookies
-         */
-        foreach (explode("\r\n", $headerContent) as $i => $line) {
-            /*
-             * First line is only HTTP status and is unneeded so skip it
-             */
-            if (0 === $i) {
-                continue;
-            }
-
-            if (Regex::contains($line, ':')) {
-                list($key, $value) = explode(': ', $line);
-
-                /*
-                 * If the header is a "set-cookie" let's save it to "cookies" array
-                 */
-                if ('Set-Cookie' === $key) {
-                    $cookieParameters = explode(';', $value);
-
-                    $name = '';
-                    $value = '';
-                    $expire = 0;
-                    $path = '/';
-                    $domain = null;
-                    $secure = false;
-                    $httpOnly = true;
-
-                    foreach ($cookieParameters as $j => $parameter) {
-                        $param = explode('=', $parameter);
-
-                        /*
-                         * First parameter will be always a cookie name and it's value. It is not needed to run
-                         * further actions for them, so save the values and move to next parameter.
-                         */
-                        if (0 === $j) {
-                            $name = trim($param[0]);
-                            $value = trim($param[1]);
-                            continue;
-                        }
-
-                        /*
-                         * Now there would be the rest of cookie parameters, names of params are sent different way so
-                         * I need to lowercase the names and remove unneeded spaces.
-                         */
-                        $paramName = mb_strtolower(trim($param[0]));
-                        $paramValue = true;
-
-                        /*
-                         * Some parameters don't have value e.g. "secure", but the value for them if they're specified
-                         * is "true". Otherwise - just read a value for parameter if exists.
-                         */
-                        if (array_key_exists(1, $param)) {
-                            $paramValue = trim($param[1]);
-                        }
-
-                        switch ($paramName) {
-                            case 'expires':
-                                $expire = $paramValue;
-                                break;
-                            case 'path':
-                                $path = $paramValue;
-                                break;
-                            case 'domain':
-                                $domain = $paramValue;
-                                break;
-                            case 'secure':
-                                $secure = $paramValue;
-                                break;
-                            case 'httponly':
-                                $httpOnly = $paramValue;
-                                break;
-                        }
-                    }
-
-                    /*
-                     * Create new Cookie object and add it to "cookies" array.
-                     * I must skip to next header as cookies shouldn't be saved in "headers" array.
-                     */
-                    $cookies[] = new Cookie($name, $value, $expire, $path, $domain, $secure, $httpOnly);
-                    continue;
-                }
-
-                /*
-                 * Save response header which is not a cookie
-                 */
-                $headers[$key] = $value;
-            }
-        }
-
-        return [
-            'headers' => $headers,
-            'cookies' => $cookies,
-            'content' => $content,
-        ];
-    }
-
     /**
      * Adds missing the "0" characters to given number until given length is reached
      *
@@ -1430,6 +1312,8 @@ class Miscellaneous
      * Returns inverted value of color for given color
      *
      * @param string $color Hexadecimal value of color to invert (with or without hash), e.g. "dd244c" or "#22a5fe"
+     * @throws IncorrectColorHexLengthException
+     * @throws InvalidColorHexValueException
      * @return string
      */
     public static function getInvertedColor($color)
@@ -1471,4 +1355,37 @@ class Miscellaneous
 
         return $invertedColor;
     }
+
+    /**
+     * Returns project's root path.
+     * Looks for directory that contains composer.json.
+     *
+     * @return string
+     */
+    public static function getProjectRootPath()
+    {
+        $projectRootPath = '';
+
+        $fileName = 'composer.json';
+        $directoryPath = __DIR__;
+
+        /*
+         * Path of directory it's not the path of last directory?
+         */
+        while (DIRECTORY_SEPARATOR !== $directoryPath) {
+            $filePath = static::concatenatePaths($directoryPath, $fileName);
+
+            /*
+             * Is here file we are looking for?
+             * Maybe it's a project's root path
+             */
+            if (file_exists($filePath)) {
+                $projectRootPath = $directoryPath;
+            }
+
+            $directoryPath = dirname($directoryPath);
+        }
+
+        return $projectRootPath;
+    }
 }

src/Utilities/QueryBuilderUtility.php

@@ -10,6 +10,7 @@ namespace Meritoo\Common\Utilities;
 
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\ORM\EntityManager;
+use Doctrine\ORM\OptimisticLockException;
 use Doctrine\ORM\Query\Expr\Join;
 use Doctrine\ORM\Query\Parameter;
 use Doctrine\ORM\QueryBuilder;
@@ -17,8 +18,8 @@ use Doctrine\ORM\QueryBuilder;
 /**
  * Useful methods for query builder (the Doctrine's QueryBuilder class)
  *
- * @author     Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
- * @copyright  Meritoo.pl
+ * @copyright Meritoo.pl
  */
 class QueryBuilderUtility
 {
@@ -33,6 +34,10 @@ class QueryBuilderUtility
     {
         $aliases = $queryBuilder->getRootAliases();
 
+        /*
+         * No aliases?
+         * Nothing to do
+         */
         if (empty($aliases)) {
             return null;
         }
@@ -42,7 +47,8 @@ class QueryBuilderUtility
 
     /**
      * Returns alias of given property joined in given query builder
-     * If the join does not exist, null is returned.
+     *
+     * If there are no joins or the join does not exist, null is returned.
      * It's also information if given property is already joined in given query builder.
      *
      * @param QueryBuilder $queryBuilder The query builder to verify
@@ -53,6 +59,10 @@ class QueryBuilderUtility
     {
         $joins = $queryBuilder->getDQLPart('join');
 
+        /*
+         * No joins?
+         * Nothing to do
+         */
         if (empty($joins)) {
             return null;
         }
@@ -99,33 +109,43 @@ class QueryBuilderUtility
      */
     public static function setCriteria(QueryBuilder $queryBuilder, array $criteria = [], $alias = '')
     {
-        if (!empty($criteria)) {
+        /*
-            if (empty($alias)) {
+         * No criteria used in WHERE clause?
-                $alias = self::getRootAlias($queryBuilder);
+         * Nothing to do
-            }
+         */
+        if (empty($criteria)) {
+            return $queryBuilder;
+        }
 
-            foreach ($criteria as $column => $value) {
+        /*
-                $compareOperator = '=';
+         * No alias provided?
+         * Let's use root alias
+         */
+        if (empty($alias)) {
+            $alias = self::getRootAlias($queryBuilder);
+        }
 
-                if (is_array($value) && !empty($value)) {
+        foreach ($criteria as $column => $value) {
-                    if (2 == count($value)) {
+            $compareOperator = '=';
-                        $compareOperator = $value[1];
-                    }
 
-                    $value = $value[0];
+            if (is_array($value) && !empty($value)) {
+                if (2 == count($value)) {
+                    $compareOperator = $value[1];
                 }
 
-                $predicate = sprintf('%s.%s %s :%s', $alias, $column, $compareOperator, $column);
+                $value = $value[0];
-
-                if (null === $value) {
-                    $predicate = $queryBuilder->expr()->isNull(sprintf('%s.%s', $alias, $column));
-                    unset($criteria[$column]);
-                } else {
-                    $queryBuilder->setParameter($column, $value);
-                }
-
-                $queryBuilder = $queryBuilder->andWhere($predicate);
             }
+
+            $predicate = sprintf('%s.%s %s :%s', $alias, $column, $compareOperator, $column);
+
+            if (null === $value) {
+                $predicate = $queryBuilder->expr()->isNull(sprintf('%s.%s', $alias, $column));
+                unset($criteria[$column]);
+            } else {
+                $queryBuilder->setParameter($column, $value);
+            }
+
+            $queryBuilder = $queryBuilder->andWhere($predicate);
         }
 
         return $queryBuilder;
@@ -136,14 +156,15 @@ class QueryBuilderUtility
      *
      * @param EntityManager         $entityManager The entity manager
      * @param array|ArrayCollection $entities      The entities to delete
-     * @param bool                  $flushDeleted  (optional) If is set to true, flushes the deleted objects.
+     * @param bool                  $flushDeleted  (optional) If is set to true, flushes the deleted objects (default
-     *                                             Otherwise - not.
+     *                                             behaviour). Otherwise - not.
+     * @throws OptimisticLockException
      * @return bool
      */
     public static function deleteEntities(EntityManager $entityManager, $entities, $flushDeleted = true)
     {
         /*
-         * No entities found?
+         * No entities provided?
          * Nothing to do
          */
         if (empty($entities)) {
@@ -169,24 +190,30 @@ class QueryBuilderUtility
      * Attention. Existing parameters will be overridden.
      *
      * @param QueryBuilder          $queryBuilder The query builder
-     * @param array|ArrayCollection $parameters   Parameters to add. Collection of instances of
+     * @param array|ArrayCollection $parameters   Parameters to add. Collection of Doctrine\ORM\Query\Parameter
-     *                                            Doctrine\ORM\Query\Parameter class or an array with key-value pairs.
+     *                                            instances or an array with key-value pairs.
      * @return QueryBuilder
      */
     public static function addParameters(QueryBuilder $queryBuilder, $parameters)
     {
-        if (!empty($parameters)) {
+        /*
-            foreach ($parameters as $key => $parameter) {
+         * No parameters?
-                $name = $key;
+         * Nothing to do
-                $value = $parameter;
+         */
+        if (empty($parameters)) {
+            return $queryBuilder;
+        }
 
-                if ($parameter instanceof Parameter) {
+        foreach ($parameters as $key => $parameter) {
-                    $name = $parameter->getName();
+            $name = $key;
-                    $value = $parameter->getValue();
+            $value = $parameter;
-                }
 
-                $queryBuilder->setParameter($name, $value);
+            if ($parameter instanceof Parameter) {
+                $name = $parameter->getName();
+                $value = $parameter->getValue();
             }
+
+            $queryBuilder->setParameter($name, $value);
         }
 
         return $queryBuilder;

src/Utilities/Reflection.php

@@ -8,9 +8,9 @@
 
 namespace Meritoo\Common\Utilities;
 
-use Doctrine\Common\Collections\Collection;
 use Doctrine\Common\Util\ClassUtils;
 use Doctrine\Common\Util\Inflector;
+use Meritoo\Common\Collection\Collection;
 use Meritoo\Common\Exception\Reflection\CannotResolveClassNameException;
 use Meritoo\Common\Exception\Reflection\MissingChildClassesException;
 use Meritoo\Common\Exception\Reflection\TooManyChildClassesException;
@@ -23,8 +23,8 @@ use ReflectionProperty;
 /**
  * Useful reflection methods
  *
- * @author     Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
- * @copyright  Meritoo.pl
+ * @copyright Meritoo.pl
  */
 class Reflection
 {
@@ -34,6 +34,7 @@ class Reflection
      * @param object|string $class              The object or name of object's class
      * @param bool          $withoutInheritance (optional) If is set to true, only methods for given class are returned.
      *                                          Otherwise - all methods, with inherited methods too.
+     * @throws ReflectionException
      * @return array
      */
     public static function getMethods($class, $withoutInheritance = false)
@@ -64,6 +65,7 @@ class Reflection
      * Returns constants of given class / object
      *
      * @param object|string $class The object or name of object's class
+     * @throws ReflectionException
      * @return array
      */
     public static function getConstants($class)
@@ -74,10 +76,11 @@ class Reflection
     }
 
     /**
-     * Returns maximum constant from all constants of given class / object.
+     * Returns maximum integer value of constant of given class / object.
-     * Values of constants should be integers.
+     * Constants whose values are integers are considered only.
      *
      * @param object|string $class The object or name of object's class
+     * @throws ReflectionException
      * @return int|null
      */
     public static function getMaxNumberConstant($class)
@@ -104,6 +107,7 @@ class Reflection
      *
      * @param object|string $class  The object or name of object's class
      * @param string        $method Name of the method to find
+     * @throws ReflectionException
      * @return bool
      */
     public static function hasMethod($class, $method)
@@ -118,6 +122,7 @@ class Reflection
      *
      * @param object|string $class    The object or name of object's class
      * @param string        $property Name of the property to find
+     * @throws ReflectionException
      * @return bool
      */
     public static function hasProperty($class, $property)
@@ -132,6 +137,7 @@ class Reflection
      *
      * @param object|string $class    The object or name of object's class
      * @param string        $constant Name of the constant to find
+     * @throws ReflectionException
      * @return bool
      */
     public static function hasConstant($class, $constant)
@@ -146,6 +152,7 @@ class Reflection
      *
      * @param object|string $class    The object or name of object's class
      * @param string        $constant Name of the constant that contains a value
+     * @throws ReflectionException
      * @return mixed
      */
     public static function getConstantValue($class, $constant)
@@ -168,6 +175,7 @@ class Reflection
      *                         dot-separated, e.g. "invoice.user.email".
      * @param bool   $force    (optional) If is set to true, try to retrieve value even if the object doesn't have
      *                         property. Otherwise - not.
+     * @throws ReflectionException
      * @return mixed
      */
     public static function getPropertyValue($object, $property, $force = false)
@@ -229,17 +237,29 @@ class Reflection
                 if ($class->hasProperty($property) || $force) {
                     $property = Inflector::classify($property);
 
-                    $methodPrefixes = [
+                    $getterPrefixes = [
                         'get',
                         'has',
                         'is',
                     ];
 
-                    foreach ($methodPrefixes as $prefix) {
+                    foreach ($getterPrefixes as $prefix) {
-                        $method = sprintf('%s%s', $prefix, $property);
+                        $getterName = sprintf('%s%s', $prefix, $property);
 
-                        if ($class->hasMethod($method)) {
+                        if ($class->hasMethod($getterName)) {
-                            $value = $object->{$method}();
+                            $method = new ReflectionMethod($object, $getterName);
+
+                            /*
+                             * Getter is not accessible publicly?
+                             * I have to skip it, to avoid an error like this:
+                             *
+                             * Call to protected method My\ExtraClass::getExtraProperty() from context 'My\ExtraClass'
+                             */
+                            if ($method->isProtected() || $method->isPrivate()) {
+                                continue;
+                            }
+
+                            $value = $object->{$getterName}();
                             $valueFound = true;
                             break;
                         }
@@ -248,13 +268,14 @@ class Reflection
 
                 if (!$valueFound && null !== $reflectionProperty) {
                     /*
-                     * Oops, we have got exception.
+                     * Oops, value of the property is still unknown
                      *
                      * 3rd try:
-                     * Let's try modify accessibility of the property and try again to get value.
+                     * Let's modify accessibility of the property and try again to get value
                      */
                     $reflectionProperty->setAccessible(true);
                     $value = $reflectionProperty->getValue($object);
+                    $reflectionProperty->setAccessible(false);
                 }
             }
         }
@@ -271,10 +292,19 @@ class Reflection
      * @param string                  $property Name of the property that contains a value
      * @param bool                    $force    (optional) If is set to true, try to retrieve value even if the
      *                                          object does not have property. Otherwise - not.
+     * @throws ReflectionException
      * @return array
      */
     public static function getPropertyValues($objects, $property, $force = false)
     {
+        /*
+         * No objects?
+         * Nothing to do
+         */
+        if (empty($objects)) {
+            return [];
+        }
+
         if ($objects instanceof Collection) {
             $objects = $objects->toArray();
         }
@@ -407,7 +437,7 @@ class Reflection
 
         $parents = class_parents($childClassName);
 
-        if (is_array($parents)) {
+        if (is_array($parents) && 0 < count($parents)) {
             return in_array($parentClassName, $parents);
         }
 
@@ -417,12 +447,15 @@ class Reflection
     /**
      * Returns given object properties
      *
-     * @param array|object|string $source An array of objects, namespaces, object or namespace
+     * @param array|object|string $source         An array of objects, namespaces, object or namespace
-     * @param int                 $filter (optional) Filter of properties. Uses ReflectionProperty class constants.
+     * @param int                 $filter         (optional) Filter of properties. Uses ReflectionProperty class
-     *                                    By default all properties are returned.
+     *                                            constants. By default all properties are returned.
+     * @param bool                $includeParents (optional) If is set to true, properties of parent classes are
+     *                                            included (recursively). Otherwise - not.
+     * @throws ReflectionException
      * @return array|ReflectionProperty
      */
-    public static function getProperties($source, $filter = null)
+    public static function getProperties($source, $filter = null, $includeParents = false)
     {
         $className = self::getClassName($source);
         $reflection = new ReflectionClass($className);
@@ -434,14 +467,27 @@ class Reflection
                 + ReflectionProperty::IS_STATIC;
         }
 
-        return $reflection->getProperties($filter);
+        $properties = $reflection->getProperties($filter);
+        $parentProperties = [];
+
+        if ($includeParents) {
+            $parent = self::getParentClass($source);
+
+            if (false !== $parent) {
+                $parentClass = $parent->getName();
+                $parentProperties = self::getProperties($parentClass, $filter, $includeParents);
+            }
+        }
+
+        return array_merge($properties, $parentProperties);
     }
 
     /**
-     * Returns a parent class
+     * Returns a parent class or false if there is no parent class
      *
      * @param array|object|string $source An array of objects, namespaces, object or namespace
-     * @return ReflectionClass
+     * @throws ReflectionException
+     * @return ReflectionClass|bool
      */
     public static function getParentClass($source)
     {
@@ -457,8 +503,8 @@ class Reflection
      *
      * @param array|object|string $class Class who child classes should be returned. An array of objects, strings,
      *                                   object or string.
-     * @return array|null
      * @throws CannotResolveClassNameException
+     * @return array|null
      */
     public static function getChildClasses($class)
     {
@@ -512,10 +558,10 @@ class Reflection
      *
      * @param array|object|string $parentClass Class who child class should be returned. An array of objects,
      *                                         namespaces, object or namespace.
-     * @return mixed
+     * @throws CannotResolveClassNameException
-     *
      * @throws MissingChildClassesException
      * @throws TooManyChildClassesException
+     * @return mixed
      */
     public static function getOneChildClass($parentClass)
     {
@@ -547,6 +593,7 @@ class Reflection
      * @param string              $property Name of the property
      * @param int                 $filter   (optional) Filter of properties. Uses ReflectionProperty class constants.
      *                                      By default all properties are allowed / processed.
+     * @throws ReflectionException
      * @return null|ReflectionProperty
      */
     public static function getProperty($class, $property, $filter = null)
@@ -573,8 +620,9 @@ class Reflection
      * @param array|string        $trait         An array of strings or string
      * @param bool                $verifyParents If is set to true, parent classes are verified if they use given
      *                                           trait. Otherwise - not.
-     * @return bool|null
      * @throws CannotResolveClassNameException
+     * @throws ReflectionException
+     * @return bool|null
      */
     public static function usesTrait($class, $trait, $verifyParents = false)
     {
@@ -616,6 +664,7 @@ class Reflection
      * If given class does not extend another, returns null.
      *
      * @param array|object|string $class An array of objects, namespaces, object or namespace
+     * @throws ReflectionException
      * @return string|null
      */
     public static function getParentClassName($class)

src/Utilities/Regex.php

@@ -14,8 +14,8 @@ use Meritoo\Common\Exception\Regex\InvalidColorHexValueException;
 /**
  * Useful regular expressions methods
  *
- * @author     Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
- * @copyright  Meritoo.pl
+ * @copyright Meritoo.pl
  */
 class Regex
 {
@@ -25,18 +25,21 @@ class Regex
      * @var array
      */
     private static $patterns = [
-        'email'            => '/[\w-]{2,}@[\w-]+\.[\w]{2,}+/',
+        'email'            => '/^[\w-.]{2,}@[\w-]+\.[\w]{2,}+$/',
         'phone'            => '/^\+?[0-9 ]+$/',
         'camelCasePart'    => '/([a-z]|[A-Z]){1}[a-z]*/',
         'urlProtocol'      => '/^([a-z]+:\/\/)',
         'urlDomain'        => '([\da-z\.-]+)\.([a-z\.]{2,6})(\/)?([\w\.\-]*)?(\?)?([\w \.\-\/=&]*)\/?$/i',
         'letterOrDigit'    => '/[a-zA-Z0-9]+/',
         'htmlEntity'       => '/&[a-z0-9]+;/',
+        'htmlAttribute'    => '/([\w-]+)="([\w -]+)"/',
         'fileName'         => '/.+\.\w+$/',
         'isQuoted'         => '/^[\'"]{1}.+[\'"]{1}$/',
         'windowsBasedPath' => '/^[A-Z]{1}:\\\.*$/',
         'money'            => '/^[-+]?\d+([\.,]{1}\d*)?$/',
         'color'            => '/^[a-f0-9]{6}$/i',
+        'bundleName'       => '/^(([A-Z]{1}[a-z0-9]+)((?2))*)(Bundle)$/',
+        'binaryValue'      => '/[^\x20-\x7E\t\r\n]/',
     ];
 
     /**
@@ -56,43 +59,77 @@ class Regex
      */
     public static function isValidEmail($email)
     {
+        /*
+         * Not a string?
+         * Nothing to do
+         */
+        if (!is_string($email)) {
+            return false;
+        }
+
         $pattern = self::getEmailPattern();
 
         return (bool)preg_match($pattern, $email);
     }
 
     /**
-     * Returns information if given tax ID (in polish: NIP) is valid
+     * Returns information if given tax ID is valid (in Poland it's named "NIP")
      *
-     * @param string $taxidString Tax ID (NIP) string
+     * @param string $taxIdString Tax ID (NIP) string
      * @return bool
      */
-    public static function isValidTaxid($taxidString)
+    public static function isValidTaxId($taxIdString)
     {
-        if (!empty($taxidString)) {
+        /*
-            $weights = [
+         * Not a string?
-                6,
+         * Nothing to do
-                5,
+         */
-                7,
+        if (!is_string($taxIdString)) {
-                2,
+            return false;
-                3,
+        }
-                4,
-                5,
-                6,
-                7,
-            ];
-            $taxid = preg_replace('/[\s-]/', '', $taxidString);
-            $sum = 0;
 
-            if (10 == strlen($taxid) && is_numeric($taxid)) {
+        /*
-                for ($x = 0; $x <= 8; ++$x) {
+         * Empty/Unknown value?
-                    $sum += $taxid[$x] * $weights[$x];
+         * Nothing to do
-                }
+         */
+        if (empty($taxIdString)) {
+            return false;
+        }
 
-                if ((($sum % 11) % 10) == $taxid[9]) {
+        $taxId = preg_replace('/[\s-]/', '', $taxIdString);
-                    return true;
+
-                }
+        /*
-            }
+         * Tax ID is not 10 characters length OR is not numeric?
+         * Nothing to do
+         */
+        if (10 !== strlen($taxId) || !is_numeric($taxId)) {
+            return false;
+        }
+
+        $weights = [
+            6,
+            5,
+            7,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+        ];
+
+        $sum = 0;
+
+        for ($x = 0; $x <= 8; ++$x) {
+            $sum += $taxId[$x] * $weights[$x];
+        }
+
+        /*
+         * Last number it's not a remainder from dividing per 11?
+         * Nothing to do
+         */
+        if ($sum % 11 == $taxId[9]) {
+            return true;
         }
 
         return false;
@@ -108,6 +145,14 @@ class Regex
      */
     public static function isValidUrl($url, $requireProtocol = false)
     {
+        /*
+         * Not a string?
+         * Nothing to do
+         */
+        if (!is_string($url)) {
+            return false;
+        }
+
         $pattern = self::getUrlPattern($requireProtocol);
 
         return (bool)preg_match($pattern, $url);
@@ -121,88 +166,108 @@ class Regex
      */
     public static function isValidPhoneNumber($phoneNumber)
     {
+        /*
+         * Not a string?
+         * Nothing to do
+         */
+        if (!is_string($phoneNumber)) {
+            return false;
+        }
+
         $pattern = self::getPhoneNumberPattern();
 
-        return (bool)preg_match($pattern, $phoneNumber);
+        return (bool)preg_match($pattern, trim($phoneNumber));
     }
 
     /**
-     * Returns array values that matches given pattern (or values that keys matches)
+     * Returns array values that match given pattern (or values that keys match the pattern)
      *
      * @param string $pattern       Pattern to match
-     * @param array  $dataArray     The array
+     * @param array  $array         The array (scalar values only)
-     * @param bool   $itsKeyPattern (optional) If is set to true, keys are checks if they match pattern. Otherwise -
+     * @param bool   $itsKeyPattern (optional) If is set to true, keys will be checked if they match pattern.
-     *                              values are checks.
+     *                              Otherwise - values will be checked (default behaviour).
      * @return array
      */
-    public static function getArrayValuesByPattern($pattern, $dataArray, $itsKeyPattern = false)
+    public static function getArrayValuesByPattern($pattern, array $array, $itsKeyPattern = false)
     {
+        /*
+         * No elements?
+         * Nothing to do
+         */
+        if (empty($array)) {
+            return [];
+        }
+
         if ($itsKeyPattern) {
             $effect = [];
 
-            if (!empty($dataArray)) {
+            foreach ($array as $key => $value) {
-                $matches = [];
+                if ((bool)preg_match($pattern, $key)) {
-
+                    $effect[$key] = $value;
-                foreach ($dataArray as $key => $value) {
-                    if (preg_match($pattern, $key, $matches)) {
-                        $effect[$key] = $value;
-                    }
                 }
             }
 
             return $effect;
         }
 
-        return preg_grep($pattern, $dataArray);
+        return preg_grep($pattern, $array);
     }
 
     /**
      * Filters array by given expression and column
      *
-     * Expression can be simple compare expression, like ' == 2', or regular expression.
+     * Expression can be simple compare expression, like " == 2", or regular expression.
      * Returns filtered array.
      *
-     * @param array  $array                The array that should be filtered
+     * @param array  $array                The 2-dimensional array that should be filtered
      * @param string $arrayColumnKey       Column name
-     * @param string $filterExpression     Filter expression, e.g. '== 2' or '!= \'home\''
+     * @param string $filterExpression     Simple filter expression (e.g. "== 2" or "!= \'home\'") or regular
-     * @param bool   $itsRegularExpression (optional) If is set to true, means that filter expression is a
+     *                                     expression (e.g. "/\d+/" or "/[a-z]+[,;]{2,}/")
-     *                                     regular expression
+     * @param bool   $itsRegularExpression (optional) If is set to true, means that filter expression is a regular
+     *                                     expression. Otherwise - not (default behaviour).
      * @return array
      */
     public static function arrayFilter($array, $arrayColumnKey, $filterExpression, $itsRegularExpression = false)
     {
-        $effect = [];
+        /*
+         * No elements?
+         * Nothing to do
+         */
+        if (empty($array)) {
+            return [];
+        }
 
-        if (!empty($array)) {
+        $effect = $array;
-            $effect = $array;
 
-            foreach ($effect as $key => &$item) {
+        foreach ($effect as $key => &$item) {
-                if (isset($item[$arrayColumnKey])) {
+            if (!isset($item[$arrayColumnKey])) {
-                    $value = $item[$arrayColumnKey];
+                continue;
+            }
 
-                    if ($itsRegularExpression) {
+            $value = $item[$arrayColumnKey];
-                        $matches = [];
-                        $pattern = '|' . $filterExpression . '|';
-                        $matchesCount = preg_match($pattern, $value, $matches);
 
-                        $remove = 0 == $matchesCount;
+            if ($itsRegularExpression) {
+                $matchesCount = preg_match($filterExpression, $value);
+                $remove = 0 == $matchesCount;
+            } else {
+                if (is_string($value)) {
+                    $value = sprintf('\'%s\'', $value);
+                } elseif (is_bool($value)) {
+                    if (true === $value) {
+                        $value = 'true';
                     } else {
-                        if ('' == $value) {
+                        $value = 'false';
-                            $value = '\'\'';
-                        } elseif (is_string($value)) {
-                            $value = '\'' . $value . '\'';
-                        }
-
-                        eval('$isTrue = ' . $value . $filterExpression . ';');
-
-                        /* @var bool $isTrue */
-                        $remove = !$isTrue;
-                    }
-
-                    if ($remove) {
-                        unset($effect[$key]);
                     }
                 }
+
+                eval(sprintf('$isEqual = %s%s;', $value, $filterExpression));
+
+                /* @var bool $isEqual */
+                $remove = !$isEqual;
+            }
+
+            if ($remove) {
+                unset($effect[$key]);
             }
         }
 
@@ -210,36 +275,41 @@ class Regex
     }
 
     /**
-     * Perform regular expression match with many given patterns.
+     * Performs regular expression match with many given patterns.
      * Returns information if given $subject matches one or all given $patterns.
      *
      * @param array|string $patterns     The patterns to match
      * @param string       $subject      The string to check
      * @param bool         $mustAllMatch (optional) If is set to true, $subject must match all $patterns. Otherwise -
-     *                                   not.
+     *                                   not (default behaviour).
      * @return bool
      */
     public static function pregMultiMatch($patterns, $subject, $mustAllMatch = false)
     {
+        /*
+         * No patterns?
+         * Nothing to do
+         */
+        if (empty($patterns)) {
+            return false;
+        }
+
         $effect = false;
         $patterns = Arrays::makeArray($patterns);
 
-        if (!empty($patterns)) {
+        if ($mustAllMatch) {
+            $effect = true;
+        }
+
+        foreach ($patterns as $pattern) {
+            $matched = (bool)preg_match_all($pattern, $subject);
+
             if ($mustAllMatch) {
-                $effect = true;
+                $effect = $effect && $matched;
-            }
+            } else {
-
+                if ($matched) {
-            foreach ($patterns as $pattern) {
+                    $effect = $matched;
-                $matches = [];
+                    break;
-                $matched = (bool)preg_match_all($pattern, $subject, $matches);
-
-                if ($mustAllMatch) {
-                    $effect = $effect && $matched;
-                } else {
-                    if ($matched) {
-                        $effect = $matched;
-                        break;
-                    }
                 }
             }
         }
@@ -676,6 +746,14 @@ class Regex
      */
     public static function isValidMoneyValue($value)
     {
+        /*
+         * Not a scalar value?
+         * Nothing to do
+         */
+        if (!is_scalar($value)) {
+            return false;
+        }
+
         $pattern = self::getMoneyPattern();
 
         return (bool)preg_match($pattern, $value);
@@ -688,39 +766,162 @@ class Regex
      * @param string $color          Color to verify
      * @param bool   $throwException (optional) If is set to true, throws an exception if given color is invalid
      *                               (default behaviour). Otherwise - not.
-     * @return string|bool
-     *
      * @throws IncorrectColorHexLengthException
      * @throws InvalidColorHexValueException
+     * @return string|bool
      */
     public static function getValidColorHexValue($color, $throwException = true)
     {
+        /*
+         * Not a scalar value?
+         * Nothing to do
+         */
+        if (!is_scalar($color)) {
+            return false;
+        }
+
         $color = Miscellaneous::replace($color, '/#/', '');
         $length = strlen($color);
 
-        if (3 === $length) {
+        /*
-            $color = Miscellaneous::replace($color, '/(.)(.)(.)/', '$1$1$2$2$3$3');
+         * Color is not 3 or 6 characters long?
-        } else {
+         * Nothing to do
-            if (6 !== $length) {
+         */
-                if ($throwException) {
+        if (3 !== $length && 6 !== $length) {
-                    throw new IncorrectColorHexLengthException($color);
-                }
-
-                return false;
-            }
-        }
-
-        $pattern = self::$patterns['color'];
-        $match = (bool)preg_match($pattern, $color);
-
-        if (!$match) {
             if ($throwException) {
-                throw new InvalidColorHexValueException($color);
+                throw new IncorrectColorHexLengthException($color);
             }
 
             return false;
         }
 
-        return strtolower($color);
+        /*
+         * Color is 3 characters long?
+         * Let's make it 6 characters long
+         */
+        if (3 === $length) {
+            $color = Miscellaneous::replace($color, '/(.)(.)(.)/', '$1$1$2$2$3$3');
+        }
+
+        $pattern = self::$patterns['color'];
+        $match = (bool)preg_match($pattern, $color);
+
+        /*
+         * It's valid color
+         * Nothing to do more
+         */
+        if ($match) {
+            return strtolower($color);
+        }
+
+        if ($throwException) {
+            throw new InvalidColorHexValueException($color);
+        }
+
+        return false;
+    }
+
+    /**
+     * Returns information if given name of bundle is valid
+     *
+     * @param string $bundleName Full name of bundle to verify, e.g. "MyExtraBundle"
+     * @return bool
+     */
+    public static function isValidBundleName($bundleName)
+    {
+        /*
+         * Not a string?
+         * Nothing to do
+         */
+        if (!is_string($bundleName)) {
+            return false;
+        }
+
+        $pattern = self::getBundleNamePattern();
+
+        return (bool)preg_match($pattern, $bundleName);
+    }
+
+    /**
+     * Returns pattern used to validate / verify name of bundle
+     *
+     * @return string
+     */
+    public static function getBundleNamePattern()
+    {
+        return self::$patterns['bundleName'];
+    }
+
+    /**
+     * Returns pattern used to validate / verify html attribute
+     *
+     * @return string
+     */
+    public static function getHtmlAttributePattern()
+    {
+        return self::$patterns['htmlAttribute'];
+    }
+
+    /**
+     * Returns information if given html attribute is valid
+     *
+     * @param string $htmlAttribute The html attribute to verify
+     * @return bool
+     */
+    public static function isValidHtmlAttribute($htmlAttribute)
+    {
+        /*
+         * Not a string?
+         * Nothing to do
+         */
+        if (!is_string($htmlAttribute)) {
+            return false;
+        }
+
+        $pattern = self::getHtmlAttributePattern();
+
+        return (bool)preg_match($pattern, $htmlAttribute);
+    }
+
+    /**
+     * Returns information if given html attributes are valid
+     *
+     * @param string $htmlAttributes The html attributes to verify
+     * @return bool
+     */
+    public static function areValidHtmlAttributes($htmlAttributes)
+    {
+        /*
+         * Not a string?
+         * Nothing to do
+         */
+        if (!is_string($htmlAttributes)) {
+            return false;
+        }
+
+        $pattern = self::getHtmlAttributePattern();
+
+        return (bool)preg_match_all($pattern, $htmlAttributes);
+    }
+
+    /**
+     * Returns information if given value is a binary value
+     *
+     * @param string $value Value to verify
+     * @return bool
+     */
+    public static function isBinaryValue($value)
+    {
+        /*
+         * Not a string?
+         * Nothing to do
+         */
+        if (!is_string($value)) {
+            return false;
+        }
+
+        $pattern = self::$patterns['binaryValue'];
+
+        return (bool)preg_match($pattern, $value);
     }
 }

src/Utilities/Repository.php

@@ -0,0 +1,235 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Utilities;
+
+use Doctrine\ORM\EntityRepository;
+use Doctrine\ORM\QueryBuilder;
+
+/**
+ * Useful methods for repository
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class Repository
+{
+    /**
+     * Name of key responsible for sorting/position of an item in array
+     *
+     * @var string
+     */
+    const POSITION_KEY = 'position';
+
+    /**
+     * Replenishes positions of given items
+     *
+     * @param array $items  Objects who have "getPosition()" and "setPosition()" methods or arrays
+     * @param bool  $asLast (optional) If is set to true, items are placed at the end (default behaviour). Otherwise -
+     *                      at top.
+     * @param bool  $force  (optional) If is set to true, positions are set even there is no extreme position.
+     *                      Otherwise - if extreme position is unknown (is null) replenishment is stopped / skipped
+     *                      (default behaviour).
+     */
+    public static function replenishPositions(array &$items, $asLast = true, $force = false)
+    {
+        $position = self::getExtremePosition($items, $asLast);
+
+        /*
+         * Extreme position is unknown, but it's required?
+         * Use 0 as default/start value
+         */
+        if (null === $position && $force) {
+            $position = 0;
+        }
+
+        /*
+         * Extreme position is unknown or there are no items to sort?
+         * Nothing to do
+         */
+        if (null === $position || empty($items)) {
+            return;
+        }
+
+        foreach ($items as &$item) {
+            /*
+             * The item is not sortable?
+             */
+            if (!self::isSortable($item)) {
+                continue;
+            }
+
+            /*
+             * Position has been set?
+             * Nothing to do
+             */
+            if (self::isSorted($item)) {
+                continue;
+            }
+
+            /*
+             * Calculate position
+             */
+            if ($asLast) {
+                ++$position;
+            } else {
+                --$position;
+            }
+
+            /*
+             * It's an object?
+             * Use proper method to set position
+             */
+            if (is_object($item)) {
+                $item->setPosition($position);
+                continue;
+            }
+
+            /*
+             * It's an array
+             * Use proper key to set position
+             */
+            $item[static::POSITION_KEY] = $position;
+        }
+    }
+
+    /**
+     * Returns extreme position (max or min) of given items
+     *
+     * @param array $items Objects who have "getPosition()" and "setPosition()" methods or arrays
+     * @param bool  $max   (optional) If is set to true, maximum value is returned. Otherwise - minimum.
+     * @return int
+     */
+    public static function getExtremePosition(array $items, $max = true)
+    {
+        /*
+         * No items?
+         * Nothing to do
+         */
+        if (empty($items)) {
+            return null;
+        }
+
+        $extreme = null;
+
+        foreach ($items as $item) {
+            /*
+             * The item is not sortable?
+             */
+            if (!self::isSortable($item)) {
+                continue;
+            }
+
+            $position = null;
+
+            /*
+             * Let's grab the position
+             */
+            if (is_object($item)) {
+                $position = $item->getPosition();
+            } elseif (array_key_exists(static::POSITION_KEY, $item)) {
+                $position = $item[static::POSITION_KEY];
+            }
+
+            /*
+             * Maximum value is expected?
+             */
+            if ($max) {
+                /*
+                 * Position was found and it's larger than previously found position (the extreme position)?
+                 */
+                if (null === $extreme || (null !== $position && $position > $extreme)) {
+                    $extreme = $position;
+                }
+
+                continue;
+            }
+
+            /*
+             * Minimum value is expected here.
+             * Position was found and it's smaller than previously found position (the extreme position)?
+             */
+            if (null === $extreme || (null !== $position && $position < $extreme)) {
+                $extreme = $position;
+            }
+        }
+
+        return $extreme;
+    }
+
+    /**
+     * Returns query builder for given entity's repository.
+     * The entity should contain given property, e.g. "name".
+     *
+     * @param EntityRepository $repository Repository of the entity
+     * @param string           $property   (optional) Name of property used by the ORDER BY clause
+     * @param string           $direction  (optional) Direction used by the ORDER BY clause ("ASC" or "DESC")
+     * @return QueryBuilder
+     */
+    public static function getEntityOrderedQueryBuilder(
+        EntityRepository $repository,
+        $property = 'name',
+        $direction = 'ASC'
+    ) {
+        $alias = 'qb';
+
+        return $repository
+            ->createQueryBuilder($alias)
+            ->orderBy(sprintf('%s.%s', $alias, $property), $direction);
+    }
+
+    /**
+     * Returns information if given item is sortable
+     *
+     * Sortable means it's an:
+     * - array
+     * or
+     * - object and has getPosition() and setPosition()
+     *
+     * @param mixed $item An item to verify (object who has "getPosition()" and "setPosition()" methods or an array)
+     * @return bool
+     */
+    private static function isSortable($item)
+    {
+        return is_array($item)
+            ||
+            (
+                is_object($item)
+                &&
+                Reflection::hasMethod($item, 'getPosition')
+                &&
+                Reflection::hasMethod($item, 'setPosition')
+            );
+    }
+
+    /**
+     * Returns information if given item is sorted (position has been set)
+     *
+     * @param mixed $item An item to verify (object who has "getPosition()" and "setPosition()" methods or an array)
+     * @return bool
+     */
+    private static function isSorted($item)
+    {
+        /*
+         * Given item is not sortable?
+         */
+        if (!self::isSortable($item)) {
+            return false;
+        }
+
+        /*
+         * It's an object or it's an array
+         * and position has been set?
+         */
+
+        return
+            (is_object($item) && null !== $item->getPosition())
+            ||
+            (is_array($item) && isset($item[static::POSITION_KEY]));
+    }
+}

src/Utilities/Uri.php

@@ -11,8 +11,8 @@ namespace Meritoo\Common\Utilities;
 /**
  * Useful uri methods (only static functions)
  *
- * @author     Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
- * @copyright  Meritoo.pl
+ * @copyright Meritoo.pl
  */
 class Uri
 {
@@ -24,13 +24,25 @@ class Uri
      */
     public static function getFullUri($withoutHost = false)
     {
-        $effect = Miscellaneous::getSafelyGlobalVariable(INPUT_SERVER, 'REQUEST_URI');
+        $requestedUrl = Miscellaneous::getSafelyGlobalVariable(INPUT_SERVER, 'REQUEST_URI');
 
-        if ($withoutHost) {
+        /*
-            return $effect;
+         * Unknown requested url?
+         * Nothing to do
+         */
+        if (empty($requestedUrl)) {
+            return '';
         }
 
-        return self::getServerNameOrIp(true) . $effect;
+        /*
+         * Without host / server name?
+         * All is done
+         */
+        if ($withoutHost) {
+            return $requestedUrl;
+        }
+
+        return self::getServerNameOrIp(true) . $requestedUrl;
     }
 
     /**
@@ -41,13 +53,25 @@ class Uri
      */
     public static function getServerNameOrIp($withProtocol = false)
     {
-        $protocol = '';
+        $host = Miscellaneous::getSafelyGlobalVariable(INPUT_SERVER, 'HTTP_HOST');
 
-        if ($withProtocol) {
+        /*
-            $protocol .= self::getProtocolName() . '://';
+         * Unknown host / server?
+         * Nothing to do
+         */
+        if (empty($host)) {
+            return '';
         }
 
-        return $protocol . Miscellaneous::getSafelyGlobalVariable(INPUT_SERVER, 'HTTP_HOST');
+        /*
+         * With protocol?
+         * Let's include the protocol
+         */
+        if ($withProtocol) {
+            return sprintf('%s://%s', self::getProtocolName(), $host);
+        }
+
+        return $host;
     }
 
     /**
@@ -57,8 +81,6 @@ class Uri
      */
     public static function getProtocolName()
     {
-        $effect = '';
-
         $matches = [];
         $protocolData = Miscellaneous::getSafelyGlobalVariable(INPUT_SERVER, 'SERVER_PROTOCOL'); // e.g. HTTP/1.1
         $matchCount = preg_match('|(.+)\/(.+)|', $protocolData, $matches);
@@ -68,11 +90,14 @@ class Uri
          * $matches[2] - protocol version, e.g. 1.1
          */
 
-        if ($matchCount > 0) {
+        /*
-            $effect = strtolower($matches[1]);
+         * Oops, cannot match protocol
+         */
+        if (0 == $matchCount) {
+            return '';
         }
 
-        return $effect;
+        return strtolower($matches[1]);
     }
 
     /**
@@ -82,13 +107,7 @@ class Uri
      */
     public static function getRefererUri()
     {
-        $effect = '';
+        return Miscellaneous::getSafelyGlobalVariable(INPUT_SERVER, 'HTTP_REFERER');
-
-        if (filter_has_var(INPUT_SERVER, 'HTTP_REFERER')) {
-            $effect = Miscellaneous::getSafelyGlobalVariable(INPUT_SERVER, 'HTTP_REFERER');
-        }
-
-        return $effect;
     }
 
     /**
@@ -214,10 +233,35 @@ class Uri
      */
     public static function isExternalUrl($url)
     {
+        /*
+         * Unknown url or it's just slash?
+         * Nothing to do
+         */
+        if (empty($url) || '/' === $url) {
+            return false;
+        }
+
         $currentUrl = self::getServerNameOrIp(true);
         $url = self::replenishProtocol($url);
 
-        return !Regex::contains($currentUrl, $url);
+        /*
+         * Let's prepare pattern of current url
+         */
+        $search = [
+            ':',
+            '/',
+            '.',
+        ];
+
+        $replace = [
+            '\:',
+            '\/',
+            '\.',
+        ];
+
+        $currentUrlPattern = str_replace($search, $replace, $currentUrl);
+
+        return !Regex::contains($url, $currentUrlPattern);
     }
 
     /**
@@ -273,6 +317,14 @@ class Uri
      */
     public static function getSecuredUrl($url, $user = '', $password = '')
     {
+        /*
+         * Url is not provided?
+         * Nothing to do
+         */
+        if (empty($url)) {
+            return '';
+        }
+
         $protocol = self::getProtocolName();
         $host = self::getServerNameOrIp();
 

src/Utilities/Xml.php

@@ -15,8 +15,8 @@ use SimpleXMLElement;
 /**
  * Useful XML-related methods (only static functions)
  *
- * @author     Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
- * @copyright  Meritoo.pl
+ * @copyright Meritoo.pl
  */
 class Xml
 {

tests/Collection/CollectionTest.php

@@ -9,12 +9,13 @@
 namespace Meritoo\Common\Test\Collection;
 
 use ArrayIterator;
+use Generator;
 use Meritoo\Common\Collection\Collection;
 use Meritoo\Common\Test\Base\BaseTestCase;
 use Meritoo\Common\Type\OopVisibilityType;
 
 /**
- * Tests of the collection of elements
+ * Test case of the collection of elements
  *
  * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
  * @copyright Meritoo.pl
@@ -129,22 +130,39 @@ class CollectionTest extends BaseTestCase
         static::assertInstanceOf(ArrayIterator::class, $this->simpleCollection->getIterator());
     }
 
-    public function testAdd()
+    /**
+     * @param mixed      $element       The element to add
+     * @param int        $expectedCount Expected count of elements in collection
+     * @param int        $expectedIndex Expected index of added element in collection
+     * @param Collection $collection    The collection
+     *
+     * @dataProvider provideElementToAdd
+     */
+    public function testAddWithoutIndex($element, $expectedCount, $expectedIndex, Collection $collection)
     {
-        $this->emptyCollection->add('test1');
+        $collection->add($element);
 
-        static::assertTrue($this->emptyCollection->has('test1'));
+        static::assertTrue($collection->has($element));
-        static::assertEquals(1, $this->emptyCollection->count());
+        static::assertEquals($expectedCount, $collection->count());
-        static::assertEquals('test1', $this->emptyCollection[0]);
+        static::assertEquals($element, $collection[$expectedIndex]);
     }
 
-    public function testAddWithIndex()
+    /**
+     * @param mixed      $element       The element to add
+     * @param mixed      $index         Index of element to add
+     * @param int        $expectedCount Expected count of elements in collection
+     * @param int        $expectedIndex Expected index of added element in collection
+     * @param Collection $collection    The collection
+     *
+     * @dataProvider provideElementToAddWithIndex
+     */
+    public function testAddWithIndex($element, $index, $expectedCount, $expectedIndex, Collection $collection)
     {
-        $this->emptyCollection->add('test2', 1234);
+        $collection->add($element, $index);
 
-        static::assertTrue($this->emptyCollection->has('test2'));
+        static::assertTrue($collection->has($element));
-        static::assertEquals(1, $this->emptyCollection->count());
+        static::assertEquals($expectedCount, $collection->count());
-        static::assertEquals('test2', $this->emptyCollection[1234]);
+        static::assertEquals($element, $collection[$expectedIndex]);
     }
 
     public function testAddMultipleUsingEmptyArray()
@@ -306,7 +324,88 @@ class CollectionTest extends BaseTestCase
 
     public function testExistsVisibilityAndArguments()
     {
-        $this->verifyMethodVisibilityAndArguments(Collection::class, 'exists', OopVisibilityType::IS_PRIVATE, 1, 1);
+        static::assertMethodVisibilityAndArguments(Collection::class, 'exists', OopVisibilityType::IS_PRIVATE, 1, 1);
+    }
+
+    /**
+     * Provides element to add to collection
+     *
+     * @return Generator
+     */
+    public function provideElementToAdd()
+    {
+        $collection = new Collection();
+
+        yield[
+            'test1',
+            1,
+            0,
+            $collection,
+        ];
+
+        yield[
+            'test2',
+            2,
+            1,
+            $collection,
+        ];
+
+        yield[
+            'test3',
+            3,
+            2,
+            $collection,
+        ];
+    }
+
+    /**
+     * Provides element with index to add to collection
+     *
+     * @return Generator
+     */
+    public function provideElementToAddWithIndex()
+    {
+        $collection = new Collection();
+
+        yield[
+            'test1',
+            'aa',
+            1,
+            'aa',
+            $collection,
+        ];
+
+        yield[
+            'test2',
+            'oo',
+            2,
+            'oo',
+            $collection,
+        ];
+
+        yield[
+            'test3',
+            null,
+            3,
+            0,
+            $collection,
+        ];
+
+        yield[
+            'test4',
+            '',
+            4,
+            1,
+            $collection,
+        ];
+
+        yield[
+            'test5',
+            'vv',
+            5,
+            'vv',
+            $collection,
+        ];
     }
 
     /**

tests/Exception/Base/UnknownTypeExceptionTest.php

@@ -9,17 +9,23 @@
 namespace Meritoo\Common\Test\Exception\Base;
 
 use Meritoo\Common\Exception\Base\UnknownTypeException;
+use Meritoo\Common\Test\Base\BaseTestCase;
 use Meritoo\Common\Type\Base\BaseType;
-use PHPUnit\Framework\TestCase;
+use Meritoo\Common\Type\OopVisibilityType;
 
 /**
- * Tests of the exception used while type of something is unknown
+ * Test case of the exception used while type of something is unknown
  *
  * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
  * @copyright Meritoo.pl
  */
-class UnknownTypeExceptionTest extends TestCase
+class UnknownTypeExceptionTest extends BaseTestCase
 {
+    public function testConstructorVisibilityAndArguments()
+    {
+        static::assertConstructorVisibilityAndArguments(UnknownTestTypeException::class, OopVisibilityType::IS_PUBLIC, 1, 1);
+    }
+
     public function testWithoutException()
     {
         self::assertEquals('Test 2', (new TestService())->getTranslatedType('test_2'));
@@ -27,7 +33,7 @@ class UnknownTypeExceptionTest extends TestCase
 
     public function testTheException()
     {
-        $this->expectException(UnknownTestTypeException::class);
+        $this->setExpectedException(UnknownTestTypeException::class);
         self::assertEmpty((new TestService())->getTranslatedType('test_3'));
     }
 }
@@ -76,9 +82,8 @@ class TestService
      * Returns translated type (for testing purposes)
      *
      * @param string $type Type of something (for testing purposes)
-     * @return string
-     *
      * @throws UnknownTestTypeException
+     * @return string
      */
     public function getTranslatedType($type)
     {

tests/Exception/Date/UnknownDatePartTypeExceptionTest.php

@@ -0,0 +1,71 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Exception\Date;
+
+use Generator;
+use Meritoo\Common\Exception\Date\UnknownDatePartTypeException;
+use Meritoo\Common\Test\Base\BaseTestCase;
+use Meritoo\Common\Type\DatePartType;
+use Meritoo\Common\Type\OopVisibilityType;
+
+/**
+ * Test case of an exception used while type of date part, e.g. "year", is unknown
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class UnknownDatePartTypeExceptionTest extends BaseTestCase
+{
+    public function testConstructorVisibilityAndArguments()
+    {
+        static::assertConstructorVisibilityAndArguments(UnknownDatePartTypeException::class, OopVisibilityType::IS_PUBLIC, 2, 2);
+    }
+
+    /**
+     * @param string $unknownDatePart Type of date part, e.g. "year". One of DatePartType class constants.
+     * @param string $value           Incorrect value
+     * @param string $expectedMessage Expected exception's message
+     *
+     * @dataProvider provideDatePartAndValue
+     */
+    public function testConstructorMessage($unknownDatePart, $value, $expectedMessage)
+    {
+        $exception = new UnknownDatePartTypeException($unknownDatePart, $value);
+        static::assertEquals($expectedMessage, $exception->getMessage());
+    }
+
+    /**
+     * Provides type of date part, incorrect value and expected exception's message
+     *
+     * @return Generator
+     */
+    public function provideDatePartAndValue()
+    {
+        $template = 'The \'%s\' type of date part (with value %s) is unknown. Probably doesn\'t exist or there is a'
+            . ' typo. You should use one of these types: day, hour, minute, month, second, year.';
+
+        yield[
+            DatePartType::DAY,
+            '44',
+            sprintf($template, DatePartType::DAY, '44'),
+        ];
+
+        yield[
+            DatePartType::MONTH,
+            '22',
+            sprintf($template, DatePartType::MONTH, '22'),
+        ];
+
+        yield[
+            DatePartType::MINUTE,
+            '77',
+            sprintf($template, DatePartType::MINUTE, '77'),
+        ];
+    }
+}

tests/Exception/File/EmptyFileExceptionTest.php

@@ -0,0 +1,60 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Exception\File;
+
+use Generator;
+use Meritoo\Common\Exception\File\EmptyFileException;
+use Meritoo\Common\Test\Base\BaseTestCase;
+use Meritoo\Common\Type\OopVisibilityType;
+
+/**
+ * Test case of an exception used while file with given path is empty (has no content)
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class EmptyFileExceptionTest extends BaseTestCase
+{
+    public function testConstructorVisibilityAndArguments()
+    {
+        static::assertConstructorVisibilityAndArguments(EmptyFileException::class, OopVisibilityType::IS_PUBLIC, 1, 1);
+    }
+
+    /**
+     * @param string $emptyFilePath   Path of the empty file
+     * @param string $expectedMessage Expected exception's message
+     *
+     * @dataProvider providePathOfFile
+     */
+    public function testConstructorMessage($emptyFilePath, $expectedMessage)
+    {
+        $exception = new EmptyFileException($emptyFilePath);
+        static::assertEquals($expectedMessage, $exception->getMessage());
+    }
+
+    /**
+     * Provides path of the empty file and expected exception's message
+     *
+     * @return Generator
+     */
+    public function providePathOfFile()
+    {
+        $template = 'File with path \'%s\' is empty (has no content). Did you provide path of proper file?';
+
+        yield[
+            'aa/bb/cc',
+            sprintf($template, 'aa/bb/cc'),
+        ];
+
+        yield[
+            'images/show/car.jpg',
+            sprintf($template, 'images/show/car.jpg'),
+        ];
+    }
+}

tests/Exception/File/EmptyFilePathExceptionTest.php

@@ -0,0 +1,33 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Exception\File;
+
+use Meritoo\Common\Exception\File\EmptyFilePathException;
+use Meritoo\Common\Test\Base\BaseTestCase;
+use Meritoo\Common\Type\OopVisibilityType;
+
+/**
+ * Test case of an exception used while path of given file is empty
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class EmptyFilePathExceptionTest extends BaseTestCase
+{
+    public function testConstructorVisibilityAndArguments()
+    {
+        static::assertConstructorVisibilityAndArguments(EmptyFilePathException::class, OopVisibilityType::IS_PUBLIC);
+    }
+
+    public function testConstructorMessage()
+    {
+        $exception = new EmptyFilePathException();
+        static::assertEquals('Path of the file is empty. Did you provide path of proper file?', $exception->getMessage());
+    }
+}

tests/Exception/File/NotExistingFileExceptionTest.php

@@ -0,0 +1,60 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Exception\File;
+
+use Generator;
+use Meritoo\Common\Exception\File\NotExistingFileException;
+use Meritoo\Common\Test\Base\BaseTestCase;
+use Meritoo\Common\Type\OopVisibilityType;
+
+/**
+ * Test case of an exception used while file with given path does not exist
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class NotExistingFileExceptionTest extends BaseTestCase
+{
+    public function testConstructorVisibilityAndArguments()
+    {
+        static::assertConstructorVisibilityAndArguments(NotExistingFileException::class, OopVisibilityType::IS_PUBLIC, 1, 1);
+    }
+
+    /**
+     * @param string $notExistingFilePath Path of not existing (or not readable) file
+     * @param string $expectedMessage     Expected exception's message
+     *
+     * @dataProvider providePathOfFile
+     */
+    public function testConstructorMessage($notExistingFilePath, $expectedMessage)
+    {
+        $exception = new NotExistingFileException($notExistingFilePath);
+        static::assertEquals($expectedMessage, $exception->getMessage());
+    }
+
+    /**
+     * Provides path of not existing file and expected exception's message
+     *
+     * @return Generator
+     */
+    public function providePathOfFile()
+    {
+        $template = 'File with path \'%s\' does not exist (or is not readable). Did you provide path of proper file?';
+
+        yield[
+            'aa/bb/cc',
+            sprintf($template, 'aa/bb/cc'),
+        ];
+
+        yield[
+            'images/show/car.jpg',
+            sprintf($template, 'images/show/car.jpg'),
+        ];
+    }
+}

tests/Exception/Method/DisabledMethodExceptionTest.php

@@ -0,0 +1,65 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Exception\Method;
+
+use Generator;
+use Meritoo\Common\Exception\Method\DisabledMethodException;
+use Meritoo\Common\Test\Base\BaseTestCase;
+use Meritoo\Common\Type\OopVisibilityType;
+
+/**
+ * Test case of an exception used while method cannot be called, because is disabled
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class DisabledMethodExceptionTest extends BaseTestCase
+{
+    public function testConstructorVisibilityAndArguments()
+    {
+        static::assertConstructorVisibilityAndArguments(DisabledMethodException::class, OopVisibilityType::IS_PUBLIC, 2, 1);
+    }
+
+    /**
+     * @param string $disabledMethod    Name of the disabled method
+     * @param string $alternativeMethod Name of the alternative method
+     * @param string $expectedMessage   Expected exception's message
+     *
+     * @internal     param string $emptyFilePath Path of the empty file
+     * @dataProvider provideMethodsNames
+     */
+    public function testConstructorMessage($disabledMethod, $alternativeMethod, $expectedMessage)
+    {
+        $exception = new DisabledMethodException($disabledMethod, $alternativeMethod);
+        static::assertEquals($expectedMessage, $exception->getMessage());
+    }
+
+    /**
+     * Provides name of the disabled method, name of the alternative method and expected exception's message
+     *
+     * @return Generator
+     */
+    public function provideMethodsNames()
+    {
+        $templateShort = 'Method %s() cannot be called, because is disabled.';
+        $templateLong = $templateShort . ' Use %s() instead.';
+
+        yield[
+            'FooBar::loremIpsum',
+            '',
+            sprintf($templateShort, 'FooBar::loremIpsum'),
+        ];
+
+        yield[
+            'FooBar::loremIpsum',
+            'AnotherClass::alternativeMethod',
+            sprintf($templateLong, 'FooBar::loremIpsum', 'AnotherClass::alternativeMethod'),
+        ];
+    }
+}

tests/Exception/Reflection/CannotResolveClassNameExceptionTest.php

@@ -0,0 +1,73 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Exception\Reflection;
+
+use Generator;
+use Meritoo\Common\Exception\Reflection\CannotResolveClassNameException;
+use Meritoo\Common\Test\Base\BaseTestCase;
+use Meritoo\Common\Type\OopVisibilityType;
+
+/**
+ * Test case of an exception used while name of class or trait cannot be resolved
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class CannotResolveClassNameExceptionTest extends BaseTestCase
+{
+    public function testConstructorVisibilityAndArguments()
+    {
+        static::assertConstructorVisibilityAndArguments(CannotResolveClassNameException::class, OopVisibilityType::IS_PUBLIC, 2, 1);
+    }
+
+    /**
+     * @param array|object|string $source          Source of the class's / trait's name. It can be an array of objects,
+     *                                             namespaces, object or namespace.
+     * @param bool                $forClass        If is set to true, message of this exception for class is prepared.
+     *                                             Otherwise - for trait.
+     * @param string              $expectedMessage Expected exception's message
+     *
+     * @dataProvider provideClassName
+     */
+    public function testConstructorMessage($source, $forClass, $expectedMessage)
+    {
+        $exception = new CannotResolveClassNameException($source, $forClass);
+        static::assertEquals($expectedMessage, $exception->getMessage());
+    }
+
+    /**
+     * Provides source of the class's / trait's name, information if message of this exception should be prepared for
+     * class and the expected exception's message
+     *
+     * @return Generator
+     */
+    public function provideClassName()
+    {
+        yield[
+            'Not\Existing\Class',
+            true,
+            'Name of class from given \'string\' Not\Existing\Class cannot be resolved. Is there everything ok?',
+        ];
+
+        yield[
+            'Not\Existing\Trait',
+            false,
+            'Name of trait from given \'string\' Not\Existing\Trait cannot be resolved. Is there everything ok?',
+        ];
+
+        yield[
+            [
+                new \stdClass(),
+                new \stdClass(),
+            ],
+            true,
+            'Name of class from given \'array\' cannot be resolved. Is there everything ok?',
+        ];
+    }
+}

tests/Exception/Reflection/MissingChildClassesExceptionTest.php

@@ -0,0 +1,65 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Exception\Reflection;
+
+use Generator;
+use Meritoo\Common\Exception\Reflection\MissingChildClassesException;
+use Meritoo\Common\Test\Base\BaseTestCase;
+use Meritoo\Common\Type\OopVisibilityType;
+
+/**
+ * Test case of an exception used while given class has no child classes
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class MissingChildClassesExceptionTest extends BaseTestCase
+{
+    public function testConstructorVisibilityAndArguments()
+    {
+        static::assertConstructorVisibilityAndArguments(MissingChildClassesException::class, OopVisibilityType::IS_PUBLIC, 1, 1);
+    }
+
+    /**
+     * @param array|object|string $parentClass     Class that hasn't child classes, but it should. An array of objects,
+     *                                             strings, object or string.
+     * @param string              $expectedMessage Expected exception's message
+     *
+     * @dataProvider provideParentClass
+     */
+    public function testConstructorMessage($parentClass, $expectedMessage)
+    {
+        $exception = new MissingChildClassesException($parentClass);
+        static::assertEquals($expectedMessage, $exception->getMessage());
+    }
+
+    /**
+     * Provides name of class that hasn't child classes, but it should, and expected exception's message
+     *
+     * @return Generator
+     */
+    public function provideParentClass()
+    {
+        $template = 'The \'%s\' class requires one child class at least who will extend her (maybe is an abstract'
+            . ' class), but the child classes are missing. Did you forget to extend this class?';
+
+        yield[
+            MissingChildClassesException::class,
+            sprintf($template, MissingChildClassesException::class),
+        ];
+
+        yield[
+            [
+                new \stdClass(),
+                new \stdClass(),
+            ],
+            sprintf($template, \stdClass::class),
+        ];
+    }
+}

tests/Exception/Reflection/TooManyChildClassesExceptionTest.php

@@ -0,0 +1,74 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Exception\Reflection;
+
+use Generator;
+use Meritoo\Common\Exception\Reflection\TooManyChildClassesException;
+use Meritoo\Common\Test\Base\BaseTestCase;
+use Meritoo\Common\Type\OopVisibilityType;
+
+/**
+ * Test case of an exception used while given class has more than one child class
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class TooManyChildClassesExceptionTest extends BaseTestCase
+{
+    public function testConstructorVisibilityAndArguments()
+    {
+        static::assertConstructorVisibilityAndArguments(TooManyChildClassesException::class, OopVisibilityType::IS_PUBLIC, 2, 2);
+    }
+
+    /**
+     * @param array|object|string $parentClass     Class that has more than one child class, but it shouldn't. An array
+     *                                             of objects, strings, object or string.
+     * @param array               $childClasses    Child classes
+     * @param string              $expectedMessage Expected exception's message
+     *
+     * @dataProvider provideParentAndChildClasses
+     */
+    public function testConstructorMessage($parentClass, array $childClasses, $expectedMessage)
+    {
+        $exception = new TooManyChildClassesException($parentClass, $childClasses);
+        static::assertEquals($expectedMessage, $exception->getMessage());
+    }
+
+    /**
+     * Provides name of class that has more than one child class, but it shouldn't, child classes, and expected
+     * exception's message
+     *
+     * @return Generator
+     */
+    public function provideParentAndChildClasses()
+    {
+        $template = "The '%s' class requires one child class at most who will extend her, but more than one child"
+            . " class was found:\n- %s\n\nWhy did you create more than one classes that extend '%s' class?";
+
+        yield[
+            BaseTestCase::class,
+            [
+                \stdClass::class,
+                OopVisibilityType::class,
+            ],
+            sprintf($template, BaseTestCase::class, implode("\n- ", [
+                \stdClass::class,
+                OopVisibilityType::class,
+            ]), BaseTestCase::class),
+        ];
+
+        yield[
+            TooManyChildClassesException::class,
+            [
+                \stdClass::class,
+            ],
+            sprintf($template, TooManyChildClassesException::class, implode("\n- ", [\stdClass::class]), TooManyChildClassesException::class),
+        ];
+    }
+}

tests/Exception/Regex/IncorrectColorHexLengthExceptionTest.php

@@ -0,0 +1,60 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Exception\Regex;
+
+use Generator;
+use Meritoo\Common\Exception\Regex\IncorrectColorHexLengthException;
+use Meritoo\Common\Test\Base\BaseTestCase;
+use Meritoo\Common\Type\OopVisibilityType;
+
+/**
+ * Test case of an exception used while length of given hexadecimal value of color is incorrect
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class IncorrectColorHexLengthExceptionTest extends BaseTestCase
+{
+    public function testConstructorVisibilityAndArguments()
+    {
+        static::assertConstructorVisibilityAndArguments(IncorrectColorHexLengthException::class, OopVisibilityType::IS_PUBLIC, 1, 1);
+    }
+
+    /**
+     * @param string $color           Incorrect hexadecimal value of color
+     * @param string $expectedMessage Expected exception's message
+     *
+     * @dataProvider provideColor
+     */
+    public function testConstructorMessage($color, $expectedMessage)
+    {
+        $exception = new IncorrectColorHexLengthException($color);
+        static::assertEquals($expectedMessage, $exception->getMessage());
+    }
+
+    /**
+     * Provides incorrect hexadecimal value of color and expected exception's message
+     *
+     * @return Generator
+     */
+    public function provideColor()
+    {
+        $template = 'Length of hexadecimal value of color \'%s\' is incorrect. It\'s %d, but it should be 3 or 6. Is there everything ok?';
+
+        yield[
+            '',
+            sprintf($template, '', strlen('')),
+        ];
+
+        yield[
+            'aa-bb-cc',
+            sprintf($template, 'aa-bb-cc', strlen('aa-bb-cc')),
+        ];
+    }
+}

tests/Exception/Regex/InvalidColorHexValueExceptionTest.php

@@ -0,0 +1,64 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Exception\Regex;
+
+use Generator;
+use Meritoo\Common\Exception\Regex\InvalidColorHexValueException;
+use Meritoo\Common\Exception\Type\UnknownOopVisibilityTypeException;
+use Meritoo\Common\Test\Base\BaseTestCase;
+use Meritoo\Common\Type\OopVisibilityType;
+
+/**
+ * Test case of an exception used while given hexadecimal value of color is invalid
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class InvalidColorHexValueExceptionTest extends BaseTestCase
+{
+    /**
+     * @throws UnknownOopVisibilityTypeException
+     */
+    public function testConstructorVisibilityAndArguments()
+    {
+        static::assertConstructorVisibilityAndArguments(InvalidColorHexValueException::class, OopVisibilityType::IS_PUBLIC, 1, 1);
+    }
+
+    /**
+     * @param string $color           Invalid hexadecimal value of color
+     * @param string $expectedMessage Expected exception's message
+     *
+     * @dataProvider provideColor
+     */
+    public function testConstructorMessage($color, $expectedMessage)
+    {
+        $exception = new InvalidColorHexValueException($color);
+        static::assertEquals($expectedMessage, $exception->getMessage());
+    }
+
+    /**
+     * Provides invalid hexadecimal value of color and expected exception's message
+     *
+     * @return Generator
+     */
+    public function provideColor()
+    {
+        $template = 'Hexadecimal value of color \'%s\' is invalid. Is there everything ok?';
+
+        yield[
+            '',
+            sprintf($template, ''),
+        ];
+
+        yield[
+            'aa-bb-cc',
+            sprintf($template, 'aa-bb-cc'),
+        ];
+    }
+}

tests/Exception/Regex/InvalidHtmlAttributesExceptionTest.php

@@ -0,0 +1,69 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Exception\Regex;
+
+use Generator;
+use Meritoo\Common\Exception\Regex\InvalidHtmlAttributesException;
+use Meritoo\Common\Exception\Type\UnknownOopVisibilityTypeException;
+use Meritoo\Common\Test\Base\BaseTestCase;
+use Meritoo\Common\Type\OopVisibilityType;
+
+/**
+ * Test case of an exception used while html attributes are invalid
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class InvalidHtmlAttributesExceptionTest extends BaseTestCase
+{
+    /**
+     * @throws UnknownOopVisibilityTypeException
+     */
+    public function testConstructorVisibilityAndArguments()
+    {
+        static::assertConstructorVisibilityAndArguments(InvalidHtmlAttributesException::class, OopVisibilityType::IS_PUBLIC, 1, 1);
+    }
+
+    /**
+     * @param string $htmlAttributes  Invalid html attributes
+     * @param string $expectedMessage Expected exception's message
+     *
+     * @dataProvider provideHtmlAttributes
+     */
+    public function testConstructorMessage($htmlAttributes, $expectedMessage)
+    {
+        $exception = new InvalidHtmlAttributesException($htmlAttributes);
+        static::assertEquals($expectedMessage, $exception->getMessage());
+    }
+
+    /**
+     * Provides html attributes
+     *
+     * @return Generator
+     */
+    public function provideHtmlAttributes()
+    {
+        $template = 'HTML attributes \'%s\' are invalid. Is there everything ok?';
+
+        yield[
+            'abc = def',
+            sprintf($template, 'abc = def'),
+        ];
+
+        yield[
+            'abc = def ghi = jkl',
+            sprintf($template, 'abc = def ghi = jkl'),
+        ];
+
+        yield[
+            'abc=def ghi=jkl',
+            sprintf($template, 'abc=def ghi=jkl'),
+        ];
+    }
+}

tests/Exception/Regex/InvalidUrlExceptionTest.php

@@ -0,0 +1,60 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Exception\Regex;
+
+use Generator;
+use Meritoo\Common\Exception\Regex\InvalidUrlException;
+use Meritoo\Common\Test\Base\BaseTestCase;
+use Meritoo\Common\Type\OopVisibilityType;
+
+/**
+ * Test case of an exception used while url is invalid
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class InvalidUrlExceptionTest extends BaseTestCase
+{
+    public function testConstructorVisibilityAndArguments()
+    {
+        static::assertConstructorVisibilityAndArguments(InvalidUrlException::class, OopVisibilityType::IS_PUBLIC, 1, 1);
+    }
+
+    /**
+     * @param string $url             Invalid url
+     * @param string $expectedMessage Expected exception's message
+     *
+     * @dataProvider provideUrl
+     */
+    public function testConstructorMessage($url, $expectedMessage)
+    {
+        $exception = new InvalidUrlException($url);
+        static::assertEquals($expectedMessage, $exception->getMessage());
+    }
+
+    /**
+     * Provides invalid url and expected exception's message
+     *
+     * @return Generator
+     */
+    public function provideUrl()
+    {
+        $template = 'Url \'%s\' is invalid. Is there everything ok?';
+
+        yield[
+            'aa/bb/cc',
+            sprintf($template, 'aa/bb/cc'),
+        ];
+
+        yield[
+            'http:/images\show\car.jpg',
+            sprintf($template, 'http:/images\show\car.jpg'),
+        ];
+    }
+}

tests/Exception/Type/UnknownOopVisibilityTypeExceptionTest.php

@@ -0,0 +1,64 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Exception\Type;
+
+use Generator;
+use Meritoo\Common\Exception\Type\UnknownOopVisibilityTypeException;
+use Meritoo\Common\Test\Base\BaseTestCase;
+use Meritoo\Common\Type\OopVisibilityType;
+
+/**
+ * Test case of an exception used while the visibility of a property, a method or (as of PHP 7.1.0) a constant is
+ * unknown
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class UnknownOopVisibilityTypeExceptionTest extends BaseTestCase
+{
+    public function testConstructorVisibilityAndArguments()
+    {
+        static::assertConstructorVisibilityAndArguments(UnknownOopVisibilityTypeException::class, OopVisibilityType::IS_PUBLIC, 1, 1);
+    }
+
+    /**
+     * @param string $unknownType     Unknown OOP-related visibility
+     * @param string $expectedMessage Expected exception's message
+     *
+     * @dataProvider provideUnknownType
+     */
+    public function testConstructorMessage($unknownType, $expectedMessage)
+    {
+        $exception = new UnknownOopVisibilityTypeException($unknownType);
+        static::assertEquals($expectedMessage, $exception->getMessage());
+    }
+
+    /**
+     * Provides path of the empty file and expected exception's message
+     *
+     * @return Generator
+     */
+    public function provideUnknownType()
+    {
+        $allTypes = (new OopVisibilityType())->getAll();
+
+        $template = 'The \'%s\' type of OOP-related visibility is unknown. Probably doesn\'t exist or there is a typo.'
+            . ' You should use one of these types: %s.';
+
+        yield[
+            '',
+            sprintf($template, '', implode(', ', $allTypes)),
+        ];
+
+        yield[
+            123,
+            sprintf($template, 123, implode(', ', $allTypes)),
+        ];
+    }
+}

tests/Meritoo/Common/Test/Utilities/BundleTest.php

@@ -1,40 +0,0 @@
-<?php
-
-/**
- * (c) Meritoo.pl, http://www.meritoo.pl
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-namespace Meritoo\Common\Test\Utilities;
-
-use Meritoo\Common\Utilities\Bundle;
-use PHPUnit\Framework\TestCase;
-
-/**
- * Tests of the useful methods for bundle
- *
- * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
- * @copyright Meritoo.pl
- */
-class BundleTest extends TestCase
-{
-    public function testGetBundleViewPathEmptyPathAndBundle()
-    {
-        self::assertNull(Bundle::getBundleViewPath('', ''));
-        self::assertNull(Bundle::getBundleViewPath('test', ''));
-        self::assertNull(Bundle::getBundleViewPath('', 'test'));
-    }
-
-    public function testGetBundleViewPathWithDefaultExtension()
-    {
-        self::assertEquals('Lorem:Ipsum.html.twig', Bundle::getBundleViewPath('Ipsum', 'Lorem'));
-        self::assertEquals('LobortisTincidunt:FusceElementum.html.twig', Bundle::getBundleViewPath('FusceElementum', 'LobortisTincidunt'));
-    }
-
-    public function testGetBundleViewPathWithCustomExtension()
-    {
-        self::assertNull(Bundle::getBundleViewPath('Ipsum', 'Lorem', ''));
-        self::assertEquals('Lorem:Ipsum.js.twig', Bundle::getBundleViewPath('Ipsum', 'Lorem', 'js.twig'));
-    }
-}

tests/Meritoo/Common/Test/Utilities/LocaleTest.php

@@ -1,129 +0,0 @@
-<?php
-
-/**
- * (c) Meritoo.pl, http://www.meritoo.pl
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-namespace Meritoo\Common\Test\Utilities;
-
-use Generator;
-use Meritoo\Common\Test\Base\BaseTestCase;
-use Meritoo\Common\Utilities\Locale;
-
-/**
- * Tests of the useful locale methods
- *
- * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
- * @copyright Meritoo.pl
- */
-class LocaleTest extends BaseTestCase
-{
-    /**
-     * @param mixed $languageCode Empty value, e.g. ""
-     * @dataProvider provideEmptyValue
-     */
-    public function testGetLongFormEmptyLanguageCode($languageCode)
-    {
-        self::assertEquals('', Locale::getLongForm($languageCode));
-    }
-
-    /**
-     * @param string $languageCode Language code, in ISO 639-1 format. Short form of the locale, e.g. "fr".
-     * @param string $countryCode  Country code, in ISO 3166-1 alpha-2 format, e.g. "FR"
-     * @param string $encoding     Encoding of the final locale
-     * @param string $expected     Expected long form of the locale
-     *
-     * @dataProvider provideLanguageAndCountryCode
-     */
-    public function testGetLongForm($languageCode, $countryCode, $encoding, $expected)
-    {
-        self::assertEquals($expected, Locale::getLongForm($languageCode, $countryCode, $encoding));
-    }
-
-    /**
-     * @param mixed $emptyValue Empty value, e.g. ""
-     * @dataProvider provideEmptyValue
-     */
-    public function testSetLocaleEmptyCategoryAndLanguageCode($emptyValue)
-    {
-        self::assertFalse(Locale::setLocale($emptyValue, $emptyValue));
-    }
-
-    /**
-     * @param int    $category     Named constant specifying the category of the functions affected by the locale
-     *                             setting. It's the same constant as required by setlocale() function.
-     * @param string $languageCode Language code, in ISO 639-1 format. Short form of the locale, e.g. "fr".
-     *
-     * @dataProvider provideCategoryAndLanguageCode
-     */
-    public function testSetLocale($category, $languageCode)
-    {
-        self::assertTrue(Locale::setLocale($category, $languageCode));
-    }
-
-    /**
-     * Provides language and country code
-     *
-     * @return Generator
-     */
-    public function provideLanguageAndCountryCode()
-    {
-        yield[
-            'fr',
-            '',
-            '',
-            'fr_FR',
-        ];
-
-        yield[
-            'fr',
-            '',
-            'UTF-8',
-            'fr_FR.UTF-8',
-        ];
-
-        yield[
-            'fr',
-            'FR',
-            '',
-            'fr_FR',
-        ];
-
-        yield[
-            'fr',
-            'FR',
-            'UTF-8',
-            'fr_FR.UTF-8',
-        ];
-    }
-
-    /**
-     * Provides category and language
-     *
-     * @return Generator
-     */
-    public function provideCategoryAndLanguageCode()
-    {
-        yield[
-            LC_ALL,
-            'fr',
-        ];
-
-        yield[
-            LC_COLLATE,
-            'fr',
-        ];
-
-        yield[
-            LC_CTYPE,
-            'en',
-        ];
-
-        yield[
-            LC_NUMERIC,
-            'en',
-        ];
-    }
-}

tests/Meritoo/Common/Test/Utilities/ReflectionTest.php

@@ -1,246 +0,0 @@
-<?php
-
-/**
- * (c) Meritoo.pl, http://www.meritoo.pl
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-namespace Meritoo\Common\Test\Utilities;
-
-use DateTime;
-use Generator;
-use Meritoo\Common\Exception\Reflection\CannotResolveClassNameException;
-use Meritoo\Common\Exception\Reflection\MissingChildClassesException;
-use Meritoo\Common\Exception\Reflection\TooManyChildClassesException;
-use Meritoo\Common\Test\Base\BaseTestCase;
-use Meritoo\Common\Test\Utilities\Reflection\A;
-use Meritoo\Common\Test\Utilities\Reflection\B;
-use Meritoo\Common\Test\Utilities\Reflection\C;
-use Meritoo\Common\Test\Utilities\Reflection\D;
-use Meritoo\Common\Test\Utilities\Reflection\E;
-use Meritoo\Common\Utilities\Reflection;
-
-/**
- * Tests of the useful reflection methods
- *
- * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
- * @copyright Meritoo.pl
- */
-class ReflectionTest extends BaseTestCase
-{
-    /**
-     * @param mixed $invalidClass Empty value, e.g. ""
-     * @dataProvider provideEmptyValue
-     */
-    public function testGetClassNameInvalidClass($invalidClass)
-    {
-        self::assertNull(Reflection::getClassName($invalidClass));
-        self::assertNull(Reflection::getClassName(123));
-    }
-
-    public function testGetClassNameNotExistingClass()
-    {
-        /*
-         * Not existing class
-         */
-        self::assertEquals('', Reflection::getClassName('xyz'));
-        self::assertEquals('', Reflection::getClassName('xyz', true));
-    }
-
-    public function testGetClassNameExistingClass()
-    {
-        /*
-         * Existing class
-         */
-        self::assertEquals(self::class, Reflection::getClassName(self::class));
-        self::assertEquals('ReflectionTest', Reflection::getClassName(self::class, true));
-        self::assertEquals(DateTime::class, Reflection::getClassName(new DateTime()));
-        self::assertEquals(DateTime::class, Reflection::getClassName(new DateTime(), true));
-
-        self::assertEquals(DateTime::class, Reflection::getClassName([
-            new DateTime(),
-            new DateTime('yesterday'),
-        ]));
-    }
-
-    public function testGetClassNameDuplicatedName()
-    {
-        /*
-         * Class with namespace containing name of class (duplicated string)
-         */
-        if (class_exists('Symfony\Bundle\SecurityBundle\SecurityBundle')) {
-            self::assertEquals('Symfony\Bundle\SecurityBundle\SecurityBundle', Reflection::getClassName('Symfony\Bundle\SecurityBundle\SecurityBundle'));
-            self::assertEquals('SecurityBundle', Reflection::getClassName('Symfony\Bundle\SecurityBundle\SecurityBundle', true));
-        }
-    }
-
-    public function testGetClassNamespaceNotExistingClass()
-    {
-        /*
-         * Not existing class
-         */
-        self::assertEquals('', Reflection::getClassNamespace('xyz'));
-    }
-
-    public function testGetClassNamespaceExistingClass()
-    {
-        /*
-         * Existing class
-         */
-        self::assertEquals('Meritoo\Common\Test\Utilities', Reflection::getClassNamespace(self::class));
-        self::assertEquals(DateTime::class, Reflection::getClassNamespace(new DateTime()));
-
-        self::assertEquals(DateTime::class, Reflection::getClassNamespace([
-            new DateTime(),
-            new DateTime('yesterday'),
-        ]));
-    }
-
-    public function testGetClassNamespaceDuplicatedName()
-    {
-        /*
-         * Class with namespace containing name of class (duplicated string)
-         */
-        if (class_exists('Symfony\Bundle\SecurityBundle\SecurityBundle')) {
-            self::assertEquals('Symfony\Bundle\SecurityBundle', Reflection::getClassNamespace('Symfony\Bundle\SecurityBundle\SecurityBundle'));
-        }
-    }
-
-    /**
-     * @param mixed $invalidClass Empty value, e.g. ""
-     * @dataProvider provideEmptyValue
-     */
-    public function testGetChildClassesInvalidClass($invalidClass)
-    {
-        $this->expectException(CannotResolveClassNameException::class);
-
-        self::assertNull(Reflection::getChildClasses($invalidClass));
-        self::assertNull(Reflection::getChildClasses(123));
-    }
-
-    public function testGetChildClassesNotExistingClass()
-    {
-        $this->expectException(CannotResolveClassNameException::class);
-        self::assertEquals('', Reflection::getChildClasses('xyz'));
-    }
-
-    public function testGetChildClassesExistingClass()
-    {
-        /*
-         * Attention. I have to create instances of these classes to load them and be available while using
-         * get_declared_classes() function in the Reflection::getChildClasses() method. Without these instances the
-         * Reflection::getChildClasses() method returns an empty array even if given class has child classes.
-         */
-        new A();
-        new B();
-        new C();
-
-        $effect = [
-            C::class,
-        ];
-
-        self::assertEquals($effect, Reflection::getChildClasses(B::class));
-
-        $effect = [
-            B::class,
-            C::class,
-        ];
-
-        self::assertEquals($effect, Reflection::getChildClasses(A::class));
-    }
-
-    public function testGetOneChildClassWithMissingChildClasses()
-    {
-        $this->expectException(MissingChildClassesException::class);
-        self::assertEquals('LoremIpsum', Reflection::getOneChildClass(C::class));
-    }
-
-    public function testGetOneChildClassWithTooManyChildClasses()
-    {
-        $this->expectException(TooManyChildClassesException::class);
-
-        self::assertEquals(B::class, Reflection::getOneChildClass(A::class));
-        self::assertEquals(C::class, Reflection::getOneChildClass(A::class));
-    }
-
-    public function testGetOneChildClass()
-    {
-        self::assertEquals(C::class, Reflection::getOneChildClass(B::class));
-    }
-
-    public function testGetMethods()
-    {
-        self::assertEquals(0, count(Reflection::getMethods(B::class, true)));
-        self::assertEquals(1, count(Reflection::getMethods(B::class)));
-        self::assertEquals(1, count(Reflection::getMethods(A::class)));
-        self::assertEquals(2, count(Reflection::getMethods(C::class, true)));
-        self::assertEquals(3, count(Reflection::getMethods(C::class)));
-    }
-
-    /**
-     * @param array|object|string $class An array of objects, namespaces, object or namespace
-     * @param array|string        $trait An array of strings or string
-     *
-     * @dataProvider provideInvalidClassAndTrait
-     */
-    public function testUsesTraitInvalidClass($class, $trait)
-    {
-        $this->expectException(CannotResolveClassNameException::class);
-        self::assertNull(Reflection::usesTrait($class, $trait));
-    }
-
-    /**
-     * @param mixed $trait Empty value, e.g. ""
-     * @dataProvider provideEmptyValue
-     */
-    public function testUsesTraitInvalidTrait($trait)
-    {
-        $this->expectException(CannotResolveClassNameException::class);
-        self::assertNull(Reflection::usesTrait(DateTime::class, $trait));
-    }
-
-    public function testUsesTraitExistingClass()
-    {
-        self::assertTrue(Reflection::usesTrait(A::class, E::class));
-        self::assertFalse(Reflection::usesTrait(B::class, E::class));
-        self::assertFalse(Reflection::usesTrait(C::class, E::class));
-        self::assertFalse(Reflection::usesTrait(D::class, E::class));
-    }
-
-    public function testUsesTraitExistingClassAndVerifyParents()
-    {
-        self::assertTrue(Reflection::usesTrait(A::class, E::class, true));
-        self::assertTrue(Reflection::usesTrait(B::class, E::class, true));
-        self::assertTrue(Reflection::usesTrait(C::class, E::class, true));
-        self::assertFalse(Reflection::usesTrait(D::class, E::class, true));
-    }
-
-    /**
-     * Provides invalid class and trait
-     *
-     * @return Generator
-     */
-    public function provideInvalidClassAndTrait()
-    {
-        yield[
-            '',
-            '',
-        ];
-
-        yield[
-            null,
-            null,
-        ];
-
-        yield[
-            0,
-            0,
-        ];
-
-        yield[
-            [],
-            [],
-        ];
-    }
-}

tests/Meritoo/Common/Test/Utilities/RegexTest.php

@@ -1,292 +0,0 @@
-<?php
-
-/**
- * (c) Meritoo.pl, http://www.meritoo.pl
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-namespace Meritoo\Common\Utilities;
-
-use PHPUnit\Framework\TestCase;
-
-/**
- * Tests of the useful regular expressions methods
- *
- * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
- * @copyright Meritoo.pl
- */
-class RegexTest extends TestCase
-{
-    private $simpleText;
-    private $camelCaseText;
-
-    public function testGetCamelCaseParts()
-    {
-        $parts = [];
-        self::assertEquals($parts, Regex::getCamelCaseParts(''));
-
-        $parts = [
-            'lorem',
-        ];
-
-        self::assertEquals($parts, Regex::getCamelCaseParts('lorem'));
-
-        $parts = [
-            'lorem',
-            'Ipsum',
-            'Dolor',
-            'Sit',
-        ];
-
-        self::assertEquals($parts, Regex::getCamelCaseParts($this->camelCaseText));
-
-        $parts = [
-            'Lorem',
-            'Ipsum',
-            'Dolor',
-            'Sit',
-        ];
-
-        $string = ucfirst($this->camelCaseText); // 'LoremIpsumDolorSit'
-        self::assertEquals($parts, Regex::getCamelCaseParts($string));
-    }
-
-    public function testCamelCase2humanReadable()
-    {
-        self::assertEquals('', Regex::camelCase2humanReadable(''));
-        self::assertEquals('lorem', Regex::camelCase2humanReadable('lorem'));
-
-        self::assertEquals($this->simpleText, Regex::camelCase2humanReadable($this->camelCaseText));
-        self::assertEquals(ucfirst($this->simpleText), Regex::camelCase2humanReadable($this->camelCaseText, true));
-    }
-
-    public function testCamelCase2simpleLowercase()
-    {
-        self::assertEquals('', Regex::camelCase2simpleLowercase(''));
-        self::assertEquals('lorem', Regex::camelCase2simpleLowercase('lorem'));
-        self::assertEquals('Lorem', Regex::camelCase2simpleLowercase('Lorem', '', false));
-        self::assertEquals('lorem-ipsum-dolor-sit', Regex::camelCase2simpleLowercase($this->camelCaseText, '-'));
-        self::assertEquals('lorem-Ipsum-Dolor-Sit', Regex::camelCase2simpleLowercase($this->camelCaseText, '-', false));
-    }
-
-    public function testIsValidUrl()
-    {
-        $validUrls = [
-            'http://php.net',
-            'http://php.net/',
-            'http://php.net/docs.php',
-            'http://php.net/get-involved.php',
-            'http://php.net/manual/en/function.preg-match.php',
-            'http://domain.com/BigLetters',
-            'http://domain.com/Another-Big-Letters',
-            'http://domain.com/?a=1&b=c2d',
-            'http://domAin.COM/?a=1&B=c2D',
-            'http://domain.com/index.php?a=1&b=c2d',
-            'http://domain.com/another-page-2.php?a=1&b=c2d',
-            'https://domain.com',
-            'https://domain.com/',
-        ];
-
-        $invalidUrls = [
-            '',
-            null,
-            false,
-            true,
-            0,
-            1,
-            123,
-            '123',
-            'http:',
-            'http://',
-            'http://abc',
-            'ftp://def',
-        ];
-
-        foreach ($validUrls as $url) {
-            self::assertTrue(Regex::isValidUrl($url));
-        }
-
-        foreach ($invalidUrls as $url) {
-            self::assertFalse(Regex::isValidUrl($url));
-        }
-    }
-
-    public function testIsSubPathOf()
-    {
-        self::assertFalse(Regex::isSubPathOf(null, null));
-        self::assertFalse(Regex::isSubPathOf('', ''));
-
-        self::assertFalse(Regex::isSubPathOf('', '/my/directory'));
-        self::assertFalse(Regex::isSubPathOf('/my/file', ''));
-        self::assertFalse(Regex::isSubPathOf('/my/file', '/my/directory'));
-
-        self::assertTrue(Regex::isSubPathOf('/my/directory', '/my/directory'));
-        self::assertTrue(Regex::isSubPathOf('/my/directory/', '/my/directory'));
-        self::assertTrue(Regex::isSubPathOf('/my/directory', '/my/directory/'));
-        self::assertTrue(Regex::isSubPathOf('/my/directory/', '/my/directory/'));
-
-        self::assertTrue(Regex::isSubPathOf('/my/another/directory/another/file', '/my/another/directory'));
-    }
-
-    public function testIsLetterOrDigit()
-    {
-        self::assertTrue(Regex::isLetterOrDigit('a'));
-        self::assertTrue(Regex::isLetterOrDigit(10));
-        self::assertFalse(Regex::isLetterOrDigit(';'));
-    }
-
-    public function testStartsWith()
-    {
-        $string = 'Lorem ipsum dolor sit amet';
-
-        $beginning = 'Lor';
-        self::assertTrue(Regex::startsWith($string, $beginning));
-
-        $beginning = 'L';
-        self::assertTrue(Regex::startsWith($string, $beginning));
-
-        $beginning = 'X';
-        self::assertFalse(Regex::startsWith($string, $beginning));
-
-        $string = '1234567890';
-        $beginning = '1';
-        self::assertTrue(Regex::startsWith($string, $beginning));
-
-        $beginning = ';';
-        self::assertFalse(Regex::startsWith($string, $beginning));
-    }
-
-    public function testStartsWithDirectorySeparator()
-    {
-        /*
-         * Slash as separator
-         */
-        $separatorSlash = '/';
-
-        self::assertTrue(Regex::startsWithDirectorySeparator('/my/extra/directory', $separatorSlash));
-        self::assertFalse(Regex::startsWithDirectorySeparator('my/extra/directory', $separatorSlash));
-
-        /*
-         * Backslash as separator
-         */
-        $separatorBackslash = '\\';
-
-        self::assertTrue(Regex::startsWithDirectorySeparator('\my\extra\directory', $separatorBackslash));
-        self::assertFalse(Regex::startsWithDirectorySeparator('my\extra\directory', $separatorBackslash));
-    }
-
-    public function testEndsWithDirectorySeparator()
-    {
-        /*
-         * Slash as separator
-         */
-        $separatorSlash = '/';
-
-        self::assertTrue(Regex::endsWithDirectorySeparator('my simple text/', $separatorSlash));
-        self::assertFalse(Regex::endsWithDirectorySeparator('my simple text', $separatorSlash));
-
-        /*
-         * Backslash as separator
-         */
-        $separatorBackslash = '\\';
-
-        self::assertTrue(Regex::endsWithDirectorySeparator('my simple text\\', $separatorBackslash));
-        self::assertFalse(Regex::endsWithDirectorySeparator('my simple text', $separatorBackslash));
-    }
-
-    public function testEndsWith()
-    {
-        self::assertFalse(Regex::endsWith($this->simpleText, '\.\.\.'));
-        self::assertFalse(Regex::endsWith($this->simpleText, '\.'));
-        self::assertTrue(Regex::endsWith($this->simpleText, 't'));
-    }
-
-    public function testIsSetUriParameter()
-    {
-        $uri = 'www.domain.com/?name=phil&type=4';
-
-        $parameterName = 'type';
-        self::assertTrue(Regex::isSetUriParameter($uri, $parameterName));
-
-        $parameterName = 'color';
-        self::assertFalse(Regex::isSetUriParameter($uri, $parameterName));
-    }
-
-    public function testContainsEntities()
-    {
-        self::assertFalse(Regex::containsEntities('Lorem ipsum'));
-        self::assertTrue(Regex::containsEntities('Lorem ipsum &raquo;'));
-    }
-
-    public function testContains()
-    {
-        self::assertTrue(Regex::contains($this->simpleText, 'ipsum'));
-        self::assertFalse(Regex::contains($this->simpleText, 'neque'));
-    }
-
-    public function testIsFileName()
-    {
-        $filePath = __FILE__;
-        $directoryPath = dirname($filePath);
-
-        self::assertTrue(Regex::isFileName($filePath));
-        self::assertFalse(Regex::isFileName($directoryPath));
-    }
-
-    public function testIsQuoted()
-    {
-        self::assertTrue(Regex::isQuoted('\'lorem ipsum\''));
-        self::assertTrue(Regex::isQuoted('"lorem ipsum"'));
-
-        self::assertFalse(Regex::isQuoted('lorem ipsum'));
-        self::assertFalse(Regex::isQuoted(new \stdClass()));
-    }
-
-    public function testIsWindowsBasedPath()
-    {
-        self::assertTrue(Regex::isWindowsBasedPath('C:\path\to\directory'));
-        self::assertTrue(Regex::isWindowsBasedPath('C:\path\to\file.jpg'));
-
-        self::assertFalse(Regex::isWindowsBasedPath('/path/to/directory'));
-        self::assertFalse(Regex::isWindowsBasedPath('/path/to/file.jpg'));
-    }
-
-    public function testIsValidNip()
-    {
-        self::assertFalse(Regex::isValidNip(null));
-        self::assertFalse(Regex::isValidNip(''));
-        self::assertFalse(Regex::isValidNip(1234));
-        self::assertFalse(Regex::isValidNip(1234567890));
-        self::assertFalse(Regex::isValidNip(0000000000));
-        self::assertFalse(Regex::isValidNip('1234567890'));
-        self::assertFalse(Regex::isValidNip('0000000000'));
-        self::assertFalse(Regex::isValidNip('abc'));
-        self::assertFalse(Regex::isValidNip($this->simpleText));
-
-        self::assertTrue(Regex::isValidNip('7340009469')); // Onet S.A.
-        self::assertTrue(Regex::isValidNip('5252530705')); // Facebook Poland sp. z o.o.
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    protected function setUp()
-    {
-        parent::setUp();
-
-        $this->simpleText = 'lorem ipsum dolor sit';
-        $this->camelCaseText = str_replace(' ', '', lcfirst(ucwords($this->simpleText))); // 'loremIpsumDolorSit'
-    }
-
-    /**
-     * {@inheritdoc}
-     */
-    protected function tearDown()
-    {
-        parent::tearDown();
-
-        unset($this->simpleText);
-        unset($this->camelCaseText);
-    }
-}

tests/Meritoo/Common/Test/Utilities/UriTest.php

@@ -1,79 +0,0 @@
-<?php
-
-/**
- * (c) Meritoo.pl, http://www.meritoo.pl
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-namespace Meritoo\Common\Test\Utilities;
-
-use Meritoo\Common\Test\Base\BaseTestCase;
-use Meritoo\Common\Utilities\Uri;
-
-/**
- * Tests of the useful uri methods (only static functions)
- *
- * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
- * @copyright Meritoo.pl
- */
-class UriTest extends BaseTestCase
-{
-    public function testAddProtocolToUrl()
-    {
-        $http = 'http';
-        $https = 'https';
-
-        $url = 'my.domain/some/url';
-        $httpUrl = sprintf('%s://%s', $http, $url);
-        $httpsUrl = sprintf('%s://%s', $https, $url);
-
-        self::assertEquals($httpUrl, Uri::addProtocolToUrl($httpUrl));
-        self::assertEquals($httpUrl, Uri::addProtocolToUrl($url));
-
-        self::assertEquals($httpsUrl, Uri::addProtocolToUrl($url, $https));
-        self::assertEquals($httpsUrl, Uri::addProtocolToUrl($httpsUrl, $http));
-    }
-
-    /**
-     * @param mixed $url Empty value, e.g. ""
-     * @dataProvider provideEmptyValue
-     */
-    public function testReplenishProtocolEmptyUrl($url)
-    {
-        self::assertEquals('', Uri::replenishProtocol($url));
-    }
-
-    /**
-     * @param string $expected Expected result
-     * @param string $url      The url to check and replenish
-     * @param string $protocol (optional) The protocol which is replenished. If is empty, protocol of current request
-     *                         is used.
-     *
-     * @dataProvider provideUrlsToReplenishProtocol
-     */
-    public function testReplenishProtocol($expected, $url, $protocol = '')
-    {
-        self::assertSame($expected, Uri::replenishProtocol($url, $protocol));
-    }
-
-    /**
-     * Provides urls to replenish protocol
-     *
-     * @return \Generator
-     */
-    public function provideUrlsToReplenishProtocol()
-    {
-        yield[
-            '://test',
-            'test',
-            '',
-        ];
-
-        yield[
-            'ftp://lorem.ipsum',
-            'lorem.ipsum',
-            'ftp',
-        ];
-    }
-}

tests/Test/Base/BaseTestCaseTest.php

@@ -0,0 +1,176 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Test\Base;
+
+use DateTime;
+use Generator;
+use Meritoo\Common\Test\Base\BaseTestCase;
+use Meritoo\Common\Type\OopVisibilityType;
+use Meritoo\Common\Utilities\GeneratorUtility;
+
+/**
+ * Test case of the base test case with common methods and data providers
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class BaseTestCaseTest extends BaseTestCase
+{
+    public function testConstructor()
+    {
+        static::assertConstructorVisibilityAndArguments(BaseTestCase::class, OopVisibilityType::IS_PUBLIC, 3);
+    }
+
+    public function testProvideEmptyValue()
+    {
+        $elements = [
+            [''],
+            ['   '],
+            [null],
+            [0],
+            [false],
+            [[]],
+        ];
+
+        $generator = (new SimpleTestCase())->provideEmptyValue();
+        self::assertEquals($elements, GeneratorUtility::getGeneratorElements($generator));
+    }
+
+    public function testProvideBooleanValue()
+    {
+        $elements = [
+            [false],
+            [true],
+        ];
+
+        $generator = (new SimpleTestCase())->provideBooleanValue();
+        self::assertEquals($elements, GeneratorUtility::getGeneratorElements($generator));
+    }
+
+    public function testProvideDateTimeInstance()
+    {
+        $dateFormat = 'Y-m-d H:i';
+
+        $expectedElements = [
+            [new DateTime()],
+            [new DateTime('yesterday')],
+            [new DateTime('now')],
+            [new DateTime('tomorrow')],
+        ];
+
+        $generator = (new SimpleTestCase())->provideDateTimeInstance();
+        $generatedElements = GeneratorUtility::getGeneratorElements($generator);
+
+        /* @var DateTime $instance1 */
+        $instance1 = $generatedElements[0][0];
+
+        /* @var DateTime $instance2 */
+        $instance2 = $generatedElements[1][0];
+
+        /* @var DateTime $instance3 */
+        $instance3 = $generatedElements[2][0];
+
+        /* @var DateTime $instance4 */
+        $instance4 = $generatedElements[3][0];
+
+        self::assertCount(count($expectedElements), $generatedElements);
+        self::assertEquals($instance1->format($dateFormat), (new DateTime())->format($dateFormat));
+        self::assertEquals($instance2->format($dateFormat), (new DateTime('yesterday'))->format($dateFormat));
+        self::assertEquals($instance3->format($dateFormat), (new DateTime('now'))->format($dateFormat));
+        self::assertEquals($instance4->format($dateFormat), (new DateTime('tomorrow'))->format($dateFormat));
+    }
+
+    public function testProvideDateTimeRelativeFormat()
+    {
+        $elements = [
+            ['now'],
+            ['yesterday'],
+            ['tomorrow'],
+            ['back of 10'],
+            ['front of 10'],
+            ['last day of February'],
+            ['first day of next month'],
+            ['last day of previous month'],
+            ['last day of next month'],
+            ['Y-m-d'],
+            ['Y-m-d 10:00'],
+        ];
+
+        $generator = (new SimpleTestCase())->provideDateTimeRelativeFormat();
+        self::assertEquals($elements, GeneratorUtility::getGeneratorElements($generator));
+    }
+
+    public function testProvideNotExistingFilePath()
+    {
+        $elements = [
+            ['lets-test.doc'],
+            ['lorem/ipsum.jpg'],
+            ['surprise/me/one/more/time.txt'],
+        ];
+
+        $generator = (new SimpleTestCase())->provideNotExistingFilePath();
+        self::assertEquals($elements, GeneratorUtility::getGeneratorElements($generator));
+    }
+
+    /**
+     * @param string $fileName      Name of file
+     * @param string $directoryPath Path of directory containing the file
+     *
+     * @dataProvider provideFileNameAndDirectoryPath
+     */
+    public function testGetFilePathForTesting($fileName, $directoryPath)
+    {
+        $path = (new SimpleTestCase())->getFilePathForTesting($fileName, $directoryPath);
+
+        if (!empty($directoryPath)) {
+            $directoryPath .= '/';
+        }
+
+        $expectedContains = sprintf('/data/tests/%s%s', $directoryPath, $fileName);
+        static::assertContains($expectedContains, $path);
+    }
+
+    /**
+     * Provides name of file and path of directory containing the file
+     *
+     * @return Generator
+     */
+    public function provideFileNameAndDirectoryPath()
+    {
+        yield[
+            'abc.jpg',
+            '',
+        ];
+
+        yield[
+            'abc.def.jpg',
+            '',
+        ];
+
+        yield[
+            'abc.jpg',
+            'def',
+        ];
+
+        yield[
+            'abc.def.jpg',
+            'def',
+        ];
+    }
+}
+
+/**
+ * Simple test case
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class SimpleTestCase extends BaseTestCase
+{
+}

tests/Type/Base/BaseTypeTest.php

@@ -9,17 +9,22 @@
 namespace Meritoo\Common\Test\Type\Base;
 
 use Generator;
+use Meritoo\Common\Test\Base\BaseTestCase;
 use Meritoo\Common\Type\Base\BaseType;
-use PHPUnit\Framework\TestCase;
 
 /**
- * Tests of the base / abstract type of something
+ * Test case of the base / abstract type of something
  *
  * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
  * @copyright Meritoo.pl
  */
-class BaseTypeTest extends TestCase
+class BaseTypeTest extends BaseTestCase
 {
+    public function testConstructor()
+    {
+        static::assertHasNoConstructor(BaseType::class);
+    }
+
     /**
      * @param BaseType $type          Type of something
      * @param array    $expectedTypes Expected concrete types of given instance of type

tests/Type/DatePartTypeTest.php

@@ -12,7 +12,7 @@ use Meritoo\Common\Test\Base\BaseTypeTestCase;
 use Meritoo\Common\Type\DatePartType;
 
 /**
- * Tests of the type of date part, e.g. "year"
+ * Test case of the type of date part, e.g. "year"
  *
  * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
  * @copyright Meritoo.pl

tests/Type/DatePeriodTest.php

@@ -6,25 +6,25 @@
  * file that was distributed with this source code.
  */
 
-namespace Meritoo\Common\Test\Utilities;
+namespace Meritoo\Common\Test\Type;
 
 use DateTime;
 use Generator;
-use Meritoo\Common\Test\Base\BaseTestCase;
+use Meritoo\Common\Test\Base\BaseTypeTestCase;
+use Meritoo\Common\Type\DatePeriod;
 use Meritoo\Common\Type\OopVisibilityType;
-use Meritoo\Common\Utilities\DatePeriod;
 
 /**
- * Tests of date's period
+ * Test case of date's period
  *
  * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
  * @copyright Meritoo.pl
  */
-class DatePeriodTest extends BaseTestCase
+class DatePeriodTest extends BaseTypeTestCase
 {
     public function testConstructorVisibilityAndArguments()
     {
-        $this->verifyConstructorVisibilityAndArguments(DatePeriod::class, OopVisibilityType::IS_PUBLIC, 2, 0);
+        static::assertConstructorVisibilityAndArguments(DatePeriod::class, OopVisibilityType::IS_PUBLIC, 2, 0);
     }
 
     /**
@@ -58,33 +58,6 @@ class DatePeriodTest extends BaseTestCase
         self::assertEquals($endDate, $period->getEndDate());
     }
 
-    /**
-     * @param mixed $period Empty value, e.g. ""
-     * @dataProvider provideEmptyValue
-     */
-    public function testIsCorrectPeriodEmptyPeriod($period)
-    {
-        self::assertFalse(DatePeriod::isCorrectPeriod($period));
-    }
-
-    /**
-     * @param int $period Incorrect period to verify
-     * @dataProvider provideIncorrectPeriod
-     */
-    public function testIsCorrectPeriodIncorrectPeriod($period)
-    {
-        self::assertFalse(DatePeriod::isCorrectPeriod($period));
-    }
-
-    /**
-     * @param int $period The period to verify
-     * @dataProvider providePeriod
-     */
-    public function testIsCorrectPeriod($period)
-    {
-        self::assertTrue(DatePeriod::isCorrectPeriod($period));
-    }
-
     /**
      * @param DatePeriod $period The date period to verify
      * @param string     $format Format used to format the date
@@ -142,36 +115,6 @@ class DatePeriodTest extends BaseTestCase
         ];
     }
 
-    /**
-     * Provides incorrect period
-     *
-     * @return Generator
-     */
-    public function provideIncorrectPeriod()
-    {
-        yield[-1];
-        yield[0];
-        yield[10];
-    }
-
-    /**
-     * Provides period to verify
-     *
-     * @return Generator
-     */
-    public function providePeriod()
-    {
-        yield[DatePeriod::LAST_WEEK];
-        yield[DatePeriod::THIS_WEEK];
-        yield[DatePeriod::NEXT_WEEK];
-        yield[DatePeriod::LAST_MONTH];
-        yield[DatePeriod::THIS_MONTH];
-        yield[DatePeriod::NEXT_MONTH];
-        yield[DatePeriod::LAST_YEAR];
-        yield[DatePeriod::THIS_YEAR];
-        yield[DatePeriod::NEXT_YEAR];
-    }
-
     /**
      * Provides period and incorrect format of date to verify
      *
@@ -270,4 +213,68 @@ class DatePeriodTest extends BaseTestCase
             '2002-02-02 00:00',
         ];
     }
+
+    /**
+     * Returns all expected types of the tested type
+     *
+     * @return array
+     */
+    protected function getAllExpectedTypes()
+    {
+        return [
+            'LAST_MONTH' => DatePeriod::LAST_MONTH,
+            'LAST_WEEK'  => DatePeriod::LAST_WEEK,
+            'LAST_YEAR'  => DatePeriod::LAST_YEAR,
+            'NEXT_MONTH' => DatePeriod::NEXT_MONTH,
+            'NEXT_WEEK'  => DatePeriod::NEXT_WEEK,
+            'NEXT_YEAR'  => DatePeriod::NEXT_YEAR,
+            'THIS_MONTH' => DatePeriod::THIS_MONTH,
+            'THIS_WEEK'  => DatePeriod::THIS_WEEK,
+            'THIS_YEAR'  => DatePeriod::THIS_YEAR,
+        ];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function getTestedTypeInstance()
+    {
+        return new DatePeriod();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function provideTypeToVerify()
+    {
+        yield[
+            '',
+            false,
+        ];
+
+        yield[
+            -1,
+            false,
+        ];
+
+        yield[
+            true,
+            false,
+        ];
+
+        yield[
+            DatePeriod::LAST_MONTH,
+            true,
+        ];
+
+        yield[
+            DatePeriod::NEXT_WEEK,
+            true,
+        ];
+
+        yield[
+            DatePeriod::THIS_YEAR,
+            true,
+        ];
+    }
 }

tests/Utilities/ArraysTest.php

@@ -8,16 +8,16 @@
 
 namespace Meritoo\Common\Test\Utilities;
 
+use Meritoo\Common\Test\Base\BaseTestCase;
 use Meritoo\Common\Utilities\Arrays;
-use PHPUnit\Framework\TestCase;
 
 /**
- * Tests of the useful arrays methods
+ * Test case of the useful arrays methods
  *
  * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
  * @copyright Meritoo.pl
  */
-class ArraysTest extends TestCase
+class ArraysTest extends BaseTestCase
 {
     private $simpleArray;
     private $simpleArrayWithKeys;
@@ -25,6 +25,11 @@ class ArraysTest extends TestCase
     private $complexArray;
     private $superComplexArray;
 
+    public function testConstructor()
+    {
+        static::assertHasNoConstructor(Arrays::class);
+    }
+
     public function testValues2string()
     {
         /*

tests/Utilities/BundleTest.php

@@ -0,0 +1,253 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Utilities;
+
+use Generator;
+use Meritoo\Common\Exception\Bundle\IncorrectBundleNameException;
+use Meritoo\Common\Test\Base\BaseTestCase;
+use Meritoo\Common\Utilities\Bundle;
+
+/**
+ * Test case of the useful methods for bundle
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class BundleTest extends BaseTestCase
+{
+    public function testConstructor()
+    {
+        static::assertHasNoConstructor(Bundle::class);
+    }
+
+    /**
+     * @param string $viewPath   Path of the view / template, e.g. "MyDirectory/my-template"
+     * @param string $bundleName Full name of the bundle, e.g. "MyExtraBundle"
+     *
+     * @throws IncorrectBundleNameException
+     * @dataProvider provideEmptyViewPathAndBundle
+     */
+    public function testGetBundleViewPathUsingEmptyPathAndBundle($viewPath, $bundleName)
+    {
+        self::assertNull(Bundle::getBundleViewPath($viewPath, $bundleName));
+    }
+
+    /**
+     * @param string $viewPath   Path of the view / template, e.g. "MyDirectory/my-template"
+     * @param string $bundleName Full name of the bundle, e.g. "MyExtraBundle"
+     *
+     * @throws IncorrectBundleNameException
+     * @dataProvider provideViewPathAndIncorrectBundleName
+     */
+    public function testGetBundleViewPathUsingIncorrectBundleName($viewPath, $bundleName)
+    {
+        $template = 'Name of bundle \'%s\' is incorrect. It should start with big letter and end with "Bundle". Is'
+            . ' there everything ok?';
+
+        $message = sprintf($template, $bundleName);
+        $this->setExpectedException(IncorrectBundleNameException::class, $message);
+
+        Bundle::getBundleViewPath($viewPath, $bundleName);
+    }
+
+    /**
+     * @param string $viewPath   Path of the view / template, e.g. "MyDirectory/my-template"
+     * @param string $bundleName Full name of the bundle, e.g. "MyExtraBundle"
+     * @param string $expected   Expected path to view / template
+     *
+     * @throws IncorrectBundleNameException
+     * @dataProvider provideViewPathAndBundle
+     */
+    public function testGetBundleViewPathUsingDefaultExtension($viewPath, $bundleName, $expected)
+    {
+        self::assertEquals($expected, Bundle::getBundleViewPath($viewPath, $bundleName));
+    }
+
+    /**
+     * @param string $viewPath   Path of the view / template, e.g. "MyDirectory/my-template"
+     * @param string $bundleName Full name of the bundle, e.g. "MyExtraBundle"
+     * @param string $extension  (optional) Extension of the view / template
+     * @param string $expected   Expected path to view / template
+     *
+     * @throws IncorrectBundleNameException
+     * @dataProvider provideViewPathAndBundleAndExtension
+     */
+    public function testGetBundleViewPathUsingCustomExtension($viewPath, $bundleName, $extension, $expected)
+    {
+        self::assertEquals($expected, Bundle::getBundleViewPath($viewPath, $bundleName, $extension));
+    }
+
+    /**
+     * @param mixed $emptyValue Empty value, e.g. ""
+     *
+     * @throws IncorrectBundleNameException
+     * @dataProvider provideEmptyValue
+     */
+    public function testGetShortBundleNameUsingEmptyValue($emptyValue)
+    {
+        $this->setExpectedException(IncorrectBundleNameException::class);
+        Bundle::getShortBundleName($emptyValue);
+    }
+
+    /**
+     * @param string $bundleName Full name of the bundle, e.g. "MyExtraBundle"
+     *
+     * @throws IncorrectBundleNameException
+     * @dataProvider provideIncorrectBundleName
+     */
+    public function testGetShortBundleNameUsingIncorrectBundleName($bundleName)
+    {
+        $this->setExpectedException(IncorrectBundleNameException::class);
+        Bundle::getShortBundleName($bundleName);
+    }
+
+    /**
+     * @param string $fullBundleName  Full name of the bundle, e.g. "MyExtraBundle"
+     * @param string $shortBundleName Short name of bundle (without "Bundle")
+     *
+     * @throws IncorrectBundleNameException
+     * @dataProvider provideFullAndShortBundleName
+     */
+    public function testGetShortBundleName($fullBundleName, $shortBundleName)
+    {
+        self::assertEquals($shortBundleName, Bundle::getShortBundleName($fullBundleName));
+    }
+
+    /**
+     * Provides empty path of the view / template and/or name of bundle
+     *
+     * @return Generator
+     */
+    public function provideEmptyViewPathAndBundle()
+    {
+        yield[
+            '',
+            '',
+        ];
+
+        yield[
+            'test',
+            '',
+        ];
+
+        yield[
+            '',
+            'test',
+        ];
+    }
+
+    /**
+     * Provides path of the view / template and incorrect name of bundle
+     *
+     * @return Generator
+     */
+    public function provideViewPathAndIncorrectBundleName()
+    {
+        yield[
+            'User:Active',
+            'myExtra',
+        ];
+
+        yield[
+            'User:Active',
+            'MyExtra',
+        ];
+
+        yield[
+            'User:Active',
+            'MySuperExtraGorgeous',
+        ];
+    }
+
+    /**
+     * Provides path of the view / template and name of bundle
+     *
+     * @return Generator
+     */
+    public function provideViewPathAndBundle()
+    {
+        yield[
+            'User',
+            'MyExtraBundle',
+            '@MyExtra/User.html.twig',
+        ];
+
+        yield[
+            'User:Active',
+            'MyExtraBundle',
+            '@MyExtra/User/Active.html.twig',
+        ];
+
+        yield[
+            'User:Active',
+            'MySuperExtraGorgeousBundle',
+            '@MySuperExtraGorgeous/User/Active.html.twig',
+        ];
+    }
+
+    /**
+     * Provides path of the view / template, name of bundle and extension of the view / template
+     *
+     * @return Generator
+     */
+    public function provideViewPathAndBundleAndExtension()
+    {
+        yield[
+            'User:Active',
+            'MyExtraBundle',
+            '',
+            null,
+        ];
+
+        yield[
+            'User:Active',
+            'MyExtraBundle',
+            'js.twig',
+            '@MyExtra/User/Active.js.twig',
+        ];
+    }
+
+    /**
+     * Provides incorrect name of bundle
+     *
+     * @return Generator
+     */
+    public function provideIncorrectBundleName()
+    {
+        yield[
+            'myExtra',
+        ];
+
+        yield[
+            'MyExtra',
+        ];
+
+        yield[
+            'MySuperExtraGorgeous',
+        ];
+    }
+
+    /**
+     * Provides full and short name of bundle
+     *
+     * @return Generator
+     */
+    public function provideFullAndShortBundleName()
+    {
+        yield[
+            'MyExtraBundle',
+            'MyExtra',
+        ];
+
+        yield[
+            'MySuperExtraGorgeousBundle',
+            'MySuperExtraGorgeous',
+        ];
+    }
+}

tests/Utilities/ComposerTest.php

@@ -13,7 +13,7 @@ use Meritoo\Common\Test\Base\BaseTestCase;
 use Meritoo\Common\Utilities\Composer;
 
 /**
- * Tests of the useful Composer-related methods
+ * Test case of the useful Composer-related methods
  *
  * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
  * @copyright Meritoo.pl
@@ -27,6 +27,11 @@ class ComposerTest extends BaseTestCase
      */
     private $composerJsonPath;
 
+    public function testConstructor()
+    {
+        static::assertHasNoConstructor(Composer::class);
+    }
+
     /**
      * @param string $composerJsonPath Empty value, e.g. ""
      * @dataProvider provideEmptyValue
@@ -83,6 +88,6 @@ class ComposerTest extends BaseTestCase
     {
         parent::setUp();
 
-        $this->composerJsonPath = $this->getFilePathToTests(Composer::FILE_NAME_MAIN);
+        $this->composerJsonPath = $this->getFilePathForTesting(Composer::FILE_NAME_MAIN);
     }
 }

tests/Utilities/DateTest.php

@@ -13,16 +13,22 @@ use DateTime;
 use Generator;
 use Meritoo\Common\Exception\Date\UnknownDatePartTypeException;
 use Meritoo\Common\Test\Base\BaseTestCase;
+use Meritoo\Common\Type\DatePeriod;
 use Meritoo\Common\Utilities\Date;
 
 /**
- * Tests of the Date methods (only static functions)
+ * Test case of the Date methods (only static functions)
  *
  * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
  * @copyright Meritoo.pl
  */
 class DateTest extends BaseTestCase
 {
+    public function testConstructor()
+    {
+        static::assertHasNoConstructor(Date::class);
+    }
+
     /**
      * @param mixed $value Empty value, e.g. ""
      * @dataProvider provideEmptyValue
@@ -218,7 +224,7 @@ class DateTest extends BaseTestCase
      */
     public function testGetDayOfWeekIncorrectValues($year, $month, $day)
     {
-        $this->expectException(UnknownDatePartTypeException::class);
+        $this->setExpectedException(UnknownDatePartTypeException::class);
         self::assertEmpty(Date::getDayOfWeek($year, $month, $day));
     }
 
@@ -501,6 +507,35 @@ class DateTest extends BaseTestCase
         self::assertTrue($randomDate >= $intervalMinDate && $randomDate <= $intervalMaxDate);
     }
 
+    /**
+     * @param mixed $period Empty value, e.g. ""
+     * @dataProvider provideEmptyValue
+     */
+    public function testGetDatesForPeriodUsingEmptyPeriod($period)
+    {
+        self::assertNull(Date::getDatesForPeriod($period));
+    }
+
+    /**
+     * @param int $period Incorrect period to verify
+     * @dataProvider provideIncorrectPeriod
+     */
+    public function testGetDatesForPeriodUsingIncorrectPeriod($period)
+    {
+        self::assertNull(Date::getDatesForPeriod($period));
+    }
+
+    /**
+     * @param int        $period   The period, type of period. One of DatePeriod class constants, e.g. DatePeriod::LAST_WEEK.
+     * @param DatePeriod $expected Expected start and end date for given period
+     *
+     * @dataProvider provideCorrectPeriod
+     */
+    public function testGetDatesForPeriod($period, DatePeriod $expected)
+    {
+        self::assertEquals($expected, Date::getDatesForPeriod($period));
+    }
+
     /**
      * Provides incorrect invalidCount of DateTime
      *
@@ -753,4 +788,112 @@ class DateTest extends BaseTestCase
             50,
         ];
     }
+
+    /**
+     * Provides incorrect period
+     *
+     * @return Generator
+     */
+    public function provideIncorrectPeriod()
+    {
+        yield[-1];
+        yield[0];
+        yield[10];
+    }
+
+    /**
+     * Provides correct period
+     *
+     * @return Generator
+     */
+    public function provideCorrectPeriod()
+    {
+        yield[
+            DatePeriod::LAST_WEEK,
+            new DatePeriod(
+                (new DateTime('this week'))->sub(new DateInterval('P7D'))->setTime(0, 0, 0),
+                (new DateTime('this week'))->sub(new DateInterval('P1D'))->setTime(23, 59, 59)
+            ),
+        ];
+
+        yield[
+            DatePeriod::THIS_WEEK,
+            new DatePeriod(
+                (new DateTime('this week'))->setTime(0, 0, 0),
+                (new DateTime('this week'))->add(new DateInterval('P6D'))->setTime(23, 59, 59)
+            ),
+        ];
+
+        yield[
+            DatePeriod::NEXT_WEEK,
+            new DatePeriod(
+                (new DateTime('this week'))->add(new DateInterval('P7D'))->setTime(0, 0, 0),
+                (new DateTime('this week'))->add(new DateInterval('P7D'))->add(new DateInterval('P6D'))->setTime(23, 59, 59)
+            ),
+        ];
+
+        yield[
+            DatePeriod::LAST_MONTH,
+            new DatePeriod(
+                (new DateTime('first day of last month'))->setTime(0, 0, 0),
+                (new DateTime('last day of last month'))->setTime(23, 59, 59)
+            ),
+        ];
+
+        yield[
+            DatePeriod::THIS_MONTH,
+            new DatePeriod(
+                Date::getDatesForPeriod(DatePeriod::LAST_MONTH)
+                    ->getEndDate()
+                    ->add(new DateInterval('P1D'))
+                    ->setTime(0, 0, 0),
+                Date::getDatesForPeriod(DatePeriod::NEXT_MONTH)
+                    ->getStartDate()
+                    ->sub(new DateInterval('P1D'))
+                    ->setTime(23, 59, 59)
+            ),
+        ];
+
+        yield[
+            DatePeriod::NEXT_MONTH,
+            new DatePeriod(
+                (new DateTime('first day of next month'))->setTime(0, 0, 0),
+                (new DateTime('last day of next month'))->setTime(23, 59, 59)
+            ),
+        ];
+
+        $lastYearStart = (new DateTime())->modify('-1 year');
+        $lastYearEnd = (new DateTime())->modify('-1 year');
+        $year = $lastYearStart->format('Y');
+
+        yield[
+            DatePeriod::LAST_YEAR,
+            new DatePeriod(
+                $lastYearStart->setDate($year, 1, 1)->setTime(0, 0, 0),
+                $lastYearEnd->setDate($year, 12, 31)->setTime(23, 59, 59)
+            ),
+        ];
+
+        $year = (new DateTime())->format('Y');
+
+        yield[
+            DatePeriod::THIS_YEAR,
+            new DatePeriod(
+                (new DateTime())->setDate($year, 1, 1)->setTime(0, 0, 0),
+                (new DateTime())->setDate($year, 12, 31)->setTime(23, 59, 59)
+            ),
+        ];
+
+        $nextYearStart = (new DateTime())->modify('1 year');
+        $nextYearEnd = (new DateTime())->modify('1 year');
+        $year = $nextYearStart->format('Y');
+
+        yield[
+            DatePeriod::NEXT_YEAR,
+            new DatePeriod(
+                $nextYearStart->setDate($year, 1, 1)->setTime(0, 0, 0),
+                $nextYearEnd->setDate($year, 12, 31)->setTime(23, 59, 59)
+            ),
+        ];
+    }
 }

tests/Utilities/GeneratorUtilityTest.php

@@ -12,13 +12,18 @@ use Meritoo\Common\Test\Base\BaseTestCase;
 use Meritoo\Common\Utilities\GeneratorUtility;
 
 /**
- * Tests of the useful methods for the Generator class
+ * Test case of the useful methods for the Generator class
  *
  * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
  * @copyright Meritoo.pl
  */
 class GeneratorUtilityTest extends BaseTestCase
 {
+    public function testConstructor()
+    {
+        static::assertHasNoConstructor(GeneratorUtility::class);
+    }
+
     public function testGetGeneratorElements()
     {
         /*

tests/Utilities/LocaleTest.php

@@ -0,0 +1,224 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Utilities;
+
+use Generator;
+use Meritoo\Common\Test\Base\BaseTestCase;
+use Meritoo\Common\Utilities\Locale;
+use ReflectionException;
+
+/**
+ * Test case of the useful locale methods
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class LocaleTest extends BaseTestCase
+{
+    /**
+     * @throws ReflectionException
+     */
+    public function testConstructor()
+    {
+        static::assertHasNoConstructor(Locale::class);
+    }
+
+    /**
+     * @param mixed $languageCode Empty value, e.g. ""
+     * @dataProvider provideEmptyValue
+     */
+    public function testGetLongFormEmptyLanguageCode($languageCode)
+    {
+        self::assertEquals('', Locale::getLongForm($languageCode));
+    }
+
+    /**
+     * @param string $languageCode Language code, in ISO 639-1 format. Short form of the locale, e.g. "fr".
+     * @param string $countryCode  Country code, in ISO 3166-1 alpha-2 format, e.g. "FR"
+     * @param string $encoding     Encoding of the final locale
+     * @param string $expected     Expected long form of the locale
+     *
+     * @dataProvider provideLanguageEncodingAndCountryCode
+     */
+    public function testGetLongForm($languageCode, $countryCode, $encoding, $expected)
+    {
+        self::assertEquals($expected, Locale::getLongForm($languageCode, $countryCode, $encoding));
+    }
+
+    /**
+     * @param mixed $emptyValue Empty value, e.g. ""
+     * @dataProvider provideEmptyValue
+     */
+    public function testSetLocaleEmptyCategoryAndLanguageCode($emptyValue)
+    {
+        self::assertFalse(Locale::setLocale($emptyValue, $emptyValue));
+    }
+
+    public function testSetLocaleIncorrectCategory()
+    {
+        self::assertFalse(Locale::setLocale(-1, 'en'));
+    }
+
+    /**
+     * @param int    $category       Named constant specifying the category of the functions affected by the locale
+     *                               setting. It's the same constant as required by setlocale() function.
+     * @param string $languageCode   Language code, in ISO 639-1 format. Short form of the locale, e.g. "fr".
+     * @param string $countryCode    Country code, in ISO 3166-1 alpha-2 format, e.g. "FR"
+     * @param string $expectedLocale Expected locale
+     *
+     * @dataProvider provideCategoryLanguageCodeAndExpectedLocale
+     */
+    public function testSetLocale($category, $languageCode, $countryCode, $expectedLocale)
+    {
+        self::assertEquals($expectedLocale, Locale::setLocale($category, $languageCode, $countryCode));
+    }
+
+    /**
+     * @param int    $category       Named constant specifying the category of the functions affected by the locale setting.
+     *                               It's the same constant as required by setlocale() function.
+     * @param string $languageCode   Language code, in ISO 639-1 format. Short form of the locale, e.g. "fr".
+     * @param string $countryCode    Country code, in ISO 3166-1 alpha-2 format, e.g. "FR"
+     * @param string $expectedLocale Expected locale
+     *
+     * @dataProvider provideCategoryLanguageCodeAndExpectedLocale
+     */
+    public function testGetLocale($category, $languageCode, $countryCode, $expectedLocale)
+    {
+        Locale::setLocale($category, $languageCode, $countryCode);
+        self::assertEquals($expectedLocale, Locale::getLocale($category));
+    }
+
+    /**
+     * Provides language, encoding and country code
+     *
+     * @return Generator
+     */
+    public function provideLanguageEncodingAndCountryCode()
+    {
+        yield[
+            'fr',
+            '',
+            '',
+            'fr_FR',
+        ];
+
+        yield[
+            'fr',
+            '',
+            'UTF-8',
+            'fr_FR.UTF-8',
+        ];
+
+        yield[
+            'fr',
+            'FR',
+            '',
+            'fr_FR',
+        ];
+
+        yield[
+            'fr',
+            'FR',
+            'UTF-8',
+            'fr_FR.UTF-8',
+        ];
+
+        yield[
+            'en',
+            'US',
+            '',
+            'en_US',
+        ];
+
+        yield[
+            'en',
+            'US',
+            'UTF-8',
+            'en_US.UTF-8',
+        ];
+
+        yield[
+            'en',
+            'US',
+            'ISO-8859-1',
+            'en_US.ISO-8859-1',
+        ];
+    }
+
+    /**
+     * Provides category
+     *
+     * @return Generator
+     */
+    public function provideCategoryLanguageCodeAndExpectedLocale()
+    {
+        yield[
+            LC_ALL,
+            'fr',
+            '',
+            'fr_FR.UTF-8',
+        ];
+
+        yield[
+            LC_COLLATE,
+            'fr',
+            'FR',
+            'fr_FR.UTF-8',
+        ];
+
+        yield[
+            LC_CTYPE,
+            'en',
+            'US',
+            'en_US.UTF-8',
+        ];
+
+        yield[
+            LC_NUMERIC,
+            'en',
+            'GB',
+            'en_GB.UTF-8',
+        ];
+
+        yield[
+            LC_MONETARY,
+            'es',
+            '',
+            'es_ES.UTF-8',
+        ];
+
+        yield[
+            LC_MONETARY,
+            'es',
+            'ES',
+            'es_ES.UTF-8',
+        ];
+
+        yield[
+            LC_TIME,
+            'it',
+            '',
+            'it_IT.UTF-8',
+        ];
+
+        yield[
+            LC_TIME,
+            'it',
+            'IT',
+            'it_IT.UTF-8',
+        ];
+
+        yield[
+            LC_TIME,
+            'it',
+            'it',
+            'it_IT.UTF-8',
+        ];
+    }
+}

tests/Utilities/MimeTypesTest.php

@@ -13,13 +13,18 @@ use Meritoo\Common\Test\Base\BaseTestCase;
 use Meritoo\Common\Utilities\MimeTypes;
 
 /**
- * Tests of the useful methods for mime types of files
+ * Test case of the useful methods for mime types of files
  *
  * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
  * @copyright Meritoo.pl
  */
 class MimeTypesTest extends BaseTestCase
 {
+    public function testConstructor()
+    {
+        static::assertHasNoConstructor(MimeTypes::class);
+    }
+
     /**
      * @param mixed $mimeType Empty value, e.g. ""
      * @dataProvider provideEmptyValue
@@ -442,12 +447,12 @@ class MimeTypesTest extends BaseTestCase
     public function provideFilePathToGetMimeTypeOfRealFile()
     {
         yield[
-            $this->getFilePathToTests('minion.jpg'),
+            $this->getFilePathForTesting('minion.jpg'),
             'image/jpeg',
         ];
 
         yield[
-            $this->getFilePathToTests('lorem-ipsum.txt'),
+            $this->getFilePathForTesting('lorem-ipsum.txt'),
             'text/plain',
         ];
     }
@@ -460,12 +465,12 @@ class MimeTypesTest extends BaseTestCase
     public function provideExistingFilePathToCheckIsImagePath()
     {
         yield[
-            $this->getFilePathToTests('minion.jpg'),
+            $this->getFilePathForTesting('minion.jpg'),
             true,
         ];
 
         yield[
-            $this->getFilePathToTests('lorem-ipsum.txt'),
+            $this->getFilePathForTesting('lorem-ipsum.txt'),
             false,
         ];
     }

tests/Utilities/MiscellaneousTest.php

@@ -14,10 +14,11 @@ use Meritoo\Common\Exception\Regex\InvalidColorHexValueException;
 use Meritoo\Common\Test\Base\BaseTestCase;
 use Meritoo\Common\Utilities\Locale;
 use Meritoo\Common\Utilities\Miscellaneous;
+use ReflectionException;
 use stdClass;
 
 /**
- * Tests of the Miscellaneous methods (only static functions)
+ * Test case of the Miscellaneous methods (only static functions)
  *
  * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
  * @copyright Meritoo.pl
@@ -27,6 +28,15 @@ class MiscellaneousTest extends BaseTestCase
     private $stringSmall;
     private $stringCommaSeparated;
     private $stringDotSeparated;
+    private $stringWithoutSpaces;
+
+    /**
+     * @throws ReflectionException
+     */
+    public function testConstructor()
+    {
+        static::assertHasNoConstructor(Miscellaneous::class);
+    }
 
     public function testGetDirectoryContent()
     {
@@ -154,8 +164,8 @@ class MiscellaneousTest extends BaseTestCase
         $expected = "int(123)\n";
 
         if ($xdebugLoaded) {
-            $libraryPath = realpath(sprintf('%s%s', dirname(__FILE__), '/../../../../..'));
+            $libraryPath = realpath(sprintf('%s%s', dirname(__FILE__), '/../..'));
-            $filePath = sprintf('%s%s', $libraryPath, '/src/Meritoo/Common/Utilities/Miscellaneous.php:');
+            $filePath = sprintf('%s%s', $libraryPath, '/src/Utilities/Miscellaneous.php:');
 
             /*
              * Attention. I have to use "\d+" at the end of $filePath, because number of line may be different if new
@@ -356,37 +366,36 @@ class MiscellaneousTest extends BaseTestCase
     {
         self::assertEquals('Lorem ipsum dolor sit<br>amet, consectetur<br>adipiscing<br>elit', Miscellaneous::breakLongText($this->stringCommaSeparated, 20));
         self::assertEquals('Lorem ipsum dolor sit---amet, consectetur---adipiscing---elit', Miscellaneous::breakLongText($this->stringCommaSeparated, 20, '---'));
+        self::assertEquals('LoremIpsum<br>DolorSitAm<br>etConsecte<br>turAdipisc<br>ingElit', Miscellaneous::breakLongText($this->stringWithoutSpaces, 10));
     }
 
-    public function testRemoveDirectory()
+    public function testRemoveDirectoryUsingNotExistingDirectory()
     {
-        /*
+        self::assertNull(Miscellaneous::removeDirectory('/abc/def/ghi'));
-         * Removing not existing directory
+    }
-         */
-        self::assertTrue(Miscellaneous::removeDirectory('/abc/def/ghi'));
 
-        /*
+    public function testRemoveDirectoryUsingNoDirectory()
-         * Removing not directory
+    {
-         */
         $directoryPath = sys_get_temp_dir() . '/ipsum.txt';
         touch($directoryPath);
         self::assertTrue(Miscellaneous::removeDirectory($directoryPath));
+    }
 
-        /*
+    public function testRemoveDirectoryUsingSimpleDirectory()
-         * Removing simple directory
+    {
-         */
         $directoryPath = sys_get_temp_dir() . '/lorem/ipsum';
         mkdir($directoryPath, 0777, true);
         self::assertTrue(Miscellaneous::removeDirectory($directoryPath));
+    }
 
-        /*
+    public function testRemoveDirectoryUsingComplexDirectory()
-         * Removing more complex directory
+    {
-         */
         $directory1Path = sys_get_temp_dir() . '/lorem/ipsum';
         $directory2Path = sys_get_temp_dir() . '/lorem/dolor/sit';
 
         mkdir($directory1Path, 0777, true);
         mkdir($directory2Path, 0777, true);
+
         self::assertTrue(Miscellaneous::removeDirectory(sys_get_temp_dir() . '/lorem', false));
     }
 
@@ -503,16 +512,35 @@ class MiscellaneousTest extends BaseTestCase
         self::assertEquals('lorem ipsum', Miscellaneous::trimSmart(' lorem ipsum     '));
     }
 
-    public function testConcatenatePaths()
+    /**
+     * @param mixed $emptyPaths Empty paths co concatenate
+     * @dataProvider provideEmptyValue
+     */
+    public function testConcatenatePathsWithEmptyPaths($emptyPaths)
+    {
+        self::assertEquals('', Miscellaneous::concatenatePaths($emptyPaths));
+    }
+
+    public function testConcatenatePathsWithOneEmptyPath()
+    {
+        $paths = [
+            'first/directory',
+            'second/one',
+            '',
+            'and/the/third',
+        ];
+
+        $concatenated = Miscellaneous::concatenatePaths($paths);
+        unset($paths[2]);
+        $imploded = implode('/', $paths);
+
+        self::assertEquals('/' . $imploded, $concatenated);
+    }
+
+    public function testConcatenatePathsInNixOs()
     {
         /*
-         * Common cases
+         * For *nix operating system
-         */
-        self::assertEquals('', Miscellaneous::concatenatePaths(null));
-        self::assertEquals('', Miscellaneous::concatenatePaths([]));
-
-        /*
-         * *nix operating system
          */
         $paths1 = [
             'first/directory',
@@ -522,7 +550,10 @@ class MiscellaneousTest extends BaseTestCase
 
         self::assertEquals('/' . implode('/', $paths1), Miscellaneous::concatenatePaths($paths1));
         self::assertEquals('/' . implode('/', $paths1), Miscellaneous::concatenatePaths($paths1[0], $paths1[1], $paths1[2]));
+    }
 
+    public function testConcatenatePathsInWindowsOs()
+    {
         /*
          * For Windows operating system
          */
@@ -634,9 +665,14 @@ class MiscellaneousTest extends BaseTestCase
         self::assertEquals(255, Miscellaneous::getValidColorComponent(255, false));
     }
 
+    /**
+     * @throws IncorrectColorHexLengthException
+     * @throws InvalidColorHexValueException
+     */
     public function testGetInvertedColorWithIncorrectLength()
     {
-        $this->expectException(IncorrectColorHexLengthException::class);
+        $this->setExpectedException(IncorrectColorHexLengthException::class);
+
         Miscellaneous::getInvertedColor(null);
         Miscellaneous::getInvertedColor('');
         Miscellaneous::getInvertedColor(1);
@@ -647,9 +683,14 @@ class MiscellaneousTest extends BaseTestCase
         Miscellaneous::getInvertedColor('1234567');
     }
 
+    /**
+     * @throws IncorrectColorHexLengthException
+     * @throws InvalidColorHexValueException
+     */
     public function testGetInvertedColorWithInvalidValue()
     {
-        $this->expectException(InvalidColorHexValueException::class);
+        $this->setExpectedException(InvalidColorHexValueException::class);
+
         Miscellaneous::getInvertedColor('0011zz');
         Miscellaneous::getInvertedColor('001#zz');
         Miscellaneous::getInvertedColor('001!zz');
@@ -657,6 +698,10 @@ class MiscellaneousTest extends BaseTestCase
         Miscellaneous::getInvertedColor('00ppqq');
     }
 
+    /**
+     * @throws IncorrectColorHexLengthException
+     * @throws InvalidColorHexValueException
+     */
     public function testGetInvertedColor()
     {
         /*
@@ -720,6 +765,11 @@ class MiscellaneousTest extends BaseTestCase
         self::assertSame($expected, Miscellaneous::fillMissingZeros($number, $length, $before));
     }
 
+    public function testGetProjectRootPath()
+    {
+        self::assertNotEmpty(Miscellaneous::getProjectRootPath());
+    }
+
     /**
      * Provides string to convert characters to latin characters and not lower cased and not human-readable
      *
@@ -1140,6 +1190,7 @@ class MiscellaneousTest extends BaseTestCase
         $this->stringSmall = 'Lorem ipsum dolor sit amet.';
         $this->stringCommaSeparated = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit';
         $this->stringDotSeparated = 'Etiam ullamcorper. Suspendisse a pellentesque dui, non felis.';
+        $this->stringWithoutSpaces = 'LoremIpsumDolorSitAmetConsecteturAdipiscingElit';
     }
 
     /**
@@ -1152,5 +1203,6 @@ class MiscellaneousTest extends BaseTestCase
         unset($this->stringSmall);
         unset($this->stringCommaSeparated);
         unset($this->stringDotSeparated);
+        unset($this->stringWithoutSpaces);
     }
 }

tests/Utilities/QueryBuilderUtilityTest.php

@@ -0,0 +1,341 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Utilities;
+
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\ORM\EntityManager;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Query\Expr;
+use Doctrine\ORM\Query\Parameter;
+use Doctrine\ORM\QueryBuilder;
+use Generator;
+use Meritoo\Common\Test\Base\BaseTestCase;
+use Meritoo\Common\Utilities\QueryBuilderUtility;
+
+/**
+ * Test case of the useful methods for query builder (the Doctrine's QueryBuilder class)
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class QueryBuilderUtilityTest extends BaseTestCase
+{
+    public function testConstructor()
+    {
+        static::assertHasNoConstructor(QueryBuilderUtility::class);
+    }
+
+    /**
+     * @param QueryBuilder $queryBuilder The query builder to retrieve root alias
+     * @param null|string  $rootAlias    Expected root alias of given query builder
+     *
+     * @dataProvider provideQueryBuilderAndRootAlias
+     */
+    public function testGetRootAlias(QueryBuilder $queryBuilder, $rootAlias)
+    {
+        static::assertSame($rootAlias, QueryBuilderUtility::getRootAlias($queryBuilder));
+    }
+
+    /**
+     * @param QueryBuilder $queryBuilder  The query builder to verify
+     * @param string       $propertyName  Name of property that maybe is joined
+     * @param null|string  $propertyAlias Expected alias of given property joined in given query builder
+     *
+     * @dataProvider provideQueryBuilderAndPropertyAlias
+     */
+    public function testGetJoinedPropertyAlias(QueryBuilder $queryBuilder, $propertyName, $propertyAlias)
+    {
+        static::assertSame($propertyAlias, QueryBuilderUtility::getJoinedPropertyAlias($queryBuilder, $propertyName));
+    }
+
+    public function testSetCriteriaWithoutCriteria()
+    {
+        $entityManager = $this->getMock(EntityManagerInterface::class);
+        $queryBuilder = new QueryBuilder($entityManager);
+        $newQueryBuilder = QueryBuilderUtility::setCriteria($queryBuilder);
+
+        static::assertSame($queryBuilder, $newQueryBuilder);
+        static::assertCount(0, $newQueryBuilder->getParameters());
+        static::assertNull($newQueryBuilder->getDQLPart('where'));
+    }
+
+    public function testSetCriteriaWithoutAlias()
+    {
+        $criteria = [
+            'lorem' => 11,
+            'ipsum' => 22,
+        ];
+
+        $entityManager = $this->getMock(EntityManagerInterface::class);
+        $queryBuilder = new QueryBuilder($entityManager);
+        $newQueryBuilder = QueryBuilderUtility::setCriteria($queryBuilder, $criteria);
+
+        static::assertSame($queryBuilder, $newQueryBuilder);
+        static::assertCount(count($criteria), $newQueryBuilder->getParameters());
+        static::assertNotNull($newQueryBuilder->getDQLPart('where'));
+    }
+
+    /**
+     * @param QueryBuilder $queryBuilder The query builder
+     * @param array        $criteria     The criteria used in WHERE clause
+     *
+     * @dataProvider provideQueryBuilderAndCriteria
+     */
+    public function testSetCriteria(QueryBuilder $queryBuilder, array $criteria)
+    {
+        $newQueryBuilder = QueryBuilderUtility::setCriteria($queryBuilder, $criteria);
+        $criteriaCount = count($criteria);
+        $nullsCount = 0;
+
+        /*
+         * I have to verify count/amount of NULLs and decrease $criteriaCount, because for null parameter is not added
+         */
+        array_walk($criteria, function ($value) use (&$nullsCount) {
+            if (null === $value) {
+                ++$nullsCount;
+            }
+        });
+
+        static::assertSame($queryBuilder, $newQueryBuilder);
+        static::assertCount($criteriaCount - $nullsCount, $newQueryBuilder->getParameters());
+        static::assertNotNull($newQueryBuilder->getDQLPart('where'));
+    }
+
+    public function testDeleteEntitiesWithoutFlush()
+    {
+        $methods = [
+            'remove',
+            'flush',
+        ];
+
+        $entityManager = $this->getMock(EntityManager::class, $methods, [], '', false);
+        $entities1 = [];
+
+        $entities2 = [
+            new \stdClass(),
+        ];
+
+        static::assertFalse(QueryBuilderUtility::deleteEntities($entityManager, $entities1, false));
+        static::assertTrue(QueryBuilderUtility::deleteEntities($entityManager, $entities2, false));
+    }
+
+    public function testDeleteEntities()
+    {
+        $methods = [
+            'remove',
+            'flush',
+        ];
+
+        $entityManager = $this->getMock(EntityManager::class, $methods, [], '', false);
+        $entities1 = [];
+
+        $entities2 = [
+            new \stdClass(),
+        ];
+
+        static::assertFalse(QueryBuilderUtility::deleteEntities($entityManager, $entities1));
+        static::assertTrue(QueryBuilderUtility::deleteEntities($entityManager, $entities2));
+    }
+
+    /**
+     * @param QueryBuilder          $queryBuilder The query builder
+     * @param array|ArrayCollection $parameters   Parameters to add. Collection of Doctrine\ORM\Query\Parameter
+     *                                            instances or an array with key-value pairs.
+     *
+     * @dataProvider provideQueryBuilderAndParameters
+     */
+    public function testAddParameters(QueryBuilder $queryBuilder, $parameters)
+    {
+        $newQueryBuilder = QueryBuilderUtility::addParameters($queryBuilder, $parameters);
+
+        static::assertSame($queryBuilder, $newQueryBuilder);
+        static::assertCount(count($parameters), $newQueryBuilder->getParameters());
+    }
+
+    /**
+     * Provides query builder to retrieve root alias and expected root alias
+     *
+     * @return Generator
+     */
+    public function provideQueryBuilderAndRootAlias()
+    {
+        $entityManager = $this->getMock(EntityManagerInterface::class);
+
+        yield[
+            new QueryBuilder($entityManager),
+            null,
+        ];
+
+        yield[
+            (new QueryBuilder($entityManager))->from('lorem_ipsum', 'lm'),
+            'lm',
+        ];
+
+        yield[
+            (new QueryBuilder($entityManager))
+                ->from('lorem', 'l')
+                ->leftJoin('l.ipsum', 'i'),
+            'l',
+        ];
+    }
+
+    /**
+     * Provides query builder, name of property and expected alias of given property
+     *
+     * @return Generator
+     */
+    public function provideQueryBuilderAndPropertyAlias()
+    {
+        $entityManager = $this->getMock(EntityManagerInterface::class);
+
+        yield[
+            new QueryBuilder($entityManager),
+            '',
+            null,
+        ];
+
+        yield[
+            new QueryBuilder($entityManager),
+            'lorem',
+            null,
+        ];
+
+        yield[
+            (new QueryBuilder($entityManager))->from('lorem_ipsum', 'lm'),
+            'lm',
+            null,
+        ];
+
+        yield[
+            (new QueryBuilder($entityManager))
+                ->from('lorem', 'l')
+                ->leftJoin('l.ipsum', 'i'),
+            'ipsum',
+            'i',
+        ];
+
+        yield[
+            (new QueryBuilder($entityManager))
+                ->from('lorem', 'l')
+                ->leftJoin('l.ipsum', 'i')
+                ->innerJoin('i.dolor', 'd'),
+            'ipsum1',
+            null,
+        ];
+
+        yield[
+            (new QueryBuilder($entityManager))
+                ->from('lorem', 'l')
+                ->leftJoin('l.ipsum', 'i')
+                ->innerJoin('i.dolor', 'd'),
+            'ipsum',
+            'i',
+        ];
+
+        yield[
+            (new QueryBuilder($entityManager))
+                ->from('lorem', 'l')
+                ->leftJoin('l.ipsum', 'i')
+                ->innerJoin('i.dolor', 'd'),
+            'dolor',
+            'd',
+        ];
+    }
+
+    /**
+     * Provides query builder and criteria used in WHERE clause
+     *
+     * @return Generator
+     */
+    public function provideQueryBuilderAndCriteria()
+    {
+        $entityManager = $this->getMock(EntityManager::class, ['getExpressionBuilder'], [], '', false);
+
+        $entityManager
+            ->expects(static::any())
+            ->method('getExpressionBuilder')
+            ->willReturn(new Expr());
+
+        yield[
+            (new QueryBuilder($entityManager))->from('lorem_ipsum', 'lm'),
+            [
+                'lorem' => 11,
+                'ipsum' => 22,
+                'dolor' => null,
+            ],
+        ];
+
+        yield[
+            (new QueryBuilder($entityManager))->from('lorem_ipsum', 'lm'),
+            [
+                'lorem' => [
+                    11,
+                    '>=',
+                ],
+                'ipsum' => [
+                    22,
+                    '<',
+                ],
+                'dolor' => null,
+            ],
+        ];
+    }
+
+    /**
+     * Provides query builder and parameters to add to given query builder
+     *
+     * @return Generator
+     */
+    public function provideQueryBuilderAndParameters()
+    {
+        $entityManager = $this->getMock(EntityManagerInterface::class);
+
+        yield[
+            new QueryBuilder($entityManager),
+            [],
+        ];
+
+        yield[
+            new QueryBuilder($entityManager),
+            new ArrayCollection(),
+        ];
+
+        yield[
+            new QueryBuilder($entityManager),
+            [
+                'lorem' => 11,
+                'ipsum' => 22,
+            ],
+        ];
+
+        yield[
+            new QueryBuilder($entityManager),
+            new ArrayCollection([
+                'lorem' => 11,
+                'ipsum' => 22,
+            ]),
+        ];
+
+        yield[
+            new QueryBuilder($entityManager),
+            [
+                new Parameter('lorem', 11),
+                new Parameter('ipsum', 22),
+            ],
+        ];
+
+        yield[
+            new QueryBuilder($entityManager),
+            new ArrayCollection([
+                new Parameter('lorem', 11),
+                new Parameter('ipsum', 22),
+            ]),
+        ];
+    }
+}

tests/Utilities/Reflection/A.php

@@ -19,8 +19,15 @@ class A
 {
     use E;
 
+    private $count = 1;
+
     protected function lorem()
     {
         return 'ipsum';
     }
+
+    protected function getCount()
+    {
+        return $this->count;
+    }
 }

tests/Utilities/Reflection/B.php

@@ -0,0 +1,26 @@
+<?php
+
+/**
+ * (c) Meritoo.pl, http://www.meritoo.pl
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Meritoo\Common\Test\Utilities\Reflection;
+
+/**
+ * The B class.
+ * Used for testing the Reflection class.
+ *
+ * @author    Krzysztof Niziol <krzysztof.niziol@meritoo.pl>
+ * @copyright Meritoo.pl
+ */
+class B extends A implements I
+{
+    protected $name = 'Lorem Ipsum';
+
+    public function getName()
+    {
+        return $this->name;
+    }
+}