Ejemplo n.º 1
0
 protected function ProcessFolder($strFolder)
 {
     $strLabel = substr($strFolder, strlen($this->strRoot) + 1);
     if (!$strLabel) {
         $strLabel = 'root';
     }
     print 'Processing ' . $strLabel . ' [';
     $strFileArray = array();
     $strFolderArray = array();
     // Iterate through all subfolders and files in this folder
     // Be sure not to process anything with CVS, SVN or ds_store
     $objDirectory = opendir($strFolder);
     while ($strName = readdir($objDirectory)) {
         if ($strName != '.' && $strName != '..' && $strName != 'SVN' && $strName != '.svnignore' && $strName != 'CVS' && $strName != '.cvsignore' && strtolower($strName) != '.ds_store') {
             $strFullPath = $strFolder . '/' . $strName;
             if (is_dir($strFullPath)) {
                 array_push($strFolderArray, $strFullPath);
             } else {
                 array_push($strFileArray, $strFullPath);
             }
         }
     }
     $intFileCount = count($strFileArray);
     for ($intFileIndex = 0; $intFileIndex < $intFileCount; $intFileIndex++) {
         print ' ';
     }
     print ']';
     for ($intFileIndex = 0; $intFileIndex <= $intFileCount; $intFileIndex++) {
         print chr(8);
     }
     foreach ($strFileArray as $strFile) {
         print 'X';
         $strMd5 = md5_file($strFile);
         $strFullPath = $strFile;
         $strFile = substr($strFile, strlen($this->strRoot) + 1);
         // Process all files other than the root _README.txt and LICENSE.txt
         if ($strFile != '_README.txt' && $strFile != '_LICENSE.txt') {
             $intDirectoryId = null;
             $objFileDirectory = null;
             foreach ($this->objDirectoryTokens as $objDirectory) {
                 if (!$intDirectoryId) {
                     if (strpos($strFile, $objDirectory->Path) === 0) {
                         $intDirectoryId = $objDirectory->Id;
                         $objFileDirectory = $objDirectory;
                         $strFile = substr($strFile, strlen($objDirectory->Path));
                     }
                 }
             }
             if (!$intDirectoryId) {
                 var_dump($this->objDirectoryTokens);
                 exit("FATAL ERROR: No DirectoryToken resolution for " . $strFile . "\r\n");
             }
             $objFile = File::LoadByDirectoryIdPath($intDirectoryId, $strFile);
             if (!$objFile) {
                 $objFile = new File();
                 $objFile->Path = $strFile;
                 $objFile->DirectoryId = $intDirectoryId;
             } else {
                 $objFile->DeprecatedMajorVersion = null;
                 $objFile->DeprecatedMinorVersion = null;
                 $objFile->DeprecatedBuild = null;
             }
             $objFile->Save();
             $this->blnFileProcessedArray['id' . $objFile->Id] = true;
             $this->strXml .= sprintf("<file directoryToken=\"%s\" path=\"%s\" md5=\"%s\"/>\r\n", $objFileDirectory->Token, $strFile, $strMd5);
             // Parse tokens for documetation for all PHP files outside of assets and PHPUnit
             if (substr($strFile, strlen($strFile) - 4) == '.php' && strpos($strFullPath, '/assets/') === false && strpos($strFullPath, '/PHPUnit/') === false) {
                 switch ($objFileDirectory->Token) {
                     case '__INCLUDES__':
                     case '__QCODO__':
                     case '__QCODO_CORE__':
                         $objParser = new QScriptParser($strFullPath);
                         $objResult = $objParser->ParseTokens();
                         // Iterate through the Class Definitions
                         foreach ($objResult->ClassArray as $objParserClass) {
                             if ($objParserClass->Extends) {
                                 $objParentClass = QcodoClass::RestoreByName($objParserClass->Extends, $this->strVersion, null);
                             } else {
                                 $objParentClass = null;
                             }
                             // TO DO
                             // if ($strImplements) {
                             // }
                             $objClass = QcodoClass::RestoreByName($objParserClass->Name, $this->strVersion, $objFile);
                             $objClass->AbstractFlag = $objParserClass->Abstract;
                             $objClass->ParentQcodoClass = $objParentClass;
                             $objClass->Save();
                             // Class Constants
                             $strConstantArray = array();
                             foreach ($objParserClass->ConstantArray as $objParserConstant) {
                                 $objConstant = QcodoConstant::RestoreByNameForClass($objParserConstant->Name, $objClass->Id, $this->strVersion, $objFile);
                                 //										$strValue = QBuildMaker::StripQuotes($objParserConstant->Value);
                                 $strValue = $objParserConstant->Value;
                                 $objConstant->Variable->DefaultValue = $strValue;
                                 $objConstant->Variable->Save();
                                 $strConstantArray[$objParserConstant->Name] = true;
                             }
                             // Class Constants (Deprecate)
                             foreach ($objClass->GetQcodoConstantArray(QQ::Clause(QQ::Expand(QQN::QcodoConstant()->Variable))) as $objConstant) {
                                 if (!array_key_exists($objConstant->Variable->Name, $strConstantArray)) {
                                     $objConstant->Variable->LastVersion = $this->strVersion;
                                     $objConstant->Variable->Save();
                                 }
                             }
                             // Class Variables
                             $strVariableArray = array();
                             foreach ($objParserClass->VariableArray as $objParserVariable) {
                                 $strName = QBuildMaker::StripDollar($objParserVariable->Name);
                                 //										$strValue = QBuildMaker::StripQuotes($objParserVariable->DefaultValue);
                                 $strValue = $objParserVariable->DefaultValue;
                                 $objClassVariable = ClassVariable::RestoreByNameForClass($strName, $objClass->Id, $this->strVersion);
                                 $objClassVariable->Variable->DefaultValue = $strValue;
                                 $objClassVariable->Variable->Save();
                                 $objClassVariable->StaticFlag = $objParserVariable->Static;
                                 switch (strtolower($objParserVariable->Visibility)) {
                                     case 'public':
                                         $objClassVariable->ProtectionTypeId = ProtectionType::_Public;
                                         break;
                                     case 'protected':
                                         $objClassVariable->ProtectionTypeId = ProtectionType::_Protected;
                                         break;
                                     case 'private':
                                         $objClassVariable->ProtectionTypeId = ProtectionType::_Private;
                                         break;
                                     default:
                                         throw new Exception('Unknown Protection Type');
                                 }
                                 $objClassVariable->Save();
                                 $strVariableArray[$strName] = true;
                             }
                             // Class Variables (deprecate)
                             foreach ($objClass->GetClassVariableArray(QQ::Clause(QQ::Expand(QQN::ClassVariable()->Variable))) as $objClassVariable) {
                                 if (!array_key_exists($objClassVariable->Variable->Name, $strVariableArray)) {
                                     $objClassVariable->Variable->LastVersion = $this->strVersion;
                                     $objClassVariable->Variable->Save();
                                 }
                             }
                             // Class Methods
                             $strMethodArray = array();
                             foreach ($objParserClass->MethodArray as $objParserFunction) {
                                 $objOperation = Operation::RestoreByNameForClass($objParserFunction->Name, $objClass->Id, $this->strVersion, $objFile);
                                 $objOperation->StaticFlag = $objParserFunction->Static;
                                 $objOperation->FinalFlag = $objParserFunction->Final;
                                 $objOperation->AbstractFlag = $objParserFunction->Abstract;
                                 switch (strtolower($objParserFunction->Visibility)) {
                                     case 'public':
                                         $objOperation->ProtectionTypeId = ProtectionType::_Public;
                                         break;
                                     case 'protected':
                                         $objOperation->ProtectionTypeId = ProtectionType::_Protected;
                                         break;
                                     case 'private':
                                         $objOperation->ProtectionTypeId = ProtectionType::_Private;
                                         break;
                                     default:
                                         throw new Exception('Unknown Protection Type');
                                 }
                                 $objOperation->Save();
                                 $strMethodArray[$objParserFunction->Name] = true;
                                 // Figure Out the Parameters
                                 $objParserParameterArray = array();
                                 foreach ($objParserFunction->ParameterArray as $objParserParameter) {
                                     $strName = QBuildMaker::StripDollar($objParserParameter->Name);
                                     $objParserParameterArray[$strName] = $objParserParameter;
                                 }
                                 $objParameterArray = Parameter::RestoreParameterArrayByNameForOperation(array_keys($objParserParameterArray), $objOperation->Id, $this->strVersion);
                                 foreach ($objParameterArray as $objParameter) {
                                     $objParserParameter = $objParserParameterArray[$objParameter->Variable->Name];
                                     $objParameter->ReferenceFlag = $objParserParameter->Reference;
                                     $objParameter->Save();
                                     $objParameter->Variable->DefaultValue = $objParserParameter->DefaultValue;
                                     $objParameter->Variable->Save();
                                 }
                             }
                             // Class Methods (deprecate)
                             foreach ($objClass->GetOperationArray() as $objOperation) {
                                 if (!array_key_exists($objOperation->Name, $strMethodArray)) {
                                     $objOperation->LastVersion = $this->strVersion;
                                     $objOperation->Save();
                                 }
                             }
                             // Class Properties
                             $strPropertyArray = array();
                             foreach ($objParserClass->PropertyArray as $objParserProperty) {
                                 $strName = QBuildMaker::StripQuotes($objParserProperty->Name);
                                 if ($strName != 'ttf' && $strName != 'pfb' && $strName != 'afm') {
                                     $objProperty = ClassProperty::RestoreByNameForClass($strName, $objClass->Id, $this->strVersion);
                                     if ($objParserProperty->Read && !$objParserProperty->Write) {
                                         $objProperty->ReadOnlyFlag = true;
                                         $objProperty->WriteOnlyFlag = false;
                                     } else {
                                         if (!$objParserProperty->Read && $objParserProperty->Write) {
                                             $objProperty->ReadOnlyFlag = false;
                                             $objProperty->WriteOnlyFlag = true;
                                         } else {
                                             $objProperty->ReadOnlyFlag = false;
                                             $objProperty->WriteOnlyFlag = false;
                                         }
                                     }
                                     $objProperty->Save();
                                     $strPropertyArray[$strName] = true;
                                 }
                             }
                             // Class Properties (deprecate)
                             foreach ($objClass->GetClassPropertyArray() as $objProperty) {
                                 if (!array_key_exists($objProperty->Variable->Name, $strPropertyArray)) {
                                     $objProperty->Variable->LastVersion = $this->strVersion;
                                     $objProperty->Save();
                                 }
                             }
                         }
                         // Iterate through the Interfaces
                         // TODO
                         // Iterate through the Global Functions
                         foreach ($objResult->FunctionArray as $objParserFunction) {
                             $objOperation = Operation::RestoreByNameForClass($objParserFunction->Name, null, $this->strVersion, $objFile);
                             // Figure Out the Parameters
                             $objParserParameterArray = array();
                             foreach ($objParserFunction->ParameterArray as $objParserParameter) {
                                 $strName = QBuildMaker::StripDollar($objParserParameter->Name);
                                 $objParserParameterArray[$strName] = $objParserParameter;
                             }
                             $objParameterArray = Parameter::RestoreParameterArrayByNameForOperation(array_keys($objParserParameterArray), $objOperation->Id, $this->strVersion);
                             foreach ($objParameterArray as $objParameter) {
                                 $objParserParameter = $objParserParameterArray[$objParameter->Variable->Name];
                                 $objParameter->ReferenceFlag = $objParserParameter->Reference;
                                 $objParameter->Save();
                                 $objParameter->Variable->DefaultValue = $objParserParameter->DefaultValue;
                                 $objParameter->Variable->Save();
                             }
                         }
                         // Iterate through the Global Constants
                         foreach ($objResult->ConstantArray as $objParserConstant) {
                             $objConstant = QcodoConstant::RestoreByNameForClass($objParserConstant->Name, null, $this->strVersion, $objFile);
                             // $strValue = QBuildMaker::StripQuotes($objParserConstant->Value);
                             $strValue = $objParserConstant->Value;
                             $objConstant->Variable->DefaultValue = $strValue;
                             $objConstant->Variable->Save();
                         }
                         // Iterate through the Global Variables
                         // NOT SUPPORTED
                         break;
                 }
             }
         }
     }
     print "] Done.\r\n";
     foreach ($strFolderArray as $strFolder) {
         $this->ProcessFolder($strFolder);
     }
 }