first commit

Author: mkorkmaz

Diff for: .coveralls.yml

@@ -0,0 +1,3 @@
+# .coveralls.yml configuration
+service_name: travis-ci
+coverage_clover: tests/_output/coverage.xml

Diff for: .scrutinizer.yml

@@ -0,0 +1,12 @@
+# .scrutinizer.yml
+
+checks:
+  php:
+    code_rating: true
+    duplication: true
+build:
+  environment:
+    php: '7.1'
+filter:
+  excluded_paths:
+    - "tests/"

Diff for: .travis.yml

@@ -0,0 +1,18 @@
+language: php
+sudo: false
+cache:
+  apt: true
+
+php:
+    - 7.1
+
+before_script:
+    - composer install --prefer-source
+script:
+    - vendor/bin/codecept run --coverage --coverage-xml --coverage-html
+after_script:
+    - if [ $TRAVIS_PHP_VERSION >= '7.0' ]; then php vendor/bin/coveralls; fi
+after_success:
+    - travis_retry php vendor/bin/coveralls -v
+
+

Diff for: codeception.yml

@@ -0,0 +1,14 @@
+paths:
+    tests: tests
+    output: tests/_output
+    data: tests/_data
+    support: tests/_support
+    envs: tests/_envs
+actor_suffix: Tester
+extensions:
+    enabled:
+        - Codeception\Extension\RunFailed
+coverage:
+    enabled: true
+    include:
+        - src/*

Diff for: composer.json

@@ -0,0 +1,30 @@
+{
+    "name": "selami/stdlib",
+    "description": "Standart Library for Selami libraries.",
+    "type": "library",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Mehmet Korkmaz",
+            "email": "[email protected]"
+        }
+    ],
+    "minimum-stability": "stable",
+    "require": {},
+    "require-dev": {
+        "codeception/codeception": "^2.3",
+        "satooshi/php-coveralls": "~1.0"
+
+    },
+    "autoload": {
+        "psr-4": {
+            "Selami\\Stdlib\\": "src/"
+        }
+    },
+    "autoload-dev": {
+        "psr-4": {
+            "Selami\\Resources\\" : "tests/resources/src/"
+        }
+    }
+
+}

Diff for: src/CaseConverter.php

@@ -0,0 +1,52 @@
+<?php
+declare(strict_types=1);
+
+namespace Selami\Stdlib;
+
+
+class CaseConverter
+{
+    /**
+     * Returns PascalCase string
+     *
+     * @param string $source
+     * @return string
+     *
+     */
+    public static function toPascalCase(string $source) : string
+    {
+        // If the string is snake case
+        $modified = str_replace('_', ' ', $source);
+        $lowercase = mb_strtolower($modified);
+        $uppercaseFirstLetters = mb_convert_case($lowercase, MB_CASE_TITLE);
+        return str_replace(' ', '', $uppercaseFirstLetters);
+    }
+
+    /**
+     * Returns camelCase string
+     *
+     * @param string $source
+     * @return string
+     *
+     */
+    public static function toCamelCase(string $source) : string
+    {
+        return lcfirst(self::toPascalCase($source));
+    }
+
+    /**
+     * Returns snake_case string
+     *
+     * @param string $source
+     * @return string
+     *
+     */
+    public static function toSnakeCase(string $source) : string
+    {
+        // If the string is pascal/camel case
+        $modified = preg_replace('/(\w)([A-Z]+)/', ' $1', $source);
+        $lowercase = mb_strtolower($modified);
+        return str_replace(' ', '_', $lowercase);
+    }
+
+}

Diff for: src/Exception/InvalidArgumentException.php

@@ -0,0 +1,10 @@
+<?php
+declare(strict_types=1);
+
+namespace Selami\Stdlib\Exception;
+
+
+class InvalidArgumentException extends \InvalidArgumentException
+{
+
+}

Diff for: src/Resolver.php

@@ -0,0 +1,64 @@
+<?php
+declare(strict_types=1);
+
+namespace Selami\Stdlib;
+
+use ReflectionMethod;
+use ReflectionParameter;
+use Selami\Stdlib\Exception\InvalidArgumentException;
+use ReflectionException;
+
+class Resolver
+{
+    /**
+     * @param string $className
+     * @param string $methodName
+     * @return array
+     * @throws InvalidArgumentException
+     */
+
+    public static function getParameterHints(string $className, string $methodName) : array
+    {
+        if (! class_exists($className)) {
+            throw new InvalidArgumentException(
+                sprintf('%s class does not exist!', $className)
+            );
+        }
+        if (! method_exists($className, $methodName)) {
+            throw new InvalidArgumentException(
+                sprintf('%s does not have method named %s!', $className, $methodName)
+            );
+        }
+        $method = new ReflectionMethod($className, $methodName);
+        /**
+         * @var array $parameters
+         */
+        $parameters = $method->getParameters();
+        $parameterHints = [];
+        foreach ($parameters as $param) {
+            $parameter = self::getParamType($param);
+            $parameterHints[$parameter['name']] = $parameter['type'];
+        }
+        return $parameterHints;
+    }
+
+
+    /**
+     * @param ReflectionParameter $parameter
+     * @return array
+     * @throws InvalidArgumentException
+     */
+    private static function getParamType(ReflectionParameter $parameter) :array
+    {
+        $type = $parameter->getType();
+        if ($type->isBuiltin()) {
+            return ['name' => $parameter->getName(), 'type' => (string) $type];
+        }
+        try {
+            return ['name' => $parameter->getName(), 'type' =>$parameter->getClass()->name];
+        } catch (ReflectionException $e) {
+            throw new InvalidArgumentException($e->getMessage());
+        }
+    }
+
+}