├── .github
    └── FUNDING.yml
├── .editorconfig
├── tests
    ├── FunctionsTest.php
    ├── LuhnAlgorithmFactoryTest.php
    ├── LuhnAlgorithmTest.php
    └── NumberTest.php
├── LICENSE.md
├── .gitignore
├── composer.json
├── src
    ├── Contract
    │   ├── LuhnAlgorithmExceptionInterface.php
    │   ├── NumberInterface.php
    │   └── LuhnAlgorithmInterface.php
    ├── Exceptions
    │   ├── MissingCheckDigitException.php
    │   └── ArgumentIsNotNumericException.php
    ├── functions.php
    ├── LuhnAlgorithmFactory.php
    ├── LuhnAlgorithm.php
    └── Number.php
├── .circleci
    └── config.yml
└── README.md


/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | buy_me_a_coffee: nekman
2 | 


--------------------------------------------------------------------------------
/.editorconfig:
--------------------------------------------------------------------------------
 1 | # See: https://editorconfig.org/#file-format-details
 2 | root = true
 3 | 
 4 | [*]
 5 | end_of_line = lf
 6 | insert_final_newline = true
 7 | charset = utf-8
 8 | indent_style = tab
 9 | trim_trailing_whitespace = true
10 | indent_size = 4
11 | 
12 | [*.yml]
13 | indent_style = space
14 | indent_size = 2
15 | 


