CodeToDiagram.class.php

Go to the documentation of this file.

<?php
class CodeToDiagram
{
        protected $arrFiles = array();

        protected $booStart = false;

        protected $strFileFrom = null;

        protected $strFileName = "diagram.html";

        protected $strOutputType = self::OUTPUT_TYPE_SCREEN;

        protected $strPrinterType = self::PRINTER_TYPE_HTML;

    protected $objPrinter;

        protected $strCallerPath;

        protected $strPublicPath;
        
        protected $booExternalAccess = false;
        protected static $objInstance;

        const RUN_IN_FILES = false;

        const REMOVE_FILES = true;

        const CODE_TO_DIAGRAM_CLASS_PREFIX = "CTD";

        const OUTPUT_TYPE_STRING = "string";

        const OUTPUT_TYPE_FILE = "file";

        const OUTPUT_TYPE_SCREEN = "screen";

        const PRINTER_TYPE_XML = "xml";

        const PRINTER_TYPE_HTML = "html";

    const MSG_NO_WRITE_PERMISSION = " The user of the system does not have permission to write the code to diagram files. Change the RUN_IN_FILES to false and save your files into a allowed folder.";

    protected static $arrDefaultStereotypes = array( 'user' , 'system' , 'user' , 'entity' , 'controller' , 'boundary' , 'database');

    public function __construct()
    {
        $this->loadDefaultsStereotypes();
        $this->setPrinterType( $this->getPrinterType() );
    }

    protected function loadDefaultsStereotypes()
    {
        foreach( self::$arrDefaultStereotypes as $strDefaultStereotype )
        {
            $objStereotype = new UmlSequenceDiagramStereotype();
            $objStereotype->setName( $strDefaultStereotype  )->setDefault( true );
            UmlSequenceDiagramStereotype::addStereotype( $objStereotype );
        }

    }

        public function getConfiguration()
        {
                return CodeInstrumentationReceiver::getInstance()->getConfiguration();
        }

    public function setPrinter( UmlSequenceDiagramPrinterInterface $objPrinter )
    {
        $this->objPrinter = $objPrinter;
        return $this;
    }

    public function getPrinter()
    {
        return $this->objPrinter;
    }

    public function setPrinterConfiguration( UmlSequenceDiagramPrinterConfigurationInterface $objPrinterConfiguration )
    {
        if( get_class( $objPrinterConfiguration ) != get_class( $this->getPrinterConfiguration() ) )
        {
            throw new CodeToDiagramException( "Invalid Printer Configuration" );
        }
        $this->getPrinter()->setConfiguration( $objPrinterConfiguration );
        return $this;
    }

    public function getPrinterConfiguration()
    {
        return $this->getPrinter()->getConfiguration();
    }

        public function setOutputType( $strType )
        {
                switch( $strType )
                {
                        case CodeToDiagram::OUTPUT_TYPE_SCREEN:
                        case CodeToDiagram::OUTPUT_TYPE_STRING:
                        case CodeToDiagram::OUTPUT_TYPE_FILE :
                        {
                                $this->strOutputType = $strType;
                                break;
                        }
                        default:
                        {
                                throw new CodeToDiagramException( "Invalid output type. ('" . $strType . "')" );
                                break;
                        }
                }
                return $this;
        }

        public function getOutputType()
        {
                return $this->strOutputType;
        }

        public function setPrinterType( $strType )
        {
                switch( $strType )
                {
                        case CodeToDiagram::PRINTER_TYPE_HTML:
            {
                $this->setPrinter( UmlSequenceDiagramPrinterToHtml::getInstance() );
                                $this->strPrinterType = $strType;
                                break;
            }
                        case CodeToDiagram::PRINTER_TYPE_XML:
                        {
                $this->setPrinter( UmlSequenceDiagramPrinterToXml::getInstance() );
                                $this->strPrinterType = $strType;
                                break;
                        }
                        default:
                        {
                                throw new CodeToDiagramException( "Invalid printer type. ('" . $strType . "')" );
                                break;
                        }
                }
                return $this;
        }

        public function getPrinterType()
        {
                return $this->strPrinterType;
        }

        public function setExternalAcess( $booExternalAccess )
        {
                $this->booExternalAccess = (boolean)$booExternalAccess;
                return $this;
        }

        public function getExternalAcess()
        {
                return $this->booExternalAccess;
        }

        public static function hasInstance()
        {
                return ( self::$objInstance !== null );
        }

        public static function getInstance()
        {
                if( self::$objInstance === null )
                {
                        self::$objInstance = new CodeToDiagram();
                }
                return self::$objInstance;
        }

        public function setStarted( $booStarted )
        {
                $this->booStart = $booStarted;
                return $this;
        }

