TranslationExportXaraya.php

Go to the documentation of this file.

<?php

/***************************************************************************
 *   Copyright (C) 2005-2020 by Ferenc Veres                                                       *
 *   lion@netngine.hu                                                                                                      *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 3 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
 ***************************************************************************/

class TranslationExportXaraya implements ITranslationExport
{
        protected $ProjectName = "Xaraya";
        protected $XmlNameSpace = "http://xaraya.com/2002/ns/translations";

        private $RootTimeStamp; 
        
        private $SilentMode;

        private $ErrorLogFile;

        private $XarayaRoot;
        
        function __construct() 
        {
        }

        private function &ExportProject(TranslationProject $project)
        {
                $langXml = new DOMDocument();
                //$langXml->substituteEntities = true;
                $langXml->LoadXML($project->GetSkeleton());

                // Loop on all strings of this project and put in a hash for later replace
                $strings = new StringIterator($project->GetID());
                foreach($strings as $str)
                {
                        $projStrings["###".$str->GetStringID()."###"] = $this->FixEntity($str->GetOriginal());
                        
                        $projStrings["###".$str->GetStringID()."t###"] = $this->FixEntity($str->GetTranslation());
/*                      if(preg_match('/\&/', $str->GetOriginal()))
                        {
                                echo( $str->GetOriginal()."\n");
                                echo(FixQuot($str->GetOriginal()."\n"));
                        }
*/              }

                // XPath to all translation entries
                $xpath = new DOMXPath($langXml);
                $xpath->registerNamespace("m",$this->XmlNameSpace);
                $entryNodes = $xpath->query("//m:translations/m:entry");

                // Loop on each string in theXML and replace variables
                foreach ($entryNodes as $entry)
                {
                        $origNodes = $xpath->query("m:string", $entry);
                        $transNodes = $xpath->query("m:translation", $entry);

                        if($origNodes->item(0)->nodeValue == "")
                        {
                                echo "Empty Original node in the file:".$project->GetName().".\n";
                        }
                        else
                        {
                                // Replace ### node with the same strings hash key value
                                $origNodes->item(0)->nodeValue = $projStrings[$origNodes->item(0)->nodeValue];
                                
                                $transNodes->item(0)->nodeValue = $projStrings[$transNodes->item(0)->nodeValue];

                        }
                }
                $xmlContent = $langXml->saveXML();
                return $xmlContent;
        }

        function FixEntity($text)
        {
                $s = str_replace("&", "&amp;", $text);
                $s = str_replace("\"", "&quot;", $s); // !!!
                $s = str_replace("<", "&lt;", $s);
                $s = str_replace(">", "&gt;", $s);
                return $s;
        }

        private function ProcessRecursive($dir, ProjectIterator $projectIterator)
        {
                // Process each project in the iterator
                foreach($projectIterator as $project)
                {
                        // Completely ignore dead projects and their subprojects (older than root)
                        if($this->RootTimeStamp <= $project->GetLastSeen())
                        {
                                // Empty document means direcrory only.
                                if($project->GetIsFolder())
                                {
                                        // Create a new dir and process the connected projects recursively.
        
                                        $newDir = $dir."/".$project->GetName();
                                        if(!is_dir($newDir))
                                        {
                                                $ret = mkdir($newDir);
                                                if(!$ret)
                                                {
                                                        throw new Exception("Failed to create directory $newDir, no permission or disk full.");
                                                }
                                        }
                                        if($projectIterator->hasChildren())
                                        {
                                                $this->ProcessRecursive($newDir, $projectIterator->getChildren());
                                        }
                                }
                                else
                                {
                                        // Save one project XML file.
                                        
                                        // Process XML files with exporter.
                                        if(preg_match("/\.xml$/", $project->GetName()))
                                        {
                                                $export = $this->ExportProject($project);
                                        }
                                        else
                                        {
                                                // NonXML files, just resave original content.
                                                $export = $project->GetDocument();
                                        }
                                        
                                        $bytes = file_put_contents($dir."/".$project->GetName(), $export);
                                        if($bytes != strlen($export))
                                        {
                                                throw new Exception("Failed to save  ".$dir."/".$project->GetName().", no permission or disk full.");
                                        }
                                        if(!$this->SilentMode)
                                        {
                                                echo("Saved: ".$dir."/".$project->GetName()."\n");
                                        }
                                        
                                        // Check if corresponding Xaraya file still exists
                                        if($this->XarayaRoot != "")
                                        {
                                                $this->CheckCodeFiles($project);
                                        }
                                }
                        }
                }

        }
        
