wmde / Euro

tests/bootstrap.php

Spacing +7 added lines, -7 removed lines

@@ -1,16 +1,16 @@
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types = 1);
 
-if ( PHP_SAPI !== 'cli' ) {
-	die( 'Not an entry point' );
+if (PHP_SAPI !== 'cli') {
+	die('Not an entry point');
 }
 
 error_reporting( -1 );
-ini_set( 'display_errors', '1' );
+ini_set('display_errors', '1');
 
-if ( !is_readable( __DIR__ . '/../vendor/autoload.php' ) ) {
-	die( 'You need to install this package with Composer before you can run the tests' );
+if (!is_readable(__DIR__.'/../vendor/autoload.php')) {
+	die('You need to install this package with Composer before you can run the tests');
 }
 
-require __DIR__ . '/../vendor/autoload.php';
+require __DIR__.'/../vendor/autoload.php';

tests/Unit/EuroErisTest.php

Spacing +21 added lines, -21 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types = 1);
 
 namespace WMDE\Euro\Tests\Unit;
 
@@ -19,43 +19,43 @@ 
 	use TestTrait;
 
 	public function testGivenNegativeAmount_constructorThrowsException() {
-		$this->forAll( Generator\neg() )
-			->then( function( int $negativeInteger ) {
-				$this->expectException( \InvalidArgumentException::class );
-				Euro::newFromCents( $negativeInteger );
+		$this->forAll(Generator\neg())
+			->then(function(int $negativeInteger) {
+				$this->expectException(\InvalidArgumentException::class);
+				Euro::newFromCents($negativeInteger);
 			} );
 	}
 
 	public function testGetCentsReturnsConstructorArgument() {
-		$this->limitTo( 10000 )
-			->forAll( Generator\choose( 0, 100 * 100 ) )
-			->then( function( int $unsignedInteger ) {
-				$amount = Euro::newFromCents( $unsignedInteger );
-				$this->assertSame( $unsignedInteger, $amount->getEuroCents() );
+		$this->limitTo(10000)
+			->forAll(Generator\choose(0, 100 * 100))
+			->then(function(int $unsignedInteger) {
+				$amount = Euro::newFromCents($unsignedInteger);
+				$this->assertSame($unsignedInteger, $amount->getEuroCents());
 			} );
 	}
 
 	public function testEquality() {
-		$this->limitTo( 10000 )
-			->forAll( Generator\choose( 0, 100 * 100 ) )
-			->then( function( int $unsignedInteger ) {
-				$amount = Euro::newFromCents( $unsignedInteger );
-				$this->assertTrue( $amount->equals( Euro::newFromCents( $unsignedInteger ) ) );
+		$this->limitTo(10000)
+			->forAll(Generator\choose(0, 100 * 100))
+			->then(function(int $unsignedInteger) {
+				$amount = Euro::newFromCents($unsignedInteger);
+				$this->assertTrue($amount->equals(Euro::newFromCents($unsignedInteger)));
 			} );
 	}
 
 	public function testNewFromString() {
-		$this->limitTo( 10000 )
-			->forAll( Generator\choose( 0, 100 ), Generator\choose( 0, 99 ) )
-			->then( function( int $firstInt, int $secondInt ) {
+		$this->limitTo(10000)
+			->forAll(Generator\choose(0, 100), Generator\choose(0, 99))
+			->then(function(int $firstInt, int $secondInt) {
 				$euroString =
-					(string)$firstInt
+					(string) $firstInt
 					. '.'
-					. str_pad( (string)$secondInt, 2, '0', STR_PAD_LEFT );
+					. str_pad((string) $secondInt, 2, '0', STR_PAD_LEFT);
 
 				$this->assertSame(
 					$firstInt * 100 + $secondInt,
-					Euro::newFromString( $euroString )->getEuroCents()
+					Euro::newFromString($euroString)->getEuroCents()
 				);
 			} );
 	}

tests/Unit/EuroTest.php

Spacing +92 added lines, -92 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types = 1);
 
 namespace WMDE\Euro\Tests\Unit;
 
@@ -18,201 +18,201 @@ 
 	/**
 	 * @dataProvider unsignedIntegerProvider
 	 */
-	public function testGetCentsReturnsConstructorArgument( int $unsignedInteger ) {
-		$amount = Euro::newFromCents( $unsignedInteger );
-		$this->assertSame( $unsignedInteger, $amount->getEuroCents() );
+	public function testGetCentsReturnsConstructorArgument(int $unsignedInteger) {
+		$amount = Euro::newFromCents($unsignedInteger);
+		$this->assertSame($unsignedInteger, $amount->getEuroCents());
 	}
 
 	public function unsignedIntegerProvider() {
 		return [
-			[ 0 ], [ 1 ], [ 2 ], [ 9 ], [ 10 ], [ 11 ],
-			[ 99 ], [ 100 ], [ 101 ], [ 999 ], [ 1000 ], [ 1001 ],
+			[0], [1], [2], [9], [10], [11],
+			[99], [100], [101], [999], [1000], [1001],
 		];
 	}
 
 	public function testGivenZero_getEuroFloatReturnsZeroFloat() {
-		$amount = Euro::newFromCents( 0 );
-		$this->assertExactFloat( 0.0, $amount->getEuroFloat() );
-		$this->assertNotSame( 0, $amount->getEuroFloat() );
+		$amount = Euro::newFromCents(0);
+		$this->assertExactFloat(0.0, $amount->getEuroFloat());
+		$this->assertNotSame(0, $amount->getEuroFloat());
 	}
 
-	private function assertExactFloat( float $expected, $actual ) {
-		$this->assertInternalType( 'float', $actual );
-		$this->assertEquals( $expected, $actual, '', 0 );
+	private function assertExactFloat(float $expected, $actual) {
+		$this->assertInternalType('float', $actual);
+		$this->assertEquals($expected, $actual, '', 0);
 	}
 
 	public function testGivenOneEuro_getEuroFloatReturnsOne() {
-		$amount = Euro::newFromCents( 100 );
-		$this->assertExactFloat( 1.0, $amount->getEuroFloat() );
+		$amount = Euro::newFromCents(100);
+		$this->assertExactFloat(1.0, $amount->getEuroFloat());
 	}
 
 	public function testGivenOneCent_getEuroFloatReturnsPointZeroOne() {
-		$amount = Euro::newFromCents( 1 );
-		$this->assertExactFloat( 0.01, $amount->getEuroFloat() );
+		$amount = Euro::newFromCents(1);
+		$this->assertExactFloat(0.01, $amount->getEuroFloat());
 	}
 
 	public function testGiven33cents_getEuroFloatReturnsPointThreeThree() {
-		$amount = Euro::newFromCents( 33 );
-		$this->assertExactFloat( 0.33, $amount->getEuroFloat() );
+		$amount = Euro::newFromCents(33);
+		$this->assertExactFloat(0.33, $amount->getEuroFloat());
 	}
 
 	public function testGivenNegativeAmount_constructorThrowsException() {
-		$this->expectException( \InvalidArgumentException::class );
+		$this->expectException(\InvalidArgumentException::class);
 		Euro::newFromCents( -1 );
 	}
 
 	public function testGivenZero_getEuroStringReturnsZeroString() {
-		$amount = Euro::newFromCents( 0 );
-		$this->assertSame( '0.00', $amount->getEuroString() );
+		$amount = Euro::newFromCents(0);
+		$this->assertSame('0.00', $amount->getEuroString());
 	}
 
 	public function testGivenOneEuro_getEuroStringReturnsOnePointZeroZero() {
-		$amount = Euro::newFromCents( 100 );
-		$this->assertSame( '1.00', $amount->getEuroString() );
+		$amount = Euro::newFromCents(100);
+		$this->assertSame('1.00', $amount->getEuroString());
 	}
 
 	public function testGivenTwoEuros_getEuroStringReturnsTwoPointZeroZero() {
-		$amount = Euro::newFromCents( 200 );
-		$this->assertSame( '2.00', $amount->getEuroString() );
+		$amount = Euro::newFromCents(200);
+		$this->assertSame('2.00', $amount->getEuroString());
 	}
 
 	public function testGivenOneCent_getEuroStringReturnsZeroPointZeroOne() {
-		$amount = Euro::newFromCents( 1 );
-		$this->assertSame( '0.01', $amount->getEuroString() );
+		$amount = Euro::newFromCents(1);
+		$this->assertSame('0.01', $amount->getEuroString());
 	}
 
 	public function testGivenTenCents_getEuroStringReturnsZeroPointOneZero() {
-		$amount = Euro::newFromCents( 10 );
-		$this->assertSame( '0.10', $amount->getEuroString() );
+		$amount = Euro::newFromCents(10);
+		$this->assertSame('0.10', $amount->getEuroString());
 	}
 
 	public function testGiven1234Cents_getEuroStringReturns12euro34() {
-		$amount = Euro::newFromCents( 1234 );
-		$this->assertSame( '12.34', $amount->getEuroString() );
+		$amount = Euro::newFromCents(1234);
+		$this->assertSame('12.34', $amount->getEuroString());
 	}
 
 	public function testOneEuroString_getsTurnedInto100cents() {
-		$this->assertSame( 100, Euro::newFromString( '1.00' )->getEuroCents() );
+		$this->assertSame(100, Euro::newFromString('1.00')->getEuroCents());
 	}
 
 	public function testOneCentString_getsTurnedInto1cents() {
-		$this->assertSame( 1, Euro::newFromString( '0.01' )->getEuroCents() );
+		$this->assertSame(1, Euro::newFromString('0.01')->getEuroCents());
 	}
 
 	public function testTenCentString_getsTurnedInto10cents() {
-		$this->assertSame( 10, Euro::newFromString( '0.10' )->getEuroCents() );
+		$this->assertSame(10, Euro::newFromString('0.10')->getEuroCents());
 	}
 
 	public function testShortTenCentString_getsTurnedInto10cents() {
-		$this->assertSame( 10, Euro::newFromString( '0.1' )->getEuroCents() );
+		$this->assertSame(10, Euro::newFromString('0.1')->getEuroCents());
 	}
 
 	public function testShortOneEuroString_getsTurnedInto100cents() {
-		$this->assertSame( 100, Euro::newFromString( '1' )->getEuroCents() );
+		$this->assertSame(100, Euro::newFromString('1')->getEuroCents());
 	}
 
 	public function testOneDecimalOneEuroString_getsTurnedInto100cents() {
-		$this->assertSame( 100, Euro::newFromString( '1.0' )->getEuroCents() );
+		$this->assertSame(100, Euro::newFromString('1.0')->getEuroCents());
 	}
 
 	public function testMultiDecimalOneEuroString_getsTurnedInto100cents() {
-		$this->assertSame( 100, Euro::newFromString( '1.00000' )->getEuroCents() );
+		$this->assertSame(100, Euro::newFromString('1.00000')->getEuroCents());
 	}
 
 	public function testHandlingOfLargeEuroString() {
-		$this->assertSame( 3133742, Euro::newFromString( '31337.42' )->getEuroCents() );
+		$this->assertSame(3133742, Euro::newFromString('31337.42')->getEuroCents());
 	}
 
 	public function testEuroStringThatCausedRoundingError_doesNotCauseRoundingError() {
 		// Regression test for https://phabricator.wikimedia.org/T183481
-		$this->assertSame( 870, Euro::newFromString( '8.70' )->getEuroCents() );
-		$this->assertSame( 920, Euro::newFromString( '9.20' )->getEuroCents() );
+		$this->assertSame(870, Euro::newFromString('8.70')->getEuroCents());
+		$this->assertSame(920, Euro::newFromString('9.20')->getEuroCents());
 	}
 
 	public function testEuroStringWithRoundingError_getsRoundedAppropriately() {
-		$this->assertSame( 101, Euro::newFromString( '1.0100000001' )->getEuroCents() );
-		$this->assertSame( 101, Euro::newFromString( '1.010000009999' )->getEuroCents() );
-		$this->assertSame( 101, Euro::newFromString( '1.011' )->getEuroCents() );
-		$this->assertSame( 101, Euro::newFromString( '1.014' )->getEuroCents() );
-		$this->assertSame( 101, Euro::newFromString( '1.0149' )->getEuroCents() );
-		$this->assertSame( 102, Euro::newFromString( '1.015' )->getEuroCents() );
-		$this->assertSame( 102, Euro::newFromString( '1.019' )->getEuroCents() );
-		$this->assertSame( 102, Euro::newFromString( '1.0199999' )->getEuroCents() );
-		$this->assertSame( 870, Euro::newFromString( '8.701' )->getEuroCents() );
-		$this->assertSame( 870, Euro::newFromString( '8.70499' )->getEuroCents() );
-		$this->assertSame( 871, Euro::newFromString( '8.705' )->getEuroCents() );
-		$this->assertSame( 871, Euro::newFromString( '8.705000' )->getEuroCents() );
-		$this->assertSame( 871, Euro::newFromString( '8.705001' )->getEuroCents() );
-		$this->assertSame( 871, Euro::newFromString( '8.709999' )->getEuroCents() );
+		$this->assertSame(101, Euro::newFromString('1.0100000001')->getEuroCents());
+		$this->assertSame(101, Euro::newFromString('1.010000009999')->getEuroCents());
+		$this->assertSame(101, Euro::newFromString('1.011')->getEuroCents());
+		$this->assertSame(101, Euro::newFromString('1.014')->getEuroCents());
+		$this->assertSame(101, Euro::newFromString('1.0149')->getEuroCents());
+		$this->assertSame(102, Euro::newFromString('1.015')->getEuroCents());
+		$this->assertSame(102, Euro::newFromString('1.019')->getEuroCents());
+		$this->assertSame(102, Euro::newFromString('1.0199999')->getEuroCents());
+		$this->assertSame(870, Euro::newFromString('8.701')->getEuroCents());
+		$this->assertSame(870, Euro::newFromString('8.70499')->getEuroCents());
+		$this->assertSame(871, Euro::newFromString('8.705')->getEuroCents());
+		$this->assertSame(871, Euro::newFromString('8.705000')->getEuroCents());
+		$this->assertSame(871, Euro::newFromString('8.705001')->getEuroCents());
+		$this->assertSame(871, Euro::newFromString('8.709999')->getEuroCents());
 	}
 
 	public function testGivenNegativeAmountString_exceptionIsThrown() {
-		$this->expectException( \InvalidArgumentException::class );
-		Euro::newFromString( '-1.00' );
+		$this->expectException(\InvalidArgumentException::class);
+		Euro::newFromString('-1.00');
 	}
 
 	public function testGivenStringWithComma_exceptionIsThrown() {
-		$this->expectException( \InvalidArgumentException::class );
-		Euro::newFromString( '1,00' );
+		$this->expectException(\InvalidArgumentException::class);
+		Euro::newFromString('1,00');
 	}
 
 	public function testGivenStringWithMultipleDots_ExceptionIsThrown() {
-		$this->expectException( \InvalidArgumentException::class );
-		Euro::newFromString( '1.0.0' );
+		$this->expectException(\InvalidArgumentException::class);
+		Euro::newFromString('1.0.0');
 	}
 
 	public function testGivenNonNumber_exceptionIsThrown() {
-		$this->expectException( \InvalidArgumentException::class );
-		Euro::newFromString( '1.00abc' );
+		$this->expectException(\InvalidArgumentException::class);
+		Euro::newFromString('1.00abc');
 	}
 
 	public function testGivenNegativeFloatAmount_exceptionIsThrown() {
-		$this->expectException( \InvalidArgumentException::class );
+		$this->expectException(\InvalidArgumentException::class);
 		Euro::newFromFloat( -1.00 );
 	}
 
 	public function testOneEuroFloat_getsTurnedInto100cents() {
-		$this->assertSame( 100, Euro::newFromFloat( 1.0 )->getEuroCents() );
+		$this->assertSame(100, Euro::newFromFloat(1.0)->getEuroCents());
 	}
 
 	public function testOneCentFloat_getsTurnedInto1cent() {
-		$this->assertSame( 1, Euro::newFromFloat( 0.01 )->getEuroCents() );
+		$this->assertSame(1, Euro::newFromFloat(0.01)->getEuroCents());
 	}
 
 	public function testTenCentFloat_getsTurnedInto10cents() {
-		$this->assertSame( 10, Euro::newFromFloat( 0.1 )->getEuroCents() );
+		$this->assertSame(10, Euro::newFromFloat(0.1)->getEuroCents());
 	}
 
 	public function testHandlingOfLargeEuroFloat() {
-		$this->assertSame( 3133742, Euro::newFromFloat( 31337.42 )->getEuroCents() );
+		$this->assertSame(3133742, Euro::newFromFloat(31337.42)->getEuroCents());
 	}
 
 	public function testFloatWithRoundingError_getsRoundedAppropriately() {
-		$this->assertSame( 101, Euro::newFromFloat( 1.0100000001 )->getEuroCents() );
-		$this->assertSame( 101, Euro::newFromFloat( 1.010000009999 )->getEuroCents() );
-		$this->assertSame( 101, Euro::newFromFloat( 1.011 )->getEuroCents() );
-		$this->assertSame( 101, Euro::newFromFloat( 1.014 )->getEuroCents() );
-		$this->assertSame( 101, Euro::newFromFloat( 1.0149 )->getEuroCents() );
-		$this->assertSame( 102, Euro::newFromFloat( 1.015 )->getEuroCents() );
-		$this->assertSame( 102, Euro::newFromFloat( 1.019 )->getEuroCents() );
-		$this->assertSame( 102, Euro::newFromFloat( 1.0199999 )->getEuroCents() );
-		$this->assertSame( 870, Euro::newFromFloat( 8.70 )->getEuroCents() );
+		$this->assertSame(101, Euro::newFromFloat(1.0100000001)->getEuroCents());
+		$this->assertSame(101, Euro::newFromFloat(1.010000009999)->getEuroCents());
+		$this->assertSame(101, Euro::newFromFloat(1.011)->getEuroCents());
+		$this->assertSame(101, Euro::newFromFloat(1.014)->getEuroCents());
+		$this->assertSame(101, Euro::newFromFloat(1.0149)->getEuroCents());
+		$this->assertSame(102, Euro::newFromFloat(1.015)->getEuroCents());
+		$this->assertSame(102, Euro::newFromFloat(1.019)->getEuroCents());
+		$this->assertSame(102, Euro::newFromFloat(1.0199999)->getEuroCents());
+		$this->assertSame(870, Euro::newFromFloat(8.70)->getEuroCents());
 	}
 
 	public function testZeroEuroIntegers_isZeroCents() {
-		$this->assertSame( 0, Euro::newFromInt( 0 )->getEuroCents() );
+		$this->assertSame(0, Euro::newFromInt(0)->getEuroCents());
 	}
 
 	public function testOneEuroIntegers_is100cents() {
-		$this->assertSame( 100, Euro::newFromInt( 1 )->getEuroCents() );
+		$this->assertSame(100, Euro::newFromInt(1)->getEuroCents());
 	}
 
 	public function test1337EuroIntegers_is133700cents() {
-		$this->assertSame( 133700, Euro::newFromInt( 1337 )->getEuroCents() );
+		$this->assertSame(133700, Euro::newFromInt(1337)->getEuroCents());
 	}
 
 	public function testGivenNegativeIntegerAmount_exceptionIsThrown() {
-		$this->expectException( \InvalidArgumentException::class );
+		$this->expectException(\InvalidArgumentException::class);
 		Euro::newFromInt( -1 );
 	}
 
@@ -220,34 +220,34 @@ 
 	 * @dataProvider euroProvider
 	 * @param Euro $euro
 	 */
-	public function testEuroEqualsItself( Euro $euro ) {
-		$this->assertTrue( $euro->equals( clone $euro ) );
+	public function testEuroEqualsItself(Euro $euro) {
+		$this->assertTrue($euro->equals(clone $euro));
 	}
 
 	public function euroProvider() {
 		return [
-			[ Euro::newFromCents( 0 ) ],
-			[ Euro::newFromCents( 1 ) ],
-			[ Euro::newFromCents( 99 ) ],
-			[ Euro::newFromCents( 100 ) ],
-			[ Euro::newFromCents( 9999 ) ],
+			[Euro::newFromCents(0)],
+			[Euro::newFromCents(1)],
+			[Euro::newFromCents(99)],
+			[Euro::newFromCents(100)],
+			[Euro::newFromCents(9999)],
 		];
 	}
 
 	public function testOneCentDoesNotEqualOneEuro() {
-		$this->assertFalse( Euro::newFromCents( 1 )->equals( Euro::newFromInt( 1 ) ) );
+		$this->assertFalse(Euro::newFromCents(1)->equals(Euro::newFromInt(1)));
 	}
 
 	public function testOneCentDoesNotEqualTwoCents() {
-		$this->assertFalse( Euro::newFromCents( 1 )->equals( Euro::newFromCents( 2 ) ) );
+		$this->assertFalse(Euro::newFromCents(1)->equals(Euro::newFromCents(2)));
 	}
 
 	public function testOneCentDoesNotEqualOneEuroAndOneCent() {
-		$this->assertFalse( Euro::newFromCents( 1 )->equals( Euro::newFromCents( 101 ) ) );
+		$this->assertFalse(Euro::newFromCents(1)->equals(Euro::newFromCents(101)));
 	}
 
 	public function test9001centsDoesNotEqual9000cents() {
-		$this->assertFalse( Euro::newFromCents( 9001 )->equals( Euro::newFromCents( 9000 ) ) );
+		$this->assertFalse(Euro::newFromCents(9001)->equals(Euro::newFromCents(9000)));
 	}
 
 }

src/Euro.php

Spacing +28 added lines, -28 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types = 1);
 
 namespace WMDE\Euro;
 
@@ -21,9 +21,9 @@ 
 	 * @param int $cents
 	 * @throws InvalidArgumentException
 	 */
-	private function __construct( int $cents ) {
-		if ( $cents < 0 ) {
-			throw new InvalidArgumentException( 'Amount needs to be positive' );
+	private function __construct(int $cents) {
+		if ($cents < 0) {
+			throw new InvalidArgumentException('Amount needs to be positive');
 		}
 
 		$this->cents = $cents;
@@ -34,8 +34,8 @@ 
 	 * @return self
 	 * @throws InvalidArgumentException
 	 */
-	public static function newFromCents( int $cents ): self {
-		return new self( $cents );
+	public static function newFromCents(int $cents): self {
+		return new self($cents);
 	}
 
 	/**
@@ -49,32 +49,32 @@ 
 	 * @return self
 	 * @throws InvalidArgumentException
 	 */
-	public static function newFromString( string $euroAmount ): self {
-		if ( !is_numeric( $euroAmount ) ) {
-			throw new InvalidArgumentException( 'Not a number' );
+	public static function newFromString(string $euroAmount): self {
+		if (!is_numeric($euroAmount)) {
+			throw new InvalidArgumentException('Not a number');
 		}
 
-		$parts = explode( '.', $euroAmount, 2 );
+		$parts = explode('.', $euroAmount, 2);
 
-		$euros = (int)$parts[0];
-		$cents = self::centsFromString( $parts[1] ?? '0' );
+		$euros = (int) $parts[0];
+		$cents = self::centsFromString($parts[1] ?? '0');
 
-		return new self( $euros * self::$CENTS_PER_EURO + $cents );
+		return new self($euros * self::$CENTS_PER_EURO + $cents);
 	}
 
-	private static function centsFromString( string $cents ): int {
-		if ( strlen( $cents ) > self::$DECIMAL_COUNT ) {
-			return self::roundCentsToInt( $cents );
+	private static function centsFromString(string $cents): int {
+		if (strlen($cents) > self::$DECIMAL_COUNT) {
+			return self::roundCentsToInt($cents);
 		}
 
 		// Turn .1 into .10, so it ends up as 10 cents
-		return (int)str_pad( $cents, self::$DECIMAL_COUNT, '0' );
+		return (int) str_pad($cents, self::$DECIMAL_COUNT, '0');
 	}
 
-	private static function roundCentsToInt( string $cents ): int {
-		$centsInt = (int)substr( $cents, 0, self::$DECIMAL_COUNT );
+	private static function roundCentsToInt(string $cents): int {
+		$centsInt = (int) substr($cents, 0, self::$DECIMAL_COUNT);
 
-		if ( (int)$cents[self::$DECIMAL_COUNT] >= 5 ) {
+		if ((int) $cents[self::$DECIMAL_COUNT] >= 5) {
 			$centsInt++;
 		}
 
@@ -90,13 +90,13 @@ 
 	 * @return self
 	 * @throws InvalidArgumentException
 	 */
-	public static function newFromFloat( float $euroAmount ) {
-		return new self( intval(
+	public static function newFromFloat(float $euroAmount) {
+		return new self(intval(
 			round(
-				round( $euroAmount, self::$DECIMAL_COUNT ) * self::$CENTS_PER_EURO,
+				round($euroAmount, self::$DECIMAL_COUNT) * self::$CENTS_PER_EURO,
 				0
 			)
-		) );
+		));
 	}
 
 	/**
@@ -104,8 +104,8 @@ 
 	 * @return self
 	 * @throws InvalidArgumentException
 	 */
-	public static function newFromInt( int $euroAmount ) {
-		return new self( $euroAmount * self::$CENTS_PER_EURO );
+	public static function newFromInt(int $euroAmount) {
+		return new self($euroAmount * self::$CENTS_PER_EURO);
 	}
 
 	public function getEuroCents(): int {
@@ -120,10 +120,10 @@ 
 	 * Returns the euro amount as string with two decimals always present in format "42.00".
 	 */
 	public function getEuroString(): string {
-		return number_format( $this->getEuroFloat(), self::$DECIMAL_COUNT, '.', '' );
+		return number_format($this->getEuroFloat(), self::$DECIMAL_COUNT, '.', '');
 	}
 
-	public function equals( Euro $euro ): bool {
+	public function equals(Euro $euro): bool {
 		return $this->cents === $euro->cents;
 	}