        public function getStarted()
        {
                return $this->booStart;
        }

        public function setFileFrom( $strFileFrom )
        {
                $this->strFileFrom = $strFileFrom;
                return $this;
        }

        public function getFileFrom()
        {
                return $this->strFileFrom;
        }

        public function setFileName( $strFileName )
        {
                $this->strFileName = $strFileName;
                return $this;
        }

        public function getFileName()
        {
                return $this->strFileName;
        }
        
        public function setCallerPath( $strCallerPath )
        {
                $this->strCallerPath = $strCallerPath;
                return $this;
        }
        
        public function getCallerPath()
        {
                return $this->strCallerPath;
        }
        
        public function setPublicPath( $strPublicPath )
        {
                $this->strPublicPath = $strPublicPath;
                return $this;
        }
        
        public function getPublicPath()
        {
                return $this->strPublicPath;    
        }
        
        public function start()
        {
                ob_start();
                if( $this->getStarted() )
                {
                        return $this;
                }
                else
                {
                        CodeInstrumentationReceiver::getInstance()->restart();
                        $this->CodeToDiagramRequireOnce($this->getFileFrom() , $this->getFileFrom() );
                        exit();

                        // just to safety //
                        return $this;
                }
        }

        public function restart()
        {
                CodeInstrumentationReceiver::getInstance()->restart();
                return $this;
        }

    private function checkPermissionToWrite( $strFileName )
    {
        $strPath = CorujaFileManipulation::getPathOfFile( $strFileName );

        if( $strPath == "" )
        {
            $strPath = $this->getPublicPath();
        }

        if( file_exists( $strFileName ) )
        {
            if( !is_writable( $strFileName ) )
            {
                throw new CodeToDiagramException( 1 .  self::MSG_NO_WRITE_PERMISSION );
            }
            return TRUE;
        }

        if( is_dir( $strPath ) )
        {
            return true;
        }

        if( !mkdir( $strPath , 0777, TRUE ) )
        {
                throw new CodeToDiagramException(3 . self::MSG_NO_WRITE_PERMISSION );
        }
        return TRUE;
    }

        public function save()
        {
                $strReturn = "";
                $strDiagram = "";
                
                if( $this->getStarted() )
                {
            $strContent = ob_get_contents();
            ob_end_clean();
                        $objUmlSequenceDiagram = CodeInstrumentationReceiver::getInstance()->getUmlSequenceDiagram();
            $objUmlSequenceDiagram->setOutput( $strContent );

                        switch( $this->getPrinterType() )
                        {
                                case self::PRINTER_TYPE_HTML:
                                {
                                        $objPrinter = UmlSequenceDiagramPrinterToHtml::getInstance();
                    UmlSequenceDiagramPrinterToHtml::getInstance()->getConfiguration()->setPublicPath( $this->getPublicPath() );
                                        UmlSequenceDiagramPrinterToHtml::getInstance()->getConfiguration()->setCallerPath( $this->getCallerPath() );
                                        UmlSequenceDiagramPrinterToHtml::getInstance()->getConfiguration()->setExternalAccess( $this->getExternalAcess() );
                                        $strDiagram = UmlSequenceDiagramPrinterToHtml::getInstance()->perform( $objUmlSequenceDiagram );
                                        break;
                                }
                                case self::PRINTER_TYPE_XML:
                                {
                                        $objPrinter = UmlSequenceDiagramPrinterToXml::getInstance();
                                        $strDiagram = UmlSequenceDiagramPrinterToXml::getInstance()->perform( $objUmlSequenceDiagram );
                                        break;
                                }
                                default:
                                {
                                        throw new CodeToDiagramException( "Invalid printer type ({$this->getPrinterType()})" );
                                        break;
                                }
                        }
                        switch( $this->getOutputType() )
                        {
                                case self::OUTPUT_TYPE_SCREEN:
                                {
                                        $objPrinter->getHeader();
                                        print $strDiagram;
                                        break;
                                }
                                case self::OUTPUT_TYPE_STRING:
                                {
                                        $strReturn = $strDiagram;
                                        break;
                                }
                                case self::OUTPUT_TYPE_FILE:
                                {
                    $this->checkPermissionToWrite( $this->getFileName() );
                                        file_put_contents( $this->getFileName() , $strDiagram );
                                        $strReturn = $strDiagram;
                                        break;
                                }
                                default:
                                {
                                        throw new CodeToDiagramException( "Invalid output type ({$this->getOutputType()})" );
                                        break;
                                }
                        }
                        CodeInstrumentationReceiver::getInstance()->restart();
                }
                return $strReturn;
        }

        public function  __destruct() {

                $this->save();
        }