        private function CheckCodeFiles(TranslationProject $project)
        {
                // Only XML files need a corresponding code file
                if(!preg_match("/\.xml$/", $project->GetName()))
                {
                        return;
                }
                
                // Loop back to root to find if this is a module,theme or core.
                unset($parents);
                
                $pid = $project->GetID();
                $localeID = $project->GetLocaleID();
                
                // Loop to parent
                while($pid != 0)
                {
                        $proj = ProjectIterator::$ProjectList[$localeID][$pid];
                        $parents[] = $proj;
                        $pid = $proj->GetParentID();
                }
                
                // Not a module or theme file (too few dirs, e.g. core, which has no code file.)
                if(count($parents) < 4)
                {
                        return; 
                }
                
                // Build an array of directory path
                unset($path);
                $xmlPath = "";
                for($i = 0; $i < count($parents); $i++)
                {
                        $path[] = $parents[count($parents) - $i - 1]->GetName();
                        
                        // Path to XML locale file, for error message.
                        if($i > 0)
                        {
                                $xmlPath .= "/".$path[count($path)-1];
                        }
                }

                // Skip "commmon.xml" and "fuzzy.xml" in module/theme root.
                if(count($path) == 4 && 
                        ($path[count($path)-1] == "common.xml" || $path[count($path)-1] == "fuzzy.xml"))
                        {
                                return;
                        }
                
                $mainFolder = $path[1]; // "modules" or "themes"
                $entityName = $path[2]; // module name or theme name. 
                
                $codeFile = "";
                
                switch($mainFolder)
                {
                        case "modules":

                                // In the module folder almost everything is "xar".
                                $codeFile = "modules/".$entityName."/xar".$path[3];
                                
                                // Extension is xd in "xartemplates", otherwise php.
                                $fileExt = ".php";
                                if($path[3] == "templates")
                                {
                                        $fileExt = ".xd";
                                }

                                // Add subfolder/file names
                                for($i = 4; $i < count($path); $i++)
                                {
                                        $codeFile .= "/".$path[$i]; 
                                }
                                
                                // Replace xml extension to php/xd
                                $codeFile = preg_replace("/\.xml$/", $fileExt, $codeFile);
                                break;
                                
                        case "themes":
                                
                                $codeFile = "themes/".$entityName;
                                
                                // Simply add subfolder/file names
                                for($i = 3; $i < count($path); $i++)
                                {
                                        $codeFile .= "/".$path[$i]; 
                                }
                                
                                // Replace xml extension to xt
                                $codeFile = preg_replace("/\.xml$/", ".xt", $codeFile);
                                break;
                
                }

                if(!file_exists($this->XarayaRoot."/".$codeFile))
                {
                        $this->LogError("No corresponding code file: $xmlPath [$codeFile]\n");          
                }
        }
        
        private function LogError($msg)
        {
                $handle = fopen($this->ErrorLogFile, "a+");
                fwrite($handle, $msg);
                fclose($handle);
        }
        public function Export($localeName, $silentMode = false)
        {
                $this->SilentMode = $silentMode;
                
                $localeID = TranslationProject::$LocaleIDCache[$localeName];
                if(empty($localeID))
                {
                        throw new Exception("Export called with unknown locale name: $localeName");
                }

                // Check export path and create locale dir
                if(!is_dir(GetConfigVar('export_path')))
                {
                        throw new Exception("Export path points to non-existing directory: ".GetConfigVar('export_path'));
                }
                $dir = GetConfigVar('export_path')."/".$localeName;
                if(!is_dir($dir))
                {
                        $ret = mkdir($dir, 0755);
                        if(!$ret)
                        {
                                throw new Exception("Failed to create directory $dir, no permission or disk full.");
                        }
                }
                $dir = GetConfigVar('export_path')."/".$localeName."/xml/";
                if(!is_dir($dir))
                {
                        $ret = mkdir($dir, 0755);
                        if(!$ret)
                        {
                                throw new Exception("Failed to create directory $dir, no permission or disk full.");
                        }
                }
                
                // Set error logs file location
                $this->ErrorLogFile = GetConfigVar('export_path')."/".$localeName."/xartm_errors.txt";
                if(file_exists($this->ErrorLogFile))
                {
                        // "Truncate" file
                        unlink($this->ErrorLogFile);
                }
                echo("Errors will be written to:".$this->ErrorLogFile."\n");
                
                // Xaraya root to find code files in it to check if a locale file is still valid
                $this->XarayaRoot = GetConfigVar('export_path')."/../..";
                if(!file_exists($this->XarayaRoot."/index.php"))
                {
                        echo("No ".$this->ProjectName." root found:".$this->XarayaRoot."/index.php. Won't detect obsolete files into errorlog.\n");
                        $this->XarayaRoot = ""; // Not a xaraya, do not check for files.
                }
                
                // Go exporting
                $rootProject = new TranslationProject();
                $rootProject->LoadRoot($this->ProjectName, $localeID);
                $this->RootTimeStamp = $rootProject->GetLastSeen();
                
                // Work from database (no cache)
                ProjectIterator::ClearCache($localeID);
                
                $allProjects = new ProjectIterator($rootProject->GetID(), $localeID, false);

                $this->ProcessRecursive($dir, $allProjects);
        }
}
?>