MontealegreLuis / phuml

src/interfaces/processor/graphviz/style.php

Spacing +4 added lines, -4 removed lines

@@ -2,12 +2,12 @@
 
 abstract class plGraphvizProcessorStyle 
 {
-    public static function factory( $style ) 
+    public static function factory($style) 
     {
-        $classname = 'plGraphvizProcessor' . ucfirst( $style ) . 'Style';
-        if ( class_exists( $classname ) === false ) 
+        $classname = 'plGraphvizProcessor' . ucfirst($style) . 'Style';
+        if (class_exists($classname) === false) 
         {
-            throw new plGraphvizProcessorStyleNotFoundException( $style );
+            throw new plGraphvizProcessorStyleNotFoundException($style);
         }
         return new $classname();
     }

src/interfaces/processor/externalCommand.php

Spacing +10 added lines, -10 removed lines

@@ -3,24 +3,24 @@
 abstract class plExternalCommandProcessor extends plProcessor 
 {
 
-    abstract public function execute( $infile, $outfile, $type );
+    abstract public function execute($infile, $outfile, $type);
 
-    public function process( $input, $type ) 
+    public function process($input, $type) 
     {
         // Create temporary datafiles
-        $infile  = tempnam( '/tmp', 'phuml' );
-        $outfile = tempnam( '/tmp', 'phuml' );
+        $infile  = tempnam('/tmp', 'phuml');
+        $outfile = tempnam('/tmp', 'phuml');
         
-        file_put_contents( $infile, $input );
+        file_put_contents($infile, $input);
 
-        unlink( $outfile );
+        unlink($outfile);
 
-        $this->execute( $infile, $outfile, $type );
+        $this->execute($infile, $outfile, $type);
         
-        $outdata = file_get_contents( $outfile );
+        $outdata = file_get_contents($outfile);
 
-        unlink( $infile );
-        unlink( $outfile );
+        unlink($infile);
+        unlink($outfile);
 
         return $outdata;
     }

src/interfaces/processor.php

Spacing +9 added lines, -9 removed lines

@@ -2,12 +2,12 @@ 
 
 abstract class plProcessor 
 {
-    public static function factory( $processor ) 
+    public static function factory($processor) 
     {
-        $classname = 'pl' . ucfirst( $processor ) . 'Processor';
-        if ( class_exists( $classname ) === false ) 
+        $classname = 'pl' . ucfirst($processor) . 'Processor';
+        if (class_exists($classname) === false) 
         {
-            throw new plProcessorNotFoundException( $processor );
+            throw new plProcessorNotFoundException($processor);
         }
         return new $classname();
     }
@@ -15,9 +15,9 @@ 
     public static function getProcessors() 
     {
         $processors = array();
-        foreach( plBase::getAutoloadClasses() as $autoload ) 
+        foreach (plBase::getAutoloadClasses() as $autoload) 
         {
-            if ( preg_match( '@^pl([A-Z][a-z]*)Processor$@', $autoload, $matches ) ) 
+            if (preg_match('@^pl([A-Z][a-z]*)Processor$@', $autoload, $matches)) 
             {
                 $processors[] = $matches[1];
             }
@@ -25,14 +25,14 @@ 
         return $processors;
     }
 
-    public function writeToDisk( $input, $output ) 
+    public function writeToDisk($input, $output) 
     {
-        file_put_contents( $output, $input );
+        file_put_contents($output, $input);
     }
     
     abstract public function getInputTypes();
     abstract public function getOutputType();
-    abstract public function process( $input, $type );
+    abstract public function process($input, $type);
 
 }
 

src/interfaces/generator.php

Spacing +5 added lines, -5 removed lines

@@ -2,17 +2,17 @@
 
 abstract class plStructureGenerator 
 {
-    public static function factory( $generator ) 
+    public static function factory($generator) 
     {
-        $classname = 'plStructure' . ucfirst( $generator ) . 'Generator';
-        if ( class_exists( $classname ) === false ) 
+        $classname = 'plStructure' . ucfirst($generator) . 'Generator';
+        if (class_exists($classname) === false) 
         {
-            throw new plStructureGeneratorNotFoundException( $generator );
+            throw new plStructureGeneratorNotFoundException($generator);
         }
         return new $classname();
     }
 
-    public abstract function createStructure( array $files );    
+    public abstract function createStructure(array $files);    
 }
 
 ?>

src/config/config.php

Spacing +6 added lines, -6 removed lines

@@ -1,19 +1,19 @@
 <?php
 
-define( "BASEDIR", dirname( __FILE__ ) . '/..' );
+define("BASEDIR", dirname(__FILE__) . '/..');
 
 ini_set(
     'include_path',
-    ini_get( "include_path" ) . PATH_SEPARATOR . BASEDIR
+    ini_get("include_path") . PATH_SEPARATOR . BASEDIR
 );
 
-require_once( 'classes/base.php' );
+require_once('classes/base.php');
 
-plBase::addAutoloadDirectory( dirname( __FILE__ ). '/../autoload' );
+plBase::addAutoloadDirectory(dirname(__FILE__) . '/../autoload');
 
-function __autoload( $classname )
+function __autoload($classname)
 {
-    plBase::autoload( $classname );
+    plBase::autoload($classname);
 }
 
 ?>

src/classes/generator/tokenparser.php

Spacing +89 added lines, -89 removed lines

@@ -39,22 +39,22 @@ 
         $this->lastToken = array();
     }
 
-    public function createStructure( array $files ) 
+    public function createStructure(array $files) 
     {
         $this->initGlobalAttributes();
 
-        foreach( $files as $file ) 
+        foreach ($files as $file) 
         {
             $this->initParserAttributes();
-            $tokens = token_get_all( file_get_contents( $file ) );
+            $tokens = token_get_all(file_get_contents($file));
 
             // Loop through all tokens
-            foreach( $tokens as $token ) 
+            foreach ($tokens as $token) 
             {
                 // Split into Simple and complex token
-                if ( is_array( $token ) !== true ) 
+                if (is_array($token) !== true) 
                 {
-                    switch( $token ) 
+                    switch ($token) 
                     {
                         case ',':
                             $this->comma();
@@ -76,80 +76,80 @@ 
                             $this->lastToken = null;                        
                     }
                 }
-                else if ( is_array( $token ) === true ) 
+                else if (is_array($token) === true) 
                 {
-                    switch ( $token[0] ) 
+                    switch ($token[0]) 
                     {
                         case T_WHITESPACE:
-                            $this->t_whitespace( $token );
+                            $this->t_whitespace($token);
                         break;
 
                         case T_FUNCTION:
-                            $this->t_function( $token );
+                            $this->t_function($token);
                         break;
 
                         case T_VAR:
-                            $this->t_var( $token );
+                            $this->t_var($token);
                         break;
 
                         case T_VARIABLE:
-                            $this->t_variable( $token );
+                            $this->t_variable($token);
                         break;
 
                         case T_ARRAY:
-                            $this->t_array( $token );
+                            $this->t_array($token);
                         break;
 
                         case T_CONSTANT_ENCAPSED_STRING:
-                            $this->t_constant_encapsed_string( $token );
+                            $this->t_constant_encapsed_string($token);
                         break;
 
                         case T_LNUMBER:
-                            $this->t_lnumber( $token );
+                            $this->t_lnumber($token);
                         break;
 
                         case T_DNUMBER:
-                            $this->t_dnumber( $token );
+                            $this->t_dnumber($token);
                         break;
 
                         case T_PAAMAYIM_NEKUDOTAYIM:
-                            $this->t_paamayim_neukudotayim( $token );
+                            $this->t_paamayim_neukudotayim($token);
                         break;
 
                         case T_STRING:
-                            $this->t_string( $token );
+                            $this->t_string($token);
                         break;
 
                         case T_INTERFACE:           
-                            $this->t_interface( $token );
+                            $this->t_interface($token);
                         break;
 
                         case T_CLASS:
-                            $this->t_class( $token );
+                            $this->t_class($token);
                         break;
                         
                         case T_IMPLEMENTS:
-                            $this->t_implements( $token );
+                            $this->t_implements($token);
                         break;
 
                         case T_EXTENDS:
-                            $this->t_extends( $token );
+                            $this->t_extends($token);
                         break;
 
                         case T_PUBLIC:
-                            $this->t_public( $token );
+                            $this->t_public($token);
                         break;
 
                         case T_PROTECTED:
-                            $this->t_protected( $token );
+                            $this->t_protected($token);
                         break;
 
                         case T_PRIVATE:
-                            $this->t_private( $token );
+                            $this->t_private($token);
                         break;
 
                         case T_DOC_COMMENT:
-                            $this->t_doc_comment( $token );
+                            $this->t_doc_comment($token);
                         break;
 
                         default:
@@ -170,7 +170,7 @@ 
         $this->fixObjectConnections();
 
         // Return the class and interface structure
-        return array_merge( $this->classes, $this->interfaces );
+        return array_merge($this->classes, $this->interfaces);
     }
 
     private function comma() 
@@ -186,7 +186,7 @@ 
 
     private function closing_bracket() 
     {
-        switch ( $this->lastToken ) 
+        switch ($this->lastToken) 
         {
             case T_FUNCTION:
                 // The function declaration has been closed
@@ -217,7 +217,7 @@ 
 
     private function equal_sign() 
     {
-        switch ( $this->lastToken ) 
+        switch ($this->lastToken) 
         {
             case T_FUNCTION:
                 // just ignore the equal sign
@@ -227,14 +227,14 @@ 
         }
     }
 
-    private function t_whitespace( $token ) 
+    private function t_whitespace($token) 
     {
         // Ignore whitespaces
     }
 
-    private function t_function( $token ) 
+    private function t_function($token) 
     {
-        switch( $this->lastToken ) 
+        switch ($this->lastToken) 
         {
             case null:
             case T_PUBLIC:
@@ -247,9 +247,9 @@ 
         }
     }
 
-    private function t_var( $token ) 
+    private function t_var($token) 
     {
-        switch ( $this->lastToken ) 
+        switch ($this->lastToken) 
         {
             case T_FUNCTION:
                 // just ignore the T_VAR
@@ -259,9 +259,9 @@ 
         }
     }
 
-    private function t_variable( $token ) 
+    private function t_variable($token) 
     {
-        switch( $this->lastToken ) 
+        switch ($this->lastToken) 
         {
             case T_PUBLIC:
             case T_PROTECTED:
@@ -286,9 +286,9 @@ 
         }
     }
 
-    private function t_array( $token ) 
+    private function t_array($token) 
     {
-        switch ( $this->lastToken ) 
+        switch ($this->lastToken) 
         {
             case T_FUNCTION:
                 // just ignore the T_ARRAY
@@ -298,9 +298,9 @@ 
         }
     }
 
-    private function t_constant_encapsed_string( $token ) 
+    private function t_constant_encapsed_string($token) 
     {
-        switch ( $this->lastToken ) 
+        switch ($this->lastToken) 
         {
             case T_FUNCTION:
                 // just ignore the T_CONSTANT_ENCAPSED_STRING
@@ -310,9 +310,9 @@ 
         }
     }
 
-    private function t_lnumber( $token ) 
+    private function t_lnumber($token) 
     {
-        switch ( $this->lastToken ) 
+        switch ($this->lastToken) 
         {
             case T_FUNCTION:
                 // just ignore the T_LNUMBER
@@ -322,9 +322,9 @@ 
         }
     }
 
-    private function t_dnumber( $token ) 
+    private function t_dnumber($token) 
     {
-        switch ( $this->lastToken ) 
+        switch ($this->lastToken) 
         {
             case T_FUNCTION:
                 // just ignore the T_DNUMBER
@@ -334,9 +334,9 @@ 
         }
     }
 
-    private function t_paamayim_neukudotayim( $token ) 
+    private function t_paamayim_neukudotayim($token) 
     {
-        switch ( $this->lastToken ) 
+        switch ($this->lastToken) 
         {
             case T_FUNCTION:
                 // just ignore the T_PAAMAYIM_NEKUDOTAYIM
@@ -346,9 +346,9 @@ 
         }
     }
 
-    private function t_string( $token ) 
+    private function t_string($token) 
     {
-        switch( $this->lastToken ) 
+        switch ($this->lastToken) 
         {
             case T_IMPLEMENTS:
                 // Add interface to implements array
@@ -365,7 +365,7 @@ 
             case T_FUNCTION:
                 // Add the current function only if there is no function name already
                 // Because if we know the function name already this is a type hint
-                if ( $this->parserStruct['function'] === null ) 
+                if ($this->parserStruct['function'] === null) 
                 {
                     // Function name
                     $this->parserStruct['function'] = $token[1];                           
@@ -393,9 +393,9 @@ 
         }
     }
 
-    private function t_interface( $token )  
+    private function t_interface($token)  
     {
-        switch( $this->lastToken ) 
+        switch ($this->lastToken) 
         {
             case null:
                 // New initial interface token
@@ -412,9 +412,9 @@ 
         }
     }
 
-    private function t_class( $token ) 
+    private function t_class($token) 
     {
-        switch( $this->lastToken ) 
+        switch ($this->lastToken) 
         {
             case null:
                 // New initial interface token
@@ -431,9 +431,9 @@ 
         }
     }
 
-    private function t_implements( $token ) 
+    private function t_implements($token) 
     {
-        switch ( $this->lastToken ) 
+        switch ($this->lastToken) 
         {
             case null:
                 $this->lastToken = $token[0];
@@ -443,9 +443,9 @@ 
         }
     }
 
-    private function t_extends( $token ) 
+    private function t_extends($token) 
     {
-        switch ( $this->lastToken ) 
+        switch ($this->lastToken) 
         {
             case null:
                 $this->lastToken = $token[0];
@@ -455,9 +455,9 @@ 
         }
     }
 
-    private function t_public( $token ) 
+    private function t_public($token) 
     {
-        switch ( $this->lastToken ) 
+        switch ($this->lastToken) 
         {
             case null:
                 $this->lastToken                 = $token[0];
@@ -468,9 +468,9 @@ 
         }
     }
 
-    private function t_protected( $token ) 
+    private function t_protected($token) 
     {
-        switch ( $this->lastToken ) 
+        switch ($this->lastToken) 
         {
             case null:
                 $this->lastToken                 = $token[0];
@@ -481,9 +481,9 @@ 
         }
     }
 
-    private function t_private( $token ) 
+    private function t_private($token) 
     {
-        switch ( $this->lastToken ) 
+        switch ($this->lastToken) 
         {
             case null:
                 $this->lastToken                 = $token[0];
@@ -494,9 +494,9 @@ 
         }
     }
 
-    private function t_doc_comment( $token ) 
+    private function t_doc_comment($token) 
     {
-        switch ( $this->lastToken ) 
+        switch ($this->lastToken) 
         {
             case null:
                 $this->parserStruct['docblock'] = $token[1];
@@ -510,19 +510,19 @@ 
     private function storeClassOrInterface() 
     {
         // First we need to check if we should store interface data found so far
-        if ( $this->parserStruct['interface'] !== null ) 
+        if ($this->parserStruct['interface'] !== null) 
         {
             // Init data storage
             $functions = array();
 
             // Create the data objects
-            foreach( $this->parserStruct['functions'] as $function ) 
+            foreach ($this->parserStruct['functions'] as $function) 
             {
                 // Create the needed parameter objects
                 $params = array();
-                foreach( $function[2] as $param) 
+                foreach ($function[2] as $param) 
                 {
-                    $params[] = new plPhpFunctionParameter( $param[1], $param[0] );
+                    $params[] = new plPhpFunctionParameter($param[1], $param[0]);
                 }
                 $functions[] = new plPhpFunction( 
                     $function[0],
@@ -540,20 +540,20 @@ 
             $this->interfaces[$this->parserStruct['interface']] = $interface;
         }
         // If there is no interface, we maybe need to store a class
-        else if ( $this->parserStruct['class'] !== null ) 
+        else if ($this->parserStruct['class'] !== null) 
         {
             // Init data storage
             $functions  = array();
             $attributes = array();
 
             // Create the data objects
-            foreach( $this->parserStruct['functions'] as $function ) 
+            foreach ($this->parserStruct['functions'] as $function) 
             {
                 // Create the needed parameter objects
                 $params = array();
-                foreach( $function[2] as $param) 
+                foreach ($function[2] as $param) 
                 {
-                    $params[] = new plPhpFunctionParameter( $param[1], $param[0] );
+                    $params[] = new plPhpFunctionParameter($param[1], $param[0]);
                 }
                 $functions[] = new plPhpFunction( 
                     $function[0],
@@ -561,21 +561,21 @@ 
                     $params
                 );                                    
             }
-            foreach ( $this->parserStruct['attributes'] as $attribute ) 
+            foreach ($this->parserStruct['attributes'] as $attribute) 
             {
                 $type = null;
                 // If there is a docblock try to isolate the attribute type
-                if ( $attribute[2] !== null ) 
+                if ($attribute[2] !== null) 
                 {
                     // Regular expression that extracts types in array annotations
                     $regexp = '/^[\s*]*@var\s+array\(\s*(\w+\s*=>\s*)?(\w+)\s*\).*$/m';
-                    if ( preg_match( $regexp, $attribute[2], $matches ) )
+                    if (preg_match($regexp, $attribute[2], $matches))
                     {
                         $type = $matches[2];
                     }
-                    else if ( $return = preg_match( '/^[\s*]*@var\s+(\S+).*$/m', $attribute[2], $matches ) )
+                    else if ($return = preg_match('/^[\s*]*@var\s+(\S+).*$/m', $attribute[2], $matches))
                     {
-                        $type = trim( $matches[1] );
+                        $type = trim($matches[1]);
                     }
                 }
                 $attributes[] = new plPhpAttribute( 
@@ -600,34 +600,34 @@ 
 
     private function fixObjectConnections() 
     {
-        foreach( $this->classes as $class ) 
+        foreach ($this->classes as $class) 
         {
             $implements = array();
-            foreach( $class->implements as $key => $impl ) 
+            foreach ($class->implements as $key => $impl) 
             {
-                $implements[$key] = array_key_exists( $impl, $this->interfaces ) 
+                $implements[$key] = array_key_exists($impl, $this->interfaces) 
                                     ? $this->interfaces[$impl]
-                                    : $this->interfaces[$impl] = new plPhpInterface( $impl );
+                                    : $this->interfaces[$impl] = new plPhpInterface($impl);
             }
             $class->implements = $implements;
 
-            if ( $class->extends === null ) 
+            if ($class->extends === null) 
             {
                 continue;
             }
-            $class->extends = array_key_exists( $class->extends, $this->classes ) 
+            $class->extends = array_key_exists($class->extends, $this->classes) 
                               ? $this->classes[$class->extends] 
-                              : ( $this->classes[$class->extends] = new plPhpClass( $class->extends ) );
+                              : ($this->classes[$class->extends] = new plPhpClass($class->extends));
         }
-        foreach( $this->interfaces as $interface ) 
+        foreach ($this->interfaces as $interface) 
         {           
-            if ( $interface->extends === null ) 
+            if ($interface->extends === null) 
             {
                 continue;
             }
-            $interface->extends = array_key_exists( $interface->extends, $this->interfaces ) 
+            $interface->extends = array_key_exists($interface->extends, $this->interfaces) 
                                  ? $this->interfaces[$interface->extends] 
-                                 : ( $this->interfaces[$interface->extends] = new plPhpInterface( $interface->extends ) );
+                                 : ($this->interfaces[$interface->extends] = new plPhpInterface($interface->extends));
         }
     }
 }

src/classes/phuml.php

Spacing +31 added lines, -31 removed lines

@@ -10,38 +10,38 @@ 
     public function __construct() 
     {
         $this->properties = array( 
-            'generator'     => plStructureGenerator::factory( 'tokenparser' ),
+            'generator'     => plStructureGenerator::factory('tokenparser'),
         );
 
         $this->files = array();
     }
 
-    public function addFile( $file ) 
+    public function addFile($file) 
     {
         $this->files[] = $file;
     }
 
-    public function addDirectory( $directory, $extension = 'php', $recursive = true ) 
+    public function addDirectory($directory, $extension = 'php', $recursive = true) 
     {
-        if ( $recursive === false ) 
+        if ($recursive === false) 
         {
-            $iterator = new DirectoryIterator( $directory );
+            $iterator = new DirectoryIterator($directory);
         }
         else
         {
             $iterator = new RecursiveIteratorIterator(
-                new RecursiveDirectoryIterator( $directory )
+                new RecursiveDirectoryIterator($directory)
             );
         }
 
-        foreach( $iterator as $entry ) 
+        foreach ($iterator as $entry) 
         {
-            if ( $entry->isDir() === true ) 
+            if ($entry->isDir() === true) 
             {
                 continue;
             }
             
-            if ( $sub = strtolower( substr( $entry->getFilename(), -1 * strlen( $extension ) ) ) !== strtolower( $extension ) ) 
+            if ($sub = strtolower(substr($entry->getFilename(), -1 * strlen($extension))) !== strtolower($extension)) 
             {
                 continue;
             }
@@ -50,77 +50,77 @@ 
         }       
     }
 
-    public function addProcessor( $processor ) 
+    public function addProcessor($processor) 
     {
-        if ( count( $this->processors ) === 0 ) 
+        if (count($this->processors) === 0) 
         {
             // First processor must support application/phuml-structure
-            if ( !in_array( 'application/phuml-structure', $processor->getInputTypes() ) ) 
+            if (!in_array('application/phuml-structure', $processor->getInputTypes())) 
             {
-                throw new plPhumlInvalidProcessorChainException( 'application/phuml-structure', $processor->getInputTypes() );
+                throw new plPhumlInvalidProcessorChainException('application/phuml-structure', $processor->getInputTypes());
             }
         }
         else
         {
-            $this->checkProcessorCompatibility( end( $this->processors ), $processor );
+            $this->checkProcessorCompatibility(end($this->processors), $processor);
 
         }
         $this->processors[] = $processor;
     }
 
-    private function checkProcessorCompatibility( $first, $second ) 
+    private function checkProcessorCompatibility($first, $second) 
     {
-        if ( !( $first instanceof plProcessor ) || !( $second instanceof plProcessor ) ) 
+        if (!($first instanceof plProcessor) || !($second instanceof plProcessor)) 
         {
             throw new plPhumlInvalidProcessorException();
         }
 
-        if ( !in_array( $first->getOutputType(), $second->getInputTypes() ) ) 
+        if (!in_array($first->getOutputType(), $second->getInputTypes())) 
         {
-            throw new plPhumlInvalidProcessorChainException( $first->getOutputType(), $second->getInputTypes() );
+            throw new plPhumlInvalidProcessorChainException($first->getOutputType(), $second->getInputTypes());
         }
     }
 
-    public function generate( $outfile ) 
+    public function generate($outfile) 
     {
         echo "[|] Parsing class structure", "\n";
-        $structure = $this->generator->createStructure( $this->files );
+        $structure = $this->generator->createStructure($this->files);
         
-        $temporary = array( $structure, 'application/phuml-structure' );
-        foreach( $this->processors as $processor ) 
+        $temporary = array($structure, 'application/phuml-structure');
+        foreach ($this->processors as $processor) 
         {            
             preg_match( 
                 '@^pl([A-Z][a-z]*)Processor$@',
-                get_class( $processor ),
+                get_class($processor),
                 $matches
             );
 
             echo "[|] Running '" . $matches[1] . "' processor", "\n";
             $temporary = array( 
-                $processor->process( $temporary[0], $temporary[1] ),
+                $processor->process($temporary[0], $temporary[1]),
                 $processor->getOutputType(),
             );
         }
 
         echo "[|] Writing generated data to disk", "\n";
-        end( $this->processors )->writeToDisk( $temporary[0], $outfile );
+        end($this->processors)->writeToDisk($temporary[0], $outfile);
     }
 
 
-    public function __get( $key )
+    public function __get($key)
     {
-        if ( !array_key_exists( $key, $this->properties ) )
+        if (!array_key_exists($key, $this->properties))
         {
-            throw new plBasePropertyException( $key, plBasePropertyException::READ );
+            throw new plBasePropertyException($key, plBasePropertyException::READ);
         }
         return $this->properties[$key];
     }
 
-    public function __set( $key, $val )
+    public function __set($key, $val)
     {
-        if ( !array_key_exists( $key, $this->properties ) )
+        if (!array_key_exists($key, $this->properties))
         {
-            throw new plBasePropertyException( $key, plBasePropertyException::WRITE );
+            throw new plBasePropertyException($key, plBasePropertyException::WRITE);
         }
         $this->properties[$key] = $val;            
     }

src/classes/processor/statistics.php

Spacing +14 added lines, -14 removed lines

@@ -7,7 +7,7 @@ 
 
     public function __construct() 
     {
-        $this->options   = new plProcessorOptions();
+        $this->options = new plProcessorOptions();
         $this->information = array();
     }
 
@@ -23,7 +23,7 @@ 
         return 'text/plain';
     }
 
-    public function process( $input, $type ) 
+    public function process($input, $type) 
     {
         // Initialize the values        
         $this->information['interfaceCount']           = 0;
@@ -39,38 +39,38 @@ 
         $this->information['privateTypedAttributes']   = 0;
 
         // Loop through the classes and interfaces
-        foreach ( $input as $definition ) 
+        foreach ($input as $definition) 
         {
-            if ( $definition instanceof plPhpInterface ) 
+            if ($definition instanceof plPhpInterface) 
             {
                 $this->information['interfaceCount']++;
             }
 
-            if ( $definition instanceof plPhpClass ) 
+            if ($definition instanceof plPhpClass) 
             {
                 $this->information['classCount']++;
 
-                foreach( $definition->attributes as $attribute ) 
+                foreach ($definition->attributes as $attribute) 
                 {
-                    switch ( $attribute->modifier ) 
+                    switch ($attribute->modifier) 
                     {
                         case 'public':
                             $this->information['publicAttributeCount']++;
-                            if ( $attribute->type !== null ) 
+                            if ($attribute->type !== null) 
                             {
                                 $this->information['publicTypedAttributes']++;
                             }
                         break;
                         case 'protected':
                             $this->information['protectedAttributeCount']++;
-                            if ( $attribute->type !== null ) 
+                            if ($attribute->type !== null) 
                             {
                                 $this->information['protectedTypedAttributes']++;
                             }
                         break;
                         case 'private':
                             $this->information['privateAttributeCount']++;
-                            if ( $attribute->type !== null ) 
+                            if ($attribute->type !== null) 
                             {
                                 $this->information['privateTypedAttributes']++;
                             }
@@ -79,9 +79,9 @@ 
                 }
             }
 
-            foreach( $definition->functions as $function ) 
+            foreach ($definition->functions as $function) 
             {
-                switch ( $function->modifier ) 
+                switch ($function->modifier) 
                 {
                     case 'public':
                         $this->information['publicFunctionCount']++;
@@ -99,8 +99,8 @@ 
         $this->information['functionCount']       = $this->information['publicFunctionCount'] + $this->information['protectedFunctionCount'] + $this->information['privateFunctionCount'];
         $this->information['attributeCount']      = $this->information['publicAttributeCount'] + $this->information['protectedAttributeCount'] + $this->information['privateAttributeCount'];
         $this->information['typedAttributeCount'] = $this->information['publicTypedAttributes'] + $this->information['protectedTypedAttributes'] + $this->information['privateTypedAttributes'];
-        $this->information['attributesPerClass']  = round( $this->information['attributeCount'] / $this->information['classCount'], 2 );
-        $this->information['functionsPerClass']   = round( $this->information['functionCount'] / $this->information['classCount'], 2 );
+        $this->information['attributesPerClass']  = round($this->information['attributeCount'] / $this->information['classCount'], 2);
+        $this->information['functionsPerClass']   = round($this->information['functionCount'] / $this->information['classCount'], 2);
         
         // Generate the needed text output
         return <<<END

src/classes/processor/dot.php

Spacing +4 added lines, -4 removed lines

@@ -21,17 +21,17 @@
         return 'image/png';
     }
 
-    public function execute( $infile, $outfile, $type ) 
+    public function execute($infile, $outfile, $type) 
     {
         exec(
-            'dot -Tpng -o ' . escapeshellarg( $outfile ) . ' ' . escapeshellarg( $infile ),
+            'dot -Tpng -o ' . escapeshellarg($outfile) . ' ' . escapeshellarg($infile),
             $output,
             $return
         );
 
-        if ( $return !== 0 ) 
+        if ($return !== 0) 
         {
-            throw new plProcessorExternalExecutionException( $output );
+            throw new plProcessorExternalExecutionException($output);
         }
     }
 }