--------------------------------------------------------------------------------
/tests/FunctionsTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Nekman\LuhnAlgorithm\Test;
 4 | 
 5 | use function Nekman\LuhnAlgorithm\Functions\string_is_numeric;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class FunctionsTest extends TestCase
 9 | {
10 |     /** @dataProvider provideStringIsNumeric */
11 |     public function testStringIsNumeric($string, $expected)
12 |     {
13 |         $this->assertEquals($expected, string_is_numeric($string));
14 |     }
15 | 
16 |     public function provideStringIsNumeric()
17 |     {
18 |         return [
19 |             "integer string" => ["123", true],
20 |             "float string" => ["123.321", true],
21 |             "whitespace" => ["123 ", false],
22 |             "integer" => [123, true],
23 |             "float" => [123.321, true],
24 |         ];
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2021 Niklas Ekman
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 6 | this software and associated documentation files (the "Software"), to deal in
 7 | the Software without restriction, including without limitation the rights to
 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 9 | the Software, and to permit persons to whom the Software is furnished to do so,
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | index.php
 2 | nbproject/
 3 | .idea/
 4 | .php_cs.cache
 5 | .phpunit.result.cache
 6 | coverage
 7 | test-results
 8 | 
 9 | # Eclipse
10 | .buildpath
11 | .project
12 | .settings/
13 | 
14 | # Created by http://www.gitignore.io
15 | 
16 | ### Composer ###
17 | composer.phar
18 | vendor/
19 | 
20 | # Commit your application's lock file http://getcomposer.org/doc/01-basic-usage.md#composer-lock-the-lock-file
21 | # You may choose to ignore a library lock file http://getcomposer.org/doc/02-libraries.md#lock-file
22 | composer.lock
23 | 
24 | ### Windows ###
25 | # Windows image file caches
26 | Thumbs.db
27 | ehthumbs.db
28 | 
29 | # Folder config file
30 | Desktop.ini
31 | 
32 | # Recycle Bin used on file shares
33 | $RECYCLE.BIN/
34 | 
35 | # Windows Installer files
36 | *.cab
37 | *.msi
38 | *.msm
39 | *.msp
40 | 
41 | 
42 | ### OSX ###
43 | .DS_Store
44 | .AppleDouble
45 | .LSOverride
46 | 
47 | # Icon must ends with two \r.
48 | Icon
49 | 
50 | 
51 | # Thumbnails
52 | ._*
53 | 
54 | # Files that might appear on external disk
55 | .Spotlight-V100
56 | .Trashes
57 | 
58 | 
59 | ### Linux ###
60 | *~
61 | 
62 | 
63 | ### NetBeans ###
64 | nbproject/private/
65 | build/
66 | nbbuild/
67 | dist/
68 | nbdist/
69 | nbactions.xml
70 | nb-configuration.xml
71 | nbproject/
72 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"name": "nekman/luhn-algorithm",
 3 | 	"type": "library",
 4 | 	"description": "Implementation of the Luhn algorithm in PHP. Used in validation of credit card numbers and some national identification numbers.",
 5 | 	"prefer-stable": true,
 6 | 	"minimum-stability": "stable",
 7 | 	"keywords": [
 8 | 		"luhn",
 9 | 		"credit",
10 | 		"card",
11 | 		"identification",
12 | 		"validation"
13 | 	],
14 | 	"license": "MIT",
15 | 	"authors": [
16 | 		{
17 | 			"name": "Niklas Ekman",
18 | 			"email": "nikl.ekman@gmail.com"
19 | 		}
20 | 	],
21 | 	"support": {
22 | 		"issues": "https://github.com/Ekman/Luhn-Algorithm/issues",
23 | 		"source": "https://github.com/Ekman/Luhn-Algorithm"
24 | 	},
25 | 	"autoload": {
26 | 		"psr-4": {
27 | 			"Nekman\\LuhnAlgorithm\\": "src"
28 | 		},
29 | 		"files": [
30 | 			"src/functions.php"
31 | 		]
32 | 	},
33 | 	"autoload-dev": {
34 | 		"psr-4": {
35 | 			"Nekman\\LuhnAlgorithm\\Test\\": "tests"
36 | 		}
37 | 	},
38 | 	"require": {
39 | 		"php": "^7.4||^8.0"
40 | 	},
41 | 	"require-dev": {
42 | 		"phpunit/phpunit": "^9.0",
43 | 		"friendsofphp/php-cs-fixer": "^2.15",
44 | 		"php-coveralls/php-coveralls": "^2.1"
45 | 	},
46 | 	"scripts": {
47 | 		"test": "phpunit tests",
48 | 		"lint": "php-cs-fixer fix --rules=@PSR2 ."
49 | 	}
50 | }
51 | 


--------------------------------------------------------------------------------
/src/Contract/LuhnAlgorithmExceptionInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * The MIT License (MIT)
 5 |  *
 6 |  * Copyright (c) 2021 Niklas Ekman
 7 |  *
 8 |  * Permission is hereby granted, free of charge, to any person obtaining a copy of
 9 |  * this software and associated documentation files (the "Software"), to deal in
10 |  * the Software without restriction, including without limitation the rights to
11 |  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
12 |  * the Software, and to permit persons to whom the Software is furnished to do so,
13 |  * subject to the following conditions:
14 |  *
15 |  * The above copyright notice and this permission notice shall be included in all
16 |  * copies or substantial portions of the Software.
17 |  *
18 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
20 |  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
21 |  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
22 |  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23 |  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 |  */
25 | 
26 | declare(strict_types=1);
27 | 
28 | namespace Nekman\LuhnAlgorithm\Contract;
29 | 
30 | use Throwable;
31 | 
32 | /**
33 |  * Base interface for all thrown exceptions in this library.
34 |  */
35 | interface LuhnAlgorithmExceptionInterface extends Throwable
36 | {
37 | }
38 | 


--------------------------------------------------------------------------------
/tests/LuhnAlgorithmFactoryTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * The MIT License (MIT)
 5 |  *
 6 |  * Copyright (c) 2021 Niklas Ekman
 7 |  *
 8 |  * Permission is hereby granted, free of charge, to any person obtaining a copy of
 9 |  * this software and associated documentation files (the "Software"), to deal in
10 |  * the Software without restriction, including without limitation the rights to
11 |  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
12 |  * the Software, and to permit persons to whom the Software is furnished to do so,
13 |  * subject to the following conditions:
14 |  *
15 |  * The above copyright notice and this permission notice shall be included in all
16 |  * copies or substantial portions of the Software.
17 |  *
18 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
20 |  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
21 |  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
22 |  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23 |  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 |  */
25 | 
26 | namespace Nekman\LuhnAlgorithm\Test;
27 | 
28 | use Nekman\LuhnAlgorithm\LuhnAlgorithm;
29 | use Nekman\LuhnAlgorithm\LuhnAlgorithmFactory;
30 | use PHPUnit\Framework\TestCase;
31 | 
32 | class LuhnAlgorithmFactoryTest extends TestCase
33 | {
34 |     public function testCreate()
35 |     {
36 |         $this->assertInstanceOf(LuhnAlgorithm::class, LuhnAlgorithmFactory::create());
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Exceptions/MissingCheckDigitException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * The MIT License (MIT)
 5 |  *
 6 |  * Copyright (c) 2021 Niklas Ekman
 7 |  *
 8 |  * Permission is hereby granted, free of charge, to any person obtaining a copy of
 9 |  * this software and associated documentation files (the "Software"), to deal in
10 |  * the Software without restriction, including without limitation the rights to
11 |  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
12 |  * the Software, and to permit persons to whom the Software is furnished to do so,
13 |  * subject to the following conditions:
14 |  *
15 |  * The above copyright notice and this permission notice shall be included in all
16 |  * copies or substantial portions of the Software.
17 |  *
18 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
20 |  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
21 |  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
22 |  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23 |  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 |  */
25 | 
26 | declare(strict_types=1);
27 | 
28 | namespace Nekman\LuhnAlgorithm\Exceptions;
29 | 
30 | use InvalidArgumentException;
31 | use Nekman\LuhnAlgorithm\Contract\LuhnAlgorithmExceptionInterface;
32 | 
33 | /**
34 |  * Indicates that the check digit should be present, but is in fact not.
35 |  */
36 | class MissingCheckDigitException extends InvalidArgumentException implements LuhnAlgorithmExceptionInterface
37 | {
38 | }
39 | 


--------------------------------------------------------------------------------
/src/functions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * The MIT License (MIT)
 5 |  *
 6 |  * Copyright (c) 2021 Niklas Ekman
 7 |  *
 8 |  * Permission is hereby granted, free of charge, to any person obtaining a copy of
 9 |  * this software and associated documentation files (the "Software"), to deal in
10 |  * the Software without restriction, including without limitation the rights to
11 |  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
12 |  * the Software, and to permit persons to whom the Software is furnished to do so,
13 |  * subject to the following conditions:
14 |  *
15 |  * The above copyright notice and this permission notice shall be included in all
16 |  * copies or substantial portions of the Software.
17 |  *
18 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
20 |  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
21 |  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
22 |  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23 |  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 |  */
25 | 
26 | declare(strict_types=1);
27 | 
28 | namespace Nekman\LuhnAlgorithm\Functions;
29 | 
30 | /**
31 |  * Determine if a string consists of only numbers
32 |  * @param string $possibleNumber The number to check
33 |  * @return bool true if the number consists only of numbers, false otherwise
34 |  * @internal
35 |  */
36 | function string_is_numeric(string $possibleNumber): bool
37 | {
38 |     return preg_match("/^\d+(\.\d+)?$/", $possibleNumber) === 1;
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Contract/NumberInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * The MIT License (MIT)
 5 |  *
 6 |  * Copyright (c) 2021 Niklas Ekman
 7 |  *
 8 |  * Permission is hereby granted, free of charge, to any person obtaining a copy of
 9 |  * this software and associated documentation files (the "Software"), to deal in
10 |  * the Software without restriction, including without limitation the rights to
11 |  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
12 |  * the Software, and to permit persons to whom the Software is furnished to do so,
13 |  * subject to the following conditions:
14 |  *
15 |  * The above copyright notice and this permission notice shall be included in all
16 |  * copies or substantial portions of the Software.
17 |  *
18 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
20 |  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
21 |  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
22 |  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23 |  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 |  */
25 | 
26 | declare(strict_types=1);
27 | 
28 | namespace Nekman\LuhnAlgorithm\Contract;
29 | 
30 | /**
31 |  * Describes the structure of a number in the Luhn Algorithm.
32 |  */
33 | interface NumberInterface
34 | {
35 |     /**
36 |      * Get the number, without check digit.
37 |      * @return string
38 |      */
39 |     public function getNumber(): string;
40 | 
41 |     /**
42 |      * Get the check digit for the number.
43 |      * @return int|null The check digit or null if it has not been calculated yet.
44 |      */
45 |     public function getCheckDigit(): ?int;
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Exceptions/ArgumentIsNotNumericException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * The MIT License (MIT)
 5 |  *
 6 |  * Copyright (c) 2021 Niklas Ekman
 7 |  *
 8 |  * Permission is hereby granted, free of charge, to any person obtaining a copy of
 9 |  * this software and associated documentation files (the "Software"), to deal in
10 |  * the Software without restriction, including without limitation the rights to
11 |  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
12 |  * the Software, and to permit persons to whom the Software is furnished to do so,
13 |  * subject to the following conditions:
14 |  *
15 |  * The above copyright notice and this permission notice shall be included in all
16 |  * copies or substantial portions of the Software.
17 |  *
18 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
20 |  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
21 |  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
22 |  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23 |  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 |  */
25 | 
26 | declare(strict_types=1);
27 | 
28 | namespace Nekman\LuhnAlgorithm\Exceptions;
29 | 
30 | use InvalidArgumentException;
31 | use Nekman\LuhnAlgorithm\Contract\LuhnAlgorithmExceptionInterface;
32 | 
33 | /**
34 |  * Indicates that an argument should be numeric, but is in fact not.
35 |  */
36 | class ArgumentIsNotNumericException extends InvalidArgumentException implements LuhnAlgorithmExceptionInterface
37 | {
38 |     public function __construct(string $number)
39 |     {
40 |         parent::__construct("Expects \$number to be a number, \"{$number}\" given.");
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/LuhnAlgorithmFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * The MIT License (MIT)
 5 |  *
 6 |  * Copyright (c) 2021 Niklas Ekman
 7 |  *
 8 |  * Permission is hereby granted, free of charge, to any person obtaining a copy of
 9 |  * this software and associated documentation files (the "Software"), to deal in
10 |  * the Software without restriction, including without limitation the rights to
11 |  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
12 |  * the Software, and to permit persons to whom the Software is furnished to do so,
13 |  * subject to the following conditions:
14 |  *
15 |  * The above copyright notice and this permission notice shall be included in all
16 |  * copies or substantial portions of the Software.
17 |  *
18 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
20 |  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
21 |  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
22 |  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23 |  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 |  */
25 | 
26 | declare(strict_types=1);
27 | 
28 | namespace Nekman\LuhnAlgorithm;
29 | 
30 | use Nekman\LuhnAlgorithm\Contract\LuhnAlgorithmInterface;
31 | 
32 | /**
33 |  * Factory for creating implementations of the Luhn Algorithm.
34 |  */
35 | class LuhnAlgorithmFactory
36 | {
37 |     /**
38 |      * @codeCoverageIgnore
39 |      */
40 |     private function __construct()
41 |     {
42 |         // Only static methods.
43 |     }
44 | 
45 |     /**
46 |      * Create a new instance of an implementation of the Luhn Algorithm.
47 |      * @return LuhnAlgorithmInterface Implementation of the Luhn Algorithm.
48 |      */
49 |     public static function create(): LuhnAlgorithmInterface
50 |     {
51 |         return new LuhnAlgorithm();
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/.circleci/config.yml:
--------------------------------------------------------------------------------
 1 | version: 2.1
 2 | 
 3 | orbs:
 4 |   composer: stockfiller/composer@2
 5 |   php-cs-fixer: stockfiller/php-cs-fixer@1
 6 |   phpunit: stockfiller/phpunit@1
 7 |   php-coveralls: nekman/php-coveralls@2
 8 | 
 9 | executors:
10 |   php74:
11 |     docker:
12 |       - image: php:7.4-alpine
13 |     resource_class: small
14 |   php80:
15 |     docker:
16 |       - image: php:8.0-alpine
17 |     resource_class: small
18 |   php81:
19 |     docker:
20 |       - image: php:8.1-alpine
21 |     resource_class: small
22 |   php82:
23 |     docker:
24 |       - image: php:8.2-alpine
25 |     resource_class: small
26 |   php83:
27 |     docker:
28 |       - image: php:8.3-alpine
29 |     resource_class: small
30 |   php84:
31 |     docker:
32 |       - image: php:8.4-alpine
33 |     resource_class: small
34 |   php85:
35 |     docker:
36 |       - image: php:8.5-rc-alpine
37 |     resource_class: small
38 | 
39 | jobs:
40 |   test_coverage:
41 |     executor: php74
42 |     environment:
43 |       CLOVER_PATH: coverage/clover.xml
44 |     steps:
45 |       - run:
46 |           name: Install PCOV and git
47 |           command: |-
48 |             apk add --update --no-cache ${PHPIZE_DEPS} git
49 |             pecl install pcov-1.0.6
50 |             docker-php-ext-enable pcov
51 |       - checkout
52 |       - composer/install_bin
53 |       - composer/install
54 |       - phpunit/test:
55 |           coverage: clover
56 |           coverage-path: "${CLOVER_PATH}"
57 |           src-path: src
58 |           test-path: tests
59 |       - php-coveralls/upload:
60 |           clover-path: "${CLOVER_PATH}"
61 | 
62 | workflows:
63 |   master:
64 |     jobs:
65 |       - php-cs-fixer/fix:
66 |           executor: php74
67 |           rules: "@PSR2"
68 |           path: .
69 |           pre-steps:
70 |             - run: apk add --update --no-cache git openssh-client
71 |             - composer/install_bin
72 |           filters:
73 |             branches:
74 |               ignore: master
75 |       - test_coverage
76 |       - phpunit/test:
77 |           test-path: tests
78 |           matrix:
79 |             parameters:
80 |               executor:
81 |                 - php80
82 |                 - php81
83 |                 - php82
84 |                 - php83
85 |                 - php84
86 |                 - php85
87 |           pre-steps: [ composer/install_bin ]
88 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Luhn Algorithm
 2 | 
 3 | [![Build Status](https://circleci.com/gh/Ekman/luhn-algorithm.svg?style=svg)](https://app.circleci.com/pipelines/github/Ekman/luhn-algorithm)
 4 | [![Coverage Status](https://coveralls.io/repos/github/Ekman/luhn-algorithm/badge.svg?branch=master)](https://coveralls.io/github/Ekman/luhn-algorithm?branch=master)
 5 | 
 6 | This is a zero dependency implementation of the Luhn Algorithm for PHP 7.4 and above. The Luhn Algorithm is used to validate things like credit cards and national identification numbers. More information on the algorithm can be found at [Wikipedia](http://en.wikipedia.org/wiki/Luhn_algorithm).
 7 | 
 8 | ## Installation
 9 | 
10 | Install with [Composer](https://getcomposer.org/):
11 | 
12 | ```bash
13 | composer require nekman/luhn-algorithm
14 | ```
15 | 
16 | ## Usage
17 | 
18 | In order to instantiate a new instance of the library, use the factory:
19 | 
20 |  ```php
21 |  use Nekman\LuhnAlgorithm\LuhnAlgorithmFactory;
22 | 
23 |  $luhn = LuhnAlgorithmFactory::create();
24 |  ```
25 | 
26 | You can find [the library facade in the `LuhnAlgorithmInterface.php` file](src/Contract/LuhnAlgorithmInterface.php).
27 | 
28 | [The `Number` class](src/Number.php) is a container class that holds the actual number and the check digit. It does no validation nor does it calculate the check digit. It exists to clearly separate the number from the check digit and to define when the check digit exists or not. To simplify the process of validating a number you can use the named constructor `Number::fromString()` like this:
29 | 
30 | ```php
31 | use Nekman\LuhnAlgorithm\Number;
32 | 
33 | // Assume $creditCard is from a form.
34 | $number = Number::fromString($creditCard);
35 | 
36 | if ($luhn->isValid($number)) {
37 |     // Number is valid.
38 | }
39 | ```
40 | 
41 | Alternatively, if you want to calculate the checksum or check digit for a number:
42 | 
43 | ```php
44 | use Nekman\LuhnAlgorithm\Number;
45 | 
46 | $number = new Number(12345);
47 | 
48 | $checksum = $luhn->calcChecksum($number);
49 | 
50 | $checkDigit = $luhn->calcCheckDigit($number);
51 | ```
52 | 
53 | ## Versioning
54 | 
55 | This project complies with [Semantic Versioning](https://semver.org/).
56 | 
57 | ## Changelog
58 | 
59 | For a complete list of changes, and how to migrate between major versions, see [releases page](https://github.com/Ekman/luhn-algorithm/releases).
60 | 
61 | ## Buy me a coffee
62 | 
63 | [!["Buy Me A Coffee"](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://buymeacoffee.com/nekman)
64 | 
65 | If you appreciate my work, then consider [buying me a coffee](https://buymeacoffee.com/nekman). Donations are completely voluntary.
66 | 


--------------------------------------------------------------------------------
/src/Contract/LuhnAlgorithmInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 |  * The MIT License (MIT)
 5 |  *
 6 |  * Copyright (c) 2021 Niklas Ekman
 7 |  *
 8 |  * Permission is hereby granted, free of charge, to any person obtaining a copy of
 9 |  * this software and associated documentation files (the "Software"), to deal in
10 |  * the Software without restriction, including without limitation the rights to
11 |  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
12 |  * the Software, and to permit persons to whom the Software is furnished to do so,
13 |  * subject to the following conditions:
14 |  *
15 |  * The above copyright notice and this permission notice shall be included in all
16 |  * copies or substantial portions of the Software.
17 |  *
18 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
20 |  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
21 |  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
22 |  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23 |  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 |  */
25 | 
26 | declare(strict_types=1);
27 | 
28 | namespace Nekman\LuhnAlgorithm\Contract;
29 | 
30 | use Nekman\LuhnAlgorithm\Exceptions\MissingCheckDigitException;
31 | 
32 | /**
33 |  * Handles the Luhn Algorithm.
34 |  *
35 |  * @link http://en.wikipedia.org/wiki/Luhn_algorithm
36 |  */
37 | interface LuhnAlgorithmInterface
38 | {
39 |     /**
40 |      * Determine if a number is valid according to the Luhn Algorithm.
41 |      * @param NumberInterface $number The number to validate.
42 |      * @throws MissingCheckDigitException If the check digit in the number is not set.
43 |      * @throws LuhnAlgorithmExceptionInterface
44 |      * @return bool true if number is valid, false otherwise.
45 |      */
46 |     public function isValid(NumberInterface $number): bool;
47 | 
48 |     /**
49 |      * Calculate the check digit for an input.
50 |      * @param NumberInterface $number The number to calculate the check digit for.
51 |      * @throws LuhnAlgorithmExceptionInterface
52 |      * @return int The check digit.
53 |      */
54 |     public function calcCheckDigit(NumberInterface $number): int;
55 | 
56 |     /**
57 |      * Calculates the checksum for number.
58 |      * @param NumberInterface $number The number to calculate the checksum for.
59 |      * @throws LuhnAlgorithmExceptionInterface
60 |      * @return int The checksum.
61 |      */
62 |     public function calcChecksum(NumberInterface $number): int;
63 | }
64 | 


--------------------------------------------------------------------------------
/src/LuhnAlgorithm.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /*
  4 |  * The MIT License (MIT)
  5 |  *
  6 |  * Copyright (c) 2021 Niklas Ekman
  7 |  *
  8 |  * Permission is hereby granted, free of charge, to any person obtaining a copy of
  9 |  * this software and associated documentation files (the "Software"), to deal in
 10 |  * the Software without restriction, including without limitation the rights to
 11 |  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 12 |  * the Software, and to permit persons to whom the Software is furnished to do so,
 13 |  * subject to the following conditions:
 14 |  *
 15 |  * The above copyright notice and this permission notice shall be included in all
 16 |  * copies or substantial portions of the Software.
 17 |  *
 18 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 19 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 20 |  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 21 |  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 22 |  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 23 |  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 24 |  */
 25 | 
 26 | declare(strict_types=1);
 27 | 
 28 | namespace Nekman\LuhnAlgorithm;
 29 | 
 30 | use Nekman\LuhnAlgorithm\Contract\LuhnAlgorithmInterface;
 31 | use Nekman\LuhnAlgorithm\Contract\NumberInterface;
 32 | use Nekman\LuhnAlgorithm\Exceptions\MissingCheckDigitException;
 33 | 
 34 | class LuhnAlgorithm implements LuhnAlgorithmInterface
 35 | {
 36 |     /**
 37 |      * @internal The intended way to instantiate this object is through the factory.
 38 |      *
 39 |      * @see LuhnAlgorithmFactory
 40 |      */
 41 |     public function __construct()
 42 |     {
 43 |     }
 44 | 
 45 |     /**
 46 |      * {@inheritDoc}
 47 |      */
 48 |     public function isValid(NumberInterface $number): bool
 49 |     {
 50 |         if ($number->getCheckDigit() === null) {
 51 |             throw new MissingCheckDigitException("Check digit is null.");
 52 |         }
 53 | 
 54 |         $checksum = $this->calcChecksum($number) + $number->getCheckDigit();
 55 | 
 56 |         return ($checksum % 10) === 0;
 57 |     }
 58 | 
 59 |     /**
 60 |      * {@inheritDoc}
 61 |      */
 62 |     public function calcChecksum(NumberInterface $number): int
 63 |     {
 64 |         $num = $number->getNumber();
 65 |         $nDigits = strlen($num);
 66 |         // Need to account for check digit
 67 |         $parity = ($nDigits + 1) % 2;
 68 |         $checksum = 0;
 69 | 
 70 |         for ($i = 0; $i < $nDigits; $i++) {
 71 |             $digit = (int)$num[$i];
 72 | 
 73 |             // Every other digit, starting from the rightmost,
 74 |             // shall be doubled.
 75 |             if (($i % 2) === $parity) {
 76 |                 $digit *= 2;
 77 | 
 78 |                 if ($digit > 9) {
 79 |                     $digit -= 9;
 80 |                 }
 81 |             }
 82 | 
 83 |             $checksum += $digit;
 84 |         }
 85 | 
 86 |         return $checksum;
 87 |     }
 88 | 
 89 |     /**
 90 |      * {@inheritDoc}
 91 |      */
 92 |     public function calcCheckDigit(NumberInterface $number): int
 93 |     {
 94 |         $checksum = $this->calcChecksum($number);
 95 | 
 96 |         // Get the last digit of the checksum.
 97 |         $checkDigit = $checksum % 10;
 98 | 
 99 |         return $checkDigit === 0
100 |             ? $checkDigit
101 |             : 10 - $checkDigit;
102 |     }
103 | }
104 | 


--------------------------------------------------------------------------------
/src/Number.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /*
  4 |  * The MIT License (MIT)
  5 |  *
  6 |  * Copyright (c) 2021 Niklas Ekman
  7 |  *
  8 |  * Permission is hereby granted, free of charge, to any person obtaining a copy of
  9 |  * this software and associated documentation files (the "Software"), to deal in
 10 |  * the Software without restriction, including without limitation the rights to
 11 |  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 12 |  * the Software, and to permit persons to whom the Software is furnished to do so,
 13 |  * subject to the following conditions:
 14 |  *
 15 |  * The above copyright notice and this permission notice shall be included in all
 16 |  * copies or substantial portions of the Software.
 17 |  *
 18 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 19 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 20 |  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 21 |  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 22 |  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 23 |  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 24 |  */
 25 | 
 26 | declare(strict_types=1);
 27 | 
 28 | namespace Nekman\LuhnAlgorithm;
 29 | 
 30 | use Nekman\LuhnAlgorithm\Contract\LuhnAlgorithmExceptionInterface;
 31 | use Nekman\LuhnAlgorithm\Contract\NumberInterface;
 32 | use Nekman\LuhnAlgorithm\Exceptions\ArgumentIsNotNumericException;
 33 | use function Nekman\LuhnAlgorithm\Functions\string_is_numeric;
 34 | use Serializable;
 35 | 
 36 | /**
 37 |  * Input for the Luhn Algorithm contains a number and a check digit.
 38 |  */
 39 | class Number implements NumberInterface, Serializable
 40 | {
 41 |     private string $number;
 42 |     private ?int $checkDigit;
 43 | 
 44 |     /**
 45 |      * @param string $number The number.
 46 |      * @param int|null $checkDigit [Optional] The check digit for the number.
 47 |      * @throws ArgumentIsNotNumericException If the number input does not consist entirely of numbers.
 48 |      */
 49 |     public function __construct(string $number, ?int $checkDigit = null)
 50 |     {
 51 |         if (!string_is_numeric($number)) {
 52 |             throw new ArgumentIsNotNumericException($number);
 53 |         }
 54 | 
 55 |         $this->number = $number;
 56 |         $this->checkDigit = $checkDigit;
 57 |     }
 58 | 
 59 |     /**
 60 |      * Create a new number from an input that contains the check digit already
 61 |      * @param string $input The input that contains the check digit already.
 62 |      * @return self
 63 |      *
 64 |      * @throws LuhnAlgorithmExceptionInterface
 65 |      * @throws ArgumentIsNotNumericException If the input does not consist entirely of numbers.
 66 |      */
 67 |     public static function fromString(string $input): self
 68 |     {
 69 |         $input = preg_replace('/[^\d]/', '', $input);
 70 | 
 71 |         if (!string_is_numeric($input)) {
 72 |             throw new ArgumentIsNotNumericException($input);
 73 |         }
 74 | 
 75 |         $lastIndex = strlen($input) - 1;
 76 | 
 77 |         // Get the last digit.
 78 |         $checkDigit = (int)$input[$lastIndex];
 79 | 
 80 |         // Remove the last digit.
 81 |         $number = substr($input, 0, $lastIndex);
 82 | 
 83 |         return new self($number, $checkDigit);
 84 |     }
 85 | 
 86 |     public function __toString(): string
 87 |     {
 88 |         return $this->number . $this->checkDigit;
 89 |     }
 90 | 
 91 |     /**
 92 |      * {@inheritdoc}
 93 |      */
 94 |     public function getCheckDigit(): ?int
 95 |     {
 96 |         return $this->checkDigit;
 97 |     }
 98 | 
 99 |     /**
100 |      * {@inheritdoc}
101 |      */
102 |     public function getNumber(): string
103 |     {
104 |         return $this->number;
105 |     }
106 | 
107 |     public function serialize(): string
108 |     {
109 |         return serialize($this->__serialize());
110 |     }
111 | 
112 |     public function __serialize(): array
113 |     {
114 |         return [$this->number, $this->checkDigit];
115 |     }
116 | 
117 |     public function unserialize($data): void
118 |     {
119 |         $this->__unserialize(unserialize($data));
120 |     }
121 | 
122 |     public function __unserialize(array $data): void
123 |     {
124 |         [$this->number, $this->checkDigit] = $data;
125 |     }
126 | }
127 | 


--------------------------------------------------------------------------------
/tests/LuhnAlgorithmTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /*
  4 |  * The MIT License (MIT)
  5 |  *
  6 |  * Copyright (c) 2021 Niklas Ekman
  7 |  *
  8 |  * Permission is hereby granted, free of charge, to any person obtaining a copy of
  9 |  * this software and associated documentation files (the "Software"), to deal in
 10 |  * the Software without restriction, including without limitation the rights to
 11 |  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 12 |  * the Software, and to permit persons to whom the Software is furnished to do so,
 13 |  * subject to the following conditions:
 14 |  *
 15 |  * The above copyright notice and this permission notice shall be included in all
 16 |  * copies or substantial portions of the Software.
 17 |  *
 18 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 19 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 20 |  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 21 |  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 22 |  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 23 |  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 24 |  */
 25 | 
 26 | namespace Nekman\LuhnAlgorithm\Test;
 27 | 
 28 | use InvalidArgumentException;
 29 | use Nekman\LuhnAlgorithm\Contract\LuhnAlgorithmExceptionInterface;
 30 | use Nekman\LuhnAlgorithm\Exceptions\MissingCheckDigitException;
 31 | use Nekman\LuhnAlgorithm\LuhnAlgorithm;
 32 | use Nekman\LuhnAlgorithm\Number;
 33 | use PHPUnit\Framework\TestCase;
 34 | 
 35 | class LuhnAlgorithmTest extends TestCase
 36 | {
 37 |     /**
 38 |      * @var LuhnAlgorithm
 39 |      */
 40 |     private $luhn;
 41 | 
 42 |     /**
 43 |      * @dataProvider provideIsValid_success
 44 |      */
 45 |     public function testIsValid_success($number, $expected)
 46 |     {
 47 |         $this->assertEquals($expected, $this->luhn->isValid($number));
 48 |     }
 49 | 
 50 |     public function provideIsValid_success()
 51 |     {
 52 |         return [
 53 |             "Valid number" => [new Number('12345', 5), true],
 54 |             "Zero" => [new Number('0', 0), true],
 55 |             "Larger than INT_MAX" => [new Number('92233720368547758072', 8), true],
 56 |             "Invalid number" => [new Number('12345', 6), false],
 57 |             "Swedish company organization ID" => [new Number(559114884, 5), true],
 58 |             "Swedish organization number" => [new Number(640319261, 7), true],
 59 |         ];
 60 |     }
 61 | 
 62 |     /**
 63 |      * @dataProvider provideIsValid_failure
 64 |      */
 65 |     public function testIsValid_failure($number, $exception)
 66 |     {
 67 |         $this->expectException($exception);
 68 |         $this->luhn->isValid($number);
 69 |     }
 70 | 
 71 |     public function provideIsValid_failure()
 72 |     {
 73 |         return [
 74 |             "Invalid argument" => [new Number(123, null), InvalidArgumentException::class],
 75 |             "Should be MissingCheckDigitException" => [new Number(123, null), MissingCheckDigitException::class],
 76 |             "Should be LuhnAlgorithmExceptionInterface" => [new Number(123, null), LuhnAlgorithmExceptionInterface::class],
 77 |         ];
 78 |     }
 79 | 
 80 |     /**
 81 |      * @dataProvider provideCalcChecksum_success
 82 |      */
 83 |     public function testCalcChecksum_success($number, $expected)
 84 |     {
 85 |         $this->assertEquals($expected, $this->luhn->calcChecksum($number));
 86 |     }
 87 | 
 88 |     public function provideCalcChecksum_success()
 89 |     {
 90 |         return [
 91 |             "Valid checksum" => [new Number(3199723370002), 50],
 92 |             "Checksum mod 10 is 0" => [new Number(31997), 30],
 93 |         ];
 94 |     }
 95 | 
 96 |     /**
 97 |      * @dataProvider provideCalcCheckDigit_success
 98 |      */
 99 |     public function testCalcCheckDigit_success($number, $expected)
100 |     {
101 |         $this->assertEquals($expected, $this->luhn->calcCheckDigit($number));
102 |     }
103 | 
104 |     public function provideCalcCheckDigit_success()
105 |     {
106 |         return [
107 |             "Valid number" => [new Number(12345), 5],
108 |             "Swedish company organization ID" => [new Number(559114884), 5],
109 |             "Swedish organization number" => [new Number(640319261), 7],
110 |             "Checksum mod 10 is 0" => [new Number(31997), 0],
111 |         ];
112 |     }
113 | 
114 |     protected function setUp(): void
115 |     {
116 |         parent::setUp();
117 | 
118 |         $this->luhn = new LuhnAlgorithm();
119 |     }
120 | }
121 | 


--------------------------------------------------------------------------------
/tests/NumberTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /*
  4 |  * The MIT License (MIT)
  5 |  *
  6 |  * Copyright (c) 2021 Niklas Ekman
  7 |  *
  8 |  * Permission is hereby granted, free of charge, to any person obtaining a copy of
  9 |  * this software and associated documentation files (the "Software"), to deal in
 10 |  * the Software without restriction, including without limitation the rights to
 11 |  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 12 |  * the Software, and to permit persons to whom the Software is furnished to do so,
 13 |  * subject to the following conditions:
 14 |  *
 15 |  * The above copyright notice and this permission notice shall be included in all
 16 |  * copies or substantial portions of the Software.
 17 |  *
 18 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 19 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 20 |  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 21 |  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 22 |  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 23 |  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 24 |  */
 25 | 
 26 | namespace Nekman\LuhnAlgorithm\Test;
 27 | 
 28 | use Nekman\LuhnAlgorithm\Contract\LuhnAlgorithmExceptionInterface;
 29 | use Nekman\LuhnAlgorithm\Exceptions\ArgumentIsNotNumericException;
 30 | use Nekman\LuhnAlgorithm\Number;
 31 | use PHPUnit\Framework\TestCase;
 32 | 
 33 | class NumberTest extends TestCase
 34 | {
 35 |     /**
 36 |      * @dataProvider provideFromString_success
 37 |      */
 38 |     public function testFromString_success($number, $expected)
 39 |     {
 40 |         $this->assertEquals($expected, Number::fromString($number));
 41 |     }
 42 | 
 43 |     public function provideFromString_success()
 44 |     {
 45 |         return [
 46 |             "String" => ["410321-9202", new Number('410321920', 2)],
 47 |             "Integer" => [4103219202, new Number('410321920', 2)],
 48 |             "Large number" => ['89148000003974165685', new Number('8914800000397416568', 5)],
 49 |             "Character in string" => ['abc123', new Number('12', 3)],
 50 |             "Larger than INT_MAX" => ['922337203685477580721', new Number('92233720368547758072', 1)],
 51 |         ];
 52 |     }
 53 | 
 54 |     /**
 55 |      * @dataProvider provideFromString_fail
 56 |      */
 57 |     public function testFromString_fail($number, $expected)
 58 |     {
 59 |         $this->expectException($expected);
 60 |         Number::fromString($number);
 61 |     }
 62 | 
 63 |     public function provideFromString_fail()
 64 |     {
 65 |         return [
 66 |             "Empty string" => ['', \InvalidArgumentException::class],
 67 |             "Invalid string" => ['xyz ', \InvalidArgumentException::class],
 68 |             "Should be ArgumentIsNotNullException" => ["foo", ArgumentIsNotNumericException::class],
 69 |             "Should be LuhnAlgorithmExceptionInterface" => ["bar", LuhnAlgorithmExceptionInterface::class],
 70 |         ];
 71 |     }
 72 | 
 73 |     /**
 74 |      * @dataProvider provideToString_success
 75 |      */
 76 |     public function testToString_success($number, $expected)
 77 |     {
 78 |         $this->assertEquals($expected, (string)$number);
 79 |     }
 80 | 
 81 |     public function provideToString_success()
 82 |     {
 83 |         return [
 84 |             "Valid number" => [new Number(12345, 5), "123455"]
 85 |         ];
 86 |     }
 87 | 
 88 |     /**
 89 |      * @dataProvider provideNew_fail
 90 |      */
 91 |     public function testNew_fail($number, $checkDigit, $expected)
 92 |     {
 93 |         $this->expectException($expected);
 94 |         new Number($number, $checkDigit);
 95 |     }
 96 | 
 97 |     public function provideNew_fail()
 98 |     {
 99 |         return [
100 |             "Invalid number" => ['abc123', 1, \InvalidArgumentException::class],
101 |             "Whitespace" => ['123 ', null, \InvalidArgumentException::class],
102 |             "Should be ArgumentIsNotNullException" => ["foo", null, ArgumentIsNotNumericException::class],
103 |             "Should be LuhnAlgorithmExceptionInterface" => ["bar", null, LuhnAlgorithmExceptionInterface::class],
104 |         ];
105 |     }
106 | 
107 |     /**
108 |      * @dataProvider provideProperties
109 |      */
110 |     public function testProperties($input, $checkDigit)
111 |     {
112 |         $number = new Number($input, $checkDigit);
113 |         $this->assertEquals($input, $number->getNumber());
114 |         $this->assertEquals($checkDigit, $number->getCheckDigit());
115 |     }
116 | 
117 |     public function provideProperties()
118 |     {
119 |         return [
120 |             "Valid number and check digit" => [123, 1],
121 |             "Valid number and check digit (null)" => [123, null],
122 |         ];
123 |     }
124 | 
125 |     public function testSerialize()
126 |     {
127 |         $number = new Number(133, 7);
128 |         $serialized = serialize($number);
129 |         $other = unserialize($serialized);
130 |         $this->assertInstanceOf(Number::class, $other);
131 |         $this->assertEquals(133, $other->getNumber());
132 |         $this->assertEquals(7, $other->getCheckDigit());
133 |     }
134 | }
135 | 


--------------------------------------------------------------------------------