        public static function init( $strFile )
        {
                if( self::getInstance()->getStarted() == false )
                {
                        self::getInstance()->setFileFrom( $strFile );
                }
                return self::getInstance();
        }

        protected function fixFileName( $strFileFrom, $strFile )
        {
                $strFileFrom = str_replace( '/', '\\', $strFileFrom );
                $strFile = str_replace( '/', '\\', $strFile );
                $strFilePath = substr( $strFileFrom ,  0 , -(strlen(basename($strFileFrom ) ) ) );
                $strFile = $strFilePath . $strFile;

                return $strFile;
        }

        public function addFile( $strFileFrom, $strFile )
        {
                $strFile = $this->fixFileName( $strFileFrom, $strFile );

                $this->arrFiles[] = $strFile;

                return $this;
        }

        protected function hasFile( $strFileFrom , $strFile )
        {
                return in_array( $strFile ,  $this->arrFiles );
        }

        public function CodeToDiagramRequireOnce( $strFileFrom, $strFile )
        {               
                $arrCodeToDiagramBackTrace = debug_backtrace();

                if( !$this->hasFile( $strFileFrom , $strFile ) )
                {
                        $this->CodeToDiagramRequire( $strFileFrom, $strFile );
                }
                return $this;
        }

        public function CodeToDiagramIncludeOnce( $strFileFrom, $strFile )
        {
                if( !$this->hasFile( $strFileFrom , $strFile ) )
                {
                        $this->CodeToDiagramIncludeOnce( $strFileFrom , $strFile );
                }
                return $this;
        }

        public function CodeToDiagramRequire( $strFileFrom, $strFile )
        {
                $this->loadFile( $strFileFrom , $strFile );
                return $this;
        }

        public function CodeToDiagramInclude( $strFileFrom, $strFile )
        {
                $this->loadFile( $strFileFrom , $strFile );
                return $this;
        }

        public function CodeToDiagramExit( $strFileFrom = '', $strMessage = '')
        {
                print "Exit called into $strFileFrom ($strMessage ) ";
        }

        protected function convertFileContent( $strContentFile , $strFile , $strFullFile )
        {
                if( self::getInstance()->getStarted() == false )
                {
                        self::getInstance()->setStarted( true );
                        $strContentFile = preg_replace('/require_once/', '//require_once', $strContentFile, 1);
                }

                $strContentFile = str_replace(
                        Array(
                                'require_once(' ,
                                'require(' ,
                                'include(' ,
                                'include_once(',
                                'exit()',
                                'exit(',
                                '__FILE__',
                        ),
                        Array(
                                'CodeToDiagram::getInstance()->CodeToDiagramRequireOnce("'. $strFile . '",' ,
                                'CodeToDiagram::getInstance()->CodeToDiagramRequire("'. $strFile . '",' ,
                                'CodeToDiagram::getInstance()->CodeToDiagramInclude("'. $strFile . '",' ,
                                'CodeToDiagram::getInstance()->CodeToDiagramIncludeOnce("'. $strFile . '",',
                                'CodeToDiagram::getInstance()->CodeToDiagramExit("'. $strFile . '")',
                                'CodeToDiagram::getInstance()->CodeToDiagramExit("'. $strFile . '",',
                                '"' . $this->getCallerPath() . $strFullFile . '"',
                        ),
                        $strContentFile
                );

                return $strContentFile;
        }

        public function codeInstrumentationLine( $strLine, $strTextSearch )
        {
                $arrResult = array();

                if(  substr( strtolower( trim( $strLine ) ) , 0 , strlen( $strTextSearch ) ) == $strTextSearch )
                {
                        $strLine = trim( $strLine );
                        $strBefore = substr( $strLine , 0 , strlen( $strTextSearch ) );
                        $strAfter = substr( $strLine , strlen( $strTextSearch ) );
                        $arrWords = explode( " " , $strAfter );

                        $strOldClassName = $arrWords[0];
                        $strNewClassName = self::CODE_TO_DIAGRAM_CLASS_PREFIX . $strOldClassName;

                        $arrWords[0] = $strNewClassName;
                        $strAfter = implode( " " , $arrWords );
                        $strLine = $strBefore . $strAfter;

                        $arrResult[ "line" ] = $strLine;
                        $arrResult[ "class_old" ] = $strOldClassName;
                        $arrResult[ "class_new" ] = $strNewClassName;

                }
                return $arrResult;
        }

        protected function codeInstrumentationClass( $strTextSearch, array &$arrOldClasses , array &$arrNewClasses , array &$arrLines )
        {
                foreach( $arrLines as $intLine => $strLine )
                {
                        $arrResult = $this->codeInstrumentationLine( $strLine , $strTextSearch  );

                        if( sizeof( $arrResult ) !== 0 )
                        {
                                $arrOldClasses[] = $arrResult[ "class_old" ];
                                $arrNewClasses[] = $arrResult[ "class_new" ];
                                $arrLines[ $intLine ] = $arrResult[ "line" ];
                        }
                }
        }

        protected function preloadFile( $strFileName , $strContentFile )
        {
                if( self::RUN_IN_FILES )
                {
                        $strFileName = $strFileName . "(0).phps";
            print $strFileName;
            $this->checkPermissionToWrite( $strFileName );
                        file_put_contents( $strFileName , $strContentFile );
                        require_once( $strFileName );
                        if( self::REMOVE_FILES )
                        {
                                unlink( $strFileName );
                        }
                }
                else
                {
                        eval( '?' . '>' . $strContentFile );
                }
                return $this;
        }
        
        protected function codeInstrumentationFile( $strFileName , $strContentFile )
        {
                $arrLines = explode( "\n"  , $strContentFile );
                $arrOldClasses  = array();
                $arrNewClasses  = array();
                $arrOldInterface = array();
                $arrNewInterface = array();

                $this->codeInstrumentationClass( "class " , $arrOldClasses , $arrNewClasses, $arrLines );
                $this->codeInstrumentationClass( "interface " , $arrOldInterface , $arrNewInterface, $arrLines );

                $strContentFile = implode( "\n" , $arrLines );

                $this->preloadFile( $strFileName , $strContentFile );

                foreach( $arrNewClasses as $intKey => $strNewClassName )
                {
                        $oReflectionCode = new CodeInstrumentationClass( $strNewClassName , $strContentFile );
                        $oReflectionCode->setClassName( $arrOldClasses[ $intKey ] );
                        $strNewCode = $oReflectionCode->getCode();
                        if( self::RUN_IN_FILES )
                        {
                                $strFileName = trim( $strNewClassName ) . "(1).phps";
                $this->checkPermissionToWrite( $strFileName );
                file_put_contents( $strFileName , '<?' . 'php ' .  $strNewCode );
                                require_once( $strFileName );
                                if( self::REMOVE_FILES )
                                {
                                        unlink( $strFileName );
                                }
                        }
                        else
                        {
                                eval( $strNewCode );
                        }
                }
                foreach( $arrNewInterface as $intKey => $strNewInterfaceName )
                {
                        $strOldInterface = $arrOldInterface[ $intKey ];
                        $strNewCode = "interface $strOldInterface {} ";
                        if( self::RUN_IN_FILES )
                        {
                                $strFileName = trim( $strNewInterfaceName ) . "(1).phps";
                $this->checkPermissionToWrite( $strFileName );
                                file_put_contents( $strFileName , '<?' . 'php ' .  $strNewCode );
                                require_once( $strFileName );
                                if( self::REMOVE_FILES )
                                {
                                        unlink( $strFileName );
                                }
                        }
                        else
                        {
                                eval( $strNewCode );
                        }
                }
        }

        protected function loadFile( $strFileFrom, $strFile )
        {
                if( basename( $strFile ) == 'CodeToDiagram.class.php' )
                {
                        return $this;
                }
                $this->addFile( $strFileFrom, $strFile );

                if( CorujaFileManipulation::isRelativePath( $strFile ) )
                {
                        $strFullFile = $this->fixFileName( $strFileFrom, $strFile );
                }
                else
                {
                        $strFullFile = $strFile;
                }

                if( ! file_exists( $strFullFile ) )
                {
                        throw new CodeToDiagramException( "Unable to find file: " . $strFullFile );
                }

                $strContentFile = file_get_contents( $strFullFile );
                $strContentFile = $this->convertFileContent( $strContentFile , $strFile , $strFullFile );
                $this->codeInstrumentationFile( $strFile, $strContentFile );
                
                return $this;
        }

        public function setCallerPathByFile( $strCallerFile )
        {
                $this->setCallerPath( CorujaFileManipulation::getPathOfFile( $strCallerFile ) );
        }

        public function addNote( $strNoteContent , $booAfter = true )
        {
            $objNote = new UmlSequenceDiagramNote();
            $objNote->setContent( $strNoteContent );
            $objMessage = CodeInstrumentationReceiver::getInstance()->getActualMessage();
            $objActor =  CodeInstrumentationReceiver::getInstance()->getActualActor();
            $objNote->setActor( $objActor );
            
            if( $booAfter )
            {
                $objMessage->addNoteAfter($objNote);
            }
            else
            {
                $objMessage->addNoteBefore( $objNote );
            }
            return $objNote;
        }

        public function __call( $strMethod , $arrArguments )
        {
            throw new CodeToDiagramException( "unknow method " . $strMethod . " in " . get_class( $this ) );
        }
}

?>