Carteni / crypto-bundle

Tests/KeyManagerWrapperTest.php

Indentation +21 added lines, -21 removed lines

@@ -36,7 +36,7 @@ 
     protected function setUp()
     {
         $this->keyManager = $this->getMockBuilder('\Mes\Security\CryptoBundle\KeyManagerInterface')
-                                 ->getMock();
+                                    ->getMock();
         $this->wrapper = new KeyManagerWrapper($this->keyManager);
     }
 
@@ -48,9 +48,9 @@ 
     public function testGenerateCreatesKey()
     {
         $this->keyManager->expects($this->once())
-                         ->method('generate')
-                         ->with(null)
-                         ->will($this->returnValue($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')->getMock()));
+                            ->method('generate')
+                            ->with(null)
+                            ->will($this->returnValue($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')->getMock()));
 
         $key = $this->wrapper->generate();
 
@@ -64,9 +64,9 @@ 
     {
         try {
             $this->keyManager->expects($this->once())
-                             ->method('generate')
-                             ->with(null)
-                             ->will($this->throwException(new EnvironmentIsBrokenException()));
+                                ->method('generate')
+                                ->with(null)
+                                ->will($this->throwException(new EnvironmentIsBrokenException()));
         } catch (EnvironmentIsBrokenException $ex) {
             $this->throwException(new CryptoException());
         }
@@ -80,9 +80,9 @@ 
         $secret = 'ThisIsASecretPassword';
 
         $this->keyManager->expects($this->once())
-                         ->method('generateFromAscii')
-                         ->with($key_encoded, $secret)
-                         ->will($this->returnValue($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')->getMock()));
+                            ->method('generateFromAscii')
+                            ->with($key_encoded, $secret)
+                            ->will($this->returnValue($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')->getMock()));
 
         $key = $this->wrapper->generateFromAscii($key_encoded, $secret);
 
@@ -99,9 +99,9 @@ 
 
         try {
             $this->keyManager->expects($this->once())
-                             ->method('generateFromAscii')
-                             ->with($key_encoded, $secret)
-                             ->will($this->throwException(new BaseCryptoException()));
+                                ->method('generateFromAscii')
+                                ->with($key_encoded, $secret)
+                                ->will($this->throwException(new BaseCryptoException()));
         } catch (CryptoException $ex) {
             $this->throwException(new CryptoException());
         }
@@ -112,8 +112,8 @@ 
     public function testGetKeyReadsKey()
     {
         $this->keyManager->expects($this->once())
-                         ->method('getKey')
-                         ->will($this->returnValue($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')->getMock()));
+                            ->method('getKey')
+                            ->will($this->returnValue($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')->getMock()));
 
         $key = $this->wrapper->getKey();
 
@@ -123,8 +123,8 @@ 
     public function testSetKeyStoresKey()
     {
         $this->keyManager->expects($this->once())
-                         ->method('setKey')
-                         ->with($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')->getMock());
+                            ->method('setKey')
+                            ->with($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')->getMock());
 
         $this->wrapper->setKey($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')->getMock());
     }
@@ -132,8 +132,8 @@ 
     public function testSetSecretStoresSecret()
     {
         $this->keyManager->expects($this->once())
-                         ->method('setSecret')
-                         ->with('ThisIsASecret');
+                            ->method('setSecret')
+                            ->with('ThisIsASecret');
 
         $this->wrapper->setSecret('ThisIsASecret');
     }
@@ -141,8 +141,8 @@ 
     public function testGetSecretReadsSecret()
     {
         $this->keyManager->expects($this->once())
-                         ->method('getSecret')
-                         ->will($this->returnValue('ThisIsYourSecret'));
+                            ->method('getSecret')
+                            ->will($this->returnValue('ThisIsYourSecret'));
 
         $secret = $this->wrapper->getSecret();
 

DependencyInjection/MesCryptoExtension.php

Indentation +24 added lines, -24 removed lines

@@ -86,21 +86,21 @@ 
 
                 // Sets the loader resource.
                 $container->findDefinition($id)
-                          ->addMethodCall('setResource', array($attribute['resource']));
+                            ->addMethodCall('setResource', array($attribute['resource']));
 
                 // Load secret from loader.
                 $container->getDefinition('mes_crypto.key_manager_wrapper')
-                          ->setMethodCalls(array())
-                          ->addMethodCall('setSecret', array($this->loadSecret));
+                            ->setMethodCalls(array())
+                            ->addMethodCall('setSecret', array($this->loadSecret));
 
                 // Sets Defuse KeyProtectedByPassword.
                 $container->findDefinition('mes_crypto.raw_key')
-                          ->setClass('Defuse\Crypto\KeyProtectedByPassword')
-                          ->setArguments(array($this->loadKey))
-                          ->setFactory(array(
-                              'Defuse\Crypto\KeyProtectedByPassword',
-                              'loadFromAsciiSafeString',
-                          ));
+                            ->setClass('Defuse\Crypto\KeyProtectedByPassword')
+                            ->setArguments(array($this->loadKey))
+                            ->setFactory(array(
+                                'Defuse\Crypto\KeyProtectedByPassword',
+                                'loadFromAsciiSafeString',
+                            ));
 
                 // Sets the key
                 $this->createKeyDefinition($container, $this->loadSecret);
@@ -194,23 +194,23 @@ 
 
             // Reads encoded key from configuration file if key is not external.
             $rawKeyDefinition->setClass($defuseKey)
-                             ->setFactory(array(
-                                 $defuseKey,
-                                 'loadFromAsciiSafeString',
-                             ));
+                                ->setFactory(array(
+                                    $defuseKey,
+                                    'loadFromAsciiSafeString',
+                                ));
             $rawKeyDefinition->setArguments(array(
                 $keyIsExternal ? $this->loadKey : $key,
             ));
         } else {
             $rawKeyDefinition->setClass($defuseKey)
-                             ->setArguments($secretExists ? array($secretIsExternal ? $this->loadSecret : $secret) : array())
-                             ->setFactory($secretExists ? array(
-                                 'Defuse\Crypto\KeyProtectedByPassword',
-                                 'createRandomPasswordProtectedKey',
-                             ) : array(
-                                 'Defuse\Crypto\Key',
-                                 'createNewRandomKey',
-                             ));
+                                ->setArguments($secretExists ? array($secretIsExternal ? $this->loadSecret : $secret) : array())
+                                ->setFactory($secretExists ? array(
+                                    'Defuse\Crypto\KeyProtectedByPassword',
+                                    'createRandomPasswordProtectedKey',
+                                ) : array(
+                                    'Defuse\Crypto\Key',
+                                    'createNewRandomKey',
+                                ));
         }
 
         if (($createRandomKey || (!$createRandomKey && !$keyIsExternal)) && !$this->loaderEnabled) {
@@ -218,7 +218,7 @@ 
         }
 
         $container->setDefinition('mes_crypto.raw_key', $rawKeyDefinition)
-                  ->setPublic(false);
+                    ->setPublic(false);
 
         // Key
         $this->createKeyDefinition($container, $secretExists ? ($secretIsExternal ? $this->loadSecret : $secret) : null);
@@ -246,7 +246,7 @@ 
             'Mes\Security\CryptoBundle\Model\Key',
             'create',
         ))
-                      ->setPublic(false);
+                        ->setPublic(false);
 
         $container->setDefinition('mes_crypto.key', $keyDefinition);
     }
@@ -271,6 +271,6 @@ 
     private function setCryptoLoaderResource(ContainerBuilder $container, $resource)
     {
         $container->findDefinition('mes_crypto.loader')
-                  ->addMethodCall('setResource', array($resource));
+                    ->addMethodCall('setResource', array($resource));
     }
 }

Tests/DependencyInjection/MesCryptoExtensionTest.php

Indentation +5 added lines, -5 removed lines

@@ -42,7 +42,7 @@ 
 
         $this->assertHasDefinition('mes_crypto.raw_key');
         $this->assertSame('Defuse\Crypto\Key', $this->configuration->findDefinition('mes_crypto.raw_key')
-                                                                   ->getClass(), 'Defuse\Crypto\Key class is correct');
+                                                                    ->getClass(), 'Defuse\Crypto\Key class is correct');
 
         $this->assertNotHasDefinition('mes_crypto.loader');
     }
@@ -55,7 +55,7 @@ 
 
         $this->assertHasDefinition('mes_crypto.raw_key');
         $this->assertSame('Defuse\Crypto\KeyProtectedByPassword', $this->configuration->findDefinition('mes_crypto.raw_key')
-                                                                                      ->getClass(), 'KeyProtectedByPassword class is correct');
+                                                                                        ->getClass(), 'KeyProtectedByPassword class is correct');
 
         $this->assertNotHasDefinition('mes_crypto.loader');
     }
@@ -68,7 +68,7 @@ 
 
         $this->assertHasDefinition('mes_crypto.raw_key');
         $this->assertSame('Defuse\Crypto\KeyProtectedByPassword', $this->configuration->findDefinition('mes_crypto.raw_key')
-                                                                                      ->getClass(), 'Defuse\Crypto\KeyProtectedByPassword class is correct');
+                                                                                        ->getClass(), 'Defuse\Crypto\KeyProtectedByPassword class is correct');
         $this->assertNotHasDefinition('mes_crypto.loader');
     }
 
@@ -80,7 +80,7 @@ 
 
         $this->assertHasDefinition('mes_crypto.raw_key');
         $this->assertSame('Defuse\Crypto\KeyProtectedByPassword', $this->configuration->findDefinition('mes_crypto.raw_key')
-                                                                                      ->getClass(), 'Defuse\Crypto\KeyProtectedByPassword class is correct');
+                                                                                        ->getClass(), 'Defuse\Crypto\KeyProtectedByPassword class is correct');
         $this->assertHasDefinition('mes_crypto.loader');
     }
 
@@ -92,7 +92,7 @@ 
 
         $this->assertHasDefinition('mes_crypto.raw_key');
         $this->assertSame('Defuse\Crypto\KeyProtectedByPassword', $this->configuration->findDefinition('mes_crypto.raw_key')
-                                                                                      ->getClass(), 'Defuse\Crypto\KeyProtectedByPassword class is correct');
+                                                                                        ->getClass(), 'Defuse\Crypto\KeyProtectedByPassword class is correct');
         $this->assertHasDefinition('mes_crypto.loader');
 
         $this->assertSame('custom_key_storage_service', (string) $this->configuration->getAlias('mes_crypto.key_storage'), 'custom_key_storage_service is correct alias');

Command/KeyGeneratorCommand.php

Indentation +7 added lines, -7 removed lines

@@ -63,7 +63,7 @@ 
         parent::initialize($input, $output);
 
         $this->helper = $this->getHelperSet()
-                             ->get('question');
+                                ->get('question');
 
         $this->symfonyStyle = $this->getStyle($input, $output);
     }
@@ -74,9 +74,9 @@ 
     protected function configure()
     {
         $this->setName('mes:crypto:generate-key')
-             ->setDefinition($this->createDefinition())
-             ->setDescription('Generates an encoded key with or without authentication secret')
-             ->setHelp(<<<'EOF'
+                ->setDefinition($this->createDefinition())
+                ->setDescription('Generates an encoded key with or without authentication secret')
+                ->setHelp(<<<'EOF'
 The <info>%command.name%</info> generates an encoded key with or without authentication secret and optionally it saves the printable key and the secret in a ini format .crypto file.
 
 <info>%command.full_name%</info>
@@ -85,7 +85,7 @@ 
 
 <info>%command.full_name%</info> --dir /path/to/dir/key.crypto
 EOF
-             );
+                );
     }
 
     /**
@@ -165,7 +165,7 @@ 
         $this->writeSection($output, 'Generating key'.($secret ? ' with authentication secret' : '').($dir ? " in $dir" : ''));
 
         $encodedKey = $keyGenerator->generate($secret)
-                                   ->getEncoded();
+                                    ->getEncoded();
 
         $this->log($logger, "The encoded key has been generated with the following sequence:\n{$encodedKey}\n", LogLevel::INFO);
 
@@ -225,7 +225,7 @@ 
 
             /** @var DebugFormatterHelper */
             $dh = $this->getHelperSet()
-                       ->get('debug_formatter');
+                        ->get('debug_formatter');
 
             $process = new Process("ls -la {$options['dir']} | grep \".crypto\"");
 

Spacing +2 added lines, -2 removed lines

@@ -104,7 +104,7 @@ 
             $random = $this->generator->generateRandomSecret();
             $this->symfonyStyle->newLine();
             $question = new Question($this->getQuestion('Insert your authentication secret or use this one randomly generated', $random), $random);
-            $question->setValidator(function ($secret) {
+            $question->setValidator(function($secret) {
                 if (!ctype_print($secret)) {
                     throw new \RuntimeException(sprintf('The authentication secret is not printable', $secret));
                 }
@@ -234,7 +234,7 @@ 
                 $dh->start(spl_object_hash($process), "Find {$options['dir']}", 'START'),
             ));
 
-            $process->run(function ($type, $buffer) use ($process, $output, $dh) {
+            $process->run(function($type, $buffer) use ($process, $output, $dh) {
                 $output->writeln($dh->progress(spl_object_hash($process), $buffer, Process::ERR === $type));
             });