Subversion Repositories SmartDukaan

<?php

/**

 * Language string extractor

 *

 * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)

 * Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)

 *

 * Licensed under The MIT License

 * For full copyright and license information, please see the LICENSE.txt

 * Redistributions of files must retain the above copyright notice.

 *

 * @copyright     Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)

 * @link          http://cakephp.org CakePHP(tm) Project

 * @since         CakePHP(tm) v 1.2.0.5012

 * @license       http://www.opensource.org/licenses/mit-license.php MIT License

 */

App::uses('AppShell', 'Console/Command');

App::uses('File', 'Utility');

App::uses('Folder', 'Utility');

App::uses('Hash', 'Utility');

/**

 * Language string extractor

 *

 * @package       Cake.Console.Command.Task

 */

class ExtractTask extends AppShell {

/**

 * Paths to use when looking for strings

 *

 * @var string

 */

	protected $_paths = array();

/**

 * Files from where to extract

 *

 * @var array

 */

	protected $_files = array();

/**

 * Merge all domain and category strings into the default.pot file

 *

 * @var boolean

 */

	protected $_merge = false;

/**

 * Current file being processed

 *

 * @var string

 */

	protected $_file = null;

/**

 * Contains all content waiting to be write

 *

 * @var string

 */

	protected $_storage = array();

/**

 * Extracted tokens

 *

 * @var array

 */

	protected $_tokens = array();

/**

 * Extracted strings indexed by category and domain.

 *

 * @var array

 */

	protected $_translations = array();

/**

 * Destination path

 *

 * @var string

 */

	protected $_output = null;

/**

 * An array of directories to exclude.

 *

 * @var array

 */

	protected $_exclude = array();

/**

 * Holds whether this call should extract model validation messages

 *

 * @var boolean

 */

	protected $_extractValidation = true;

/**

 * Holds the validation string domain to use for validation messages when extracting

 *

 * @var boolean

 */

	protected $_validationDomain = 'default';

/**

 * Holds whether this call should extract the CakePHP Lib messages

 *

 * @var boolean

 */

	protected $_extractCore = false;

/**

 * Method to interact with the User and get path selections.

 *

 * @return void

 */

	protected function _getPaths() {

		$defaultPath = APP;

		while (true) {

			$currentPaths = count($this->_paths) > 0 ? $this->_paths : array('None');

			$message = __d(

				'cake_console',

				"Current paths: %s\nWhat is the path you would like to extract?\n[Q]uit [D]one",

				implode(', ', $currentPaths)

			);

			$response = $this->in($message, null, $defaultPath);

			if (strtoupper($response) === 'Q') {

				$this->out(__d('cake_console', 'Extract Aborted'));

				return $this->_stop();

			} elseif (strtoupper($response) === 'D' && count($this->_paths)) {

				$this->out();

				return;

			} elseif (strtoupper($response) === 'D') {

				$this->err(__d('cake_console', '<warning>No directories selected.</warning> Please choose a directory.'));

			} elseif (is_dir($response)) {

				$this->_paths[] = $response;

				$defaultPath = 'D';

			} else {

				$this->err(__d('cake_console', 'The directory path you supplied was not found. Please try again.'));

			}

			$this->out();

		}

	}

/**

 * Execution method always used for tasks

 *

 * @return void

 */

	public function execute() {

		if (!empty($this->params['exclude'])) {

			$this->_exclude = explode(',', $this->params['exclude']);

		}

		if (isset($this->params['files']) && !is_array($this->params['files'])) {

			$this->_files = explode(',', $this->params['files']);

		}

		if (isset($this->params['paths'])) {

			$this->_paths = explode(',', $this->params['paths']);

		} elseif (isset($this->params['plugin'])) {

			$plugin = Inflector::camelize($this->params['plugin']);

			if (!CakePlugin::loaded($plugin)) {

				CakePlugin::load($plugin);

			}

			$this->_paths = array(CakePlugin::path($plugin));

			$this->params['plugin'] = $plugin;

		} else {

			$this->_getPaths();

		}

		if (isset($this->params['extract-core'])) {

			$this->_extractCore = !(strtolower($this->params['extract-core']) === 'no');

		} else {

			$response = $this->in(__d('cake_console', 'Would you like to extract the messages from the CakePHP core?'), array('y', 'n'), 'n');

			$this->_extractCore = strtolower($response) === 'y';

		}

		if (!empty($this->params['exclude-plugins']) && $this->_isExtractingApp()) {

			$this->_exclude = array_merge($this->_exclude, App::path('plugins'));

		}

		if (!empty($this->params['ignore-model-validation']) || (!$this->_isExtractingApp() && empty($plugin))) {

			$this->_extractValidation = false;

		}

		if (!empty($this->params['validation-domain'])) {

			$this->_validationDomain = $this->params['validation-domain'];

		}

		if ($this->_extractCore) {

			$this->_paths[] = CAKE;

			$this->_exclude = array_merge($this->_exclude, array(

				CAKE . 'Test',

				CAKE . 'Console' . DS . 'Templates'

			));

		}

		if (isset($this->params['output'])) {

			$this->_output = $this->params['output'];

		} elseif (isset($this->params['plugin'])) {

			$this->_output = $this->_paths[0] . DS . 'Locale';

		} else {

			$message = __d('cake_console', "What is the path you would like to output?\n[Q]uit", $this->_paths[0] . DS . 'Locale');

			while (true) {

				$response = $this->in($message, null, rtrim($this->_paths[0], DS) . DS . 'Locale');

				if (strtoupper($response) === 'Q') {

					$this->out(__d('cake_console', 'Extract Aborted'));

					return $this->_stop();

				} elseif ($this->_isPathUsable($response)) {

					$this->_output = $response . DS;

					break;

				} else {

					$this->err(__d('cake_console', 'The directory path you supplied was not found. Please try again.'));

				}

				$this->out();

			}

		}

		if (isset($this->params['merge'])) {

			$this->_merge = !(strtolower($this->params['merge']) === 'no');

		} else {

			$this->out();

			$response = $this->in(__d('cake_console', 'Would you like to merge all domain and category strings into the default.pot file?'), array('y', 'n'), 'n');

			$this->_merge = strtolower($response) === 'y';

		}

		if (empty($this->_files)) {

			$this->_searchFiles();

		}

		$this->_output = rtrim($this->_output, DS) . DS;

		if (!$this->_isPathUsable($this->_output)) {

			$this->err(__d('cake_console', 'The output directory %s was not found or writable.', $this->_output));

			return $this->_stop();

		}

		$this->_extract();

	}

/**

 * Add a translation to the internal translations property

 *

 * Takes care of duplicate translations

 *

 * @param string $category

 * @param string $domain

 * @param string $msgid

 * @param array $details

 * @return void

 */

	protected function _addTranslation($category, $domain, $msgid, $details = array()) {

		if (empty($this->_translations[$category][$domain][$msgid])) {

			$this->_translations[$category][$domain][$msgid] = array(

				'msgid_plural' => false

			);

		}

		if (isset($details['msgid_plural'])) {

			$this->_translations[$category][$domain][$msgid]['msgid_plural'] = $details['msgid_plural'];

		}

		if (isset($details['file'])) {

			$line = 0;

			if (isset($details['line'])) {

				$line = $details['line'];

			}

			$this->_translations[$category][$domain][$msgid]['references'][$details['file']][] = $line;

		}

	}

/**

 * Extract text

 *

 * @return void

 */

	protected function _extract() {

		$this->out();

		$this->out();

		$this->out(__d('cake_console', 'Extracting...'));

		$this->hr();

		$this->out(__d('cake_console', 'Paths:'));

		foreach ($this->_paths as $path) {

			$this->out('   ' . $path);

		}

		$this->out(__d('cake_console', 'Output Directory: ') . $this->_output);

		$this->hr();

		$this->_extractTokens();

		$this->_extractValidationMessages();

		$this->_buildFiles();

		$this->_writeFiles();

		$this->_paths = $this->_files = $this->_storage = array();

		$this->_translations = $this->_tokens = array();

		$this->_extractValidation = true;

		$this->out();

		$this->out(__d('cake_console', 'Done.'));

	}

/**

 * Get & configure the option parser

 *

 * @return void

 */

	public function getOptionParser() {

		$parser = parent::getOptionParser();

		return $parser->description(__d('cake_console', 'CakePHP Language String Extraction:'))

			->addOption('app', array('help' => __d('cake_console', 'Directory where your application is located.')))

			->addOption('paths', array('help' => __d('cake_console', 'Comma separated list of paths.')))

			->addOption('merge', array(

				'help' => __d('cake_console', 'Merge all domain and category strings into the default.po file.'),

				'choices' => array('yes', 'no')

			))

			->addOption('output', array('help' => __d('cake_console', 'Full path to output directory.')))

			->addOption('files', array('help' => __d('cake_console', 'Comma separated list of files.')))

			->addOption('exclude-plugins', array(

				'boolean' => true,

				'default' => true,

				'help' => __d('cake_console', 'Ignores all files in plugins if this command is run inside from the same app directory.')

			))

			->addOption('plugin', array(

				'help' => __d('cake_console', 'Extracts tokens only from the plugin specified and puts the result in the plugin\'s Locale directory.')

			))

			->addOption('ignore-model-validation', array(

				'boolean' => true,

				'default' => false,

				'help' => __d('cake_console', 'Ignores validation messages in the $validate property.' .

					' If this flag is not set and the command is run from the same app directory,' .

					' all messages in model validation rules will be extracted as tokens.')

			))

			->addOption('validation-domain', array(

				'help' => __d('cake_console', 'If set to a value, the localization domain to be used for model validation messages.')

			))

			->addOption('exclude', array(

				'help' => __d('cake_console', 'Comma separated list of directories to exclude.' .

					' Any path containing a path segment with the provided values will be skipped. E.g. test,vendors')

			))

			->addOption('overwrite', array(

				'boolean' => true,

				'default' => false,

				'help' => __d('cake_console', 'Always overwrite existing .pot files.')

			))

			->addOption('extract-core', array(

				'help' => __d('cake_console', 'Extract messages from the CakePHP core libs.'),

				'choices' => array('yes', 'no')

			));

	}

/**

 * Extract tokens out of all files to be processed

 *

 * @return void

 */

	protected function _extractTokens() {

		foreach ($this->_files as $file) {

			$this->_file = $file;

			$this->out(__d('cake_console', 'Processing %s...', $file));

			$code = file_get_contents($file);

			$allTokens = token_get_all($code);

			$this->_tokens = array();

			foreach ($allTokens as $token) {

				if (!is_array($token) || ($token[0] != T_WHITESPACE && $token[0] != T_INLINE_HTML)) {

					$this->_tokens[] = $token;

				}

			}

			unset($allTokens);

			$this->_parse('__', array('singular'));

			$this->_parse('__n', array('singular', 'plural'));

			$this->_parse('__d', array('domain', 'singular'));

			$this->_parse('__c', array('singular', 'category'));

			$this->_parse('__dc', array('domain', 'singular', 'category'));

			$this->_parse('__dn', array('domain', 'singular', 'plural'));

			$this->_parse('__dcn', array('domain', 'singular', 'plural', 'count', 'category'));

		}

	}

/**

 * Parse tokens

 *

 * @param string $functionName Function name that indicates translatable string (e.g: '__')

 * @param array $map Array containing what variables it will find (e.g: category, domain, singular, plural)

 * @return void

 */

	protected function _parse($functionName, $map) {

		$count = 0;

		$categories = array('LC_ALL', 'LC_COLLATE', 'LC_CTYPE', 'LC_MONETARY', 'LC_NUMERIC', 'LC_TIME', 'LC_MESSAGES');

		$tokenCount = count($this->_tokens);

		while (($tokenCount - $count) > 1) {

			$countToken = $this->_tokens[$count];

			$firstParenthesis = $this->_tokens[$count + 1];

			if (!is_array($countToken)) {

				$count++;

				continue;

			}

			list($type, $string, $line) = $countToken;

			if (($type == T_STRING) && ($string == $functionName) && ($firstParenthesis === '(')) {

				$position = $count;

				$depth = 0;

				while (!$depth) {

					if ($this->_tokens[$position] === '(') {

						$depth++;

					} elseif ($this->_tokens[$position] === ')') {

						$depth--;

					}

					$position++;

				}

				$mapCount = count($map);

				$strings = $this->_getStrings($position, $mapCount);

				if ($mapCount == count($strings)) {

					extract(array_combine($map, $strings));

					$category = isset($category) ? $category : 6;

					$category = intval($category);

					$categoryName = $categories[$category];

					$domain = isset($domain) ? $domain : 'default';

					$details = array(

						'file' => $this->_file,

						'line' => $line,

					);

					if (isset($plural)) {

						$details['msgid_plural'] = $plural;

					}

					$this->_addTranslation($categoryName, $domain, $singular, $details);

				} else {

					$this->_markerError($this->_file, $line, $functionName, $count);

				}

			}

			$count++;

		}

	}

/**

 * Looks for models in the application and extracts the validation messages

 * to be added to the translation map

 *

 * @return void

 */

	protected function _extractValidationMessages() {

		if (!$this->_extractValidation) {

			return;

		}

		$plugins = array(null);

		if (empty($this->params['exclude-plugins'])) {

			$plugins = array_merge($plugins, App::objects('plugin', null, false));

		}

		foreach ($plugins as $plugin) {

			$this->_extractPluginValidationMessages($plugin);

		}

	}

/**

 * Extract validation messages from application or plugin models

 *

 * @param string $plugin Plugin name or `null` to process application models

 * @return void

 */

	protected function _extractPluginValidationMessages($plugin = null) {

		App::uses('AppModel', 'Model');

		if (!empty($plugin)) {

			if (!CakePlugin::loaded($plugin)) {

				return;

			}

			App::uses($plugin . 'AppModel', $plugin . '.Model');

			$plugin = $plugin . '.';

		}

		$models = App::objects($plugin . 'Model', null, false);

		foreach ($models as $model) {

			App::uses($model, $plugin . 'Model');

			$reflection = new ReflectionClass($model);

			if (!$reflection->isSubClassOf('Model')) {

				continue;

			}

			$properties = $reflection->getDefaultProperties();

			$validate = $properties['validate'];

			if (empty($validate)) {

				continue;

			}

			$file = $reflection->getFileName();

			$domain = $this->_validationDomain;

			if (!empty($properties['validationDomain'])) {

				$domain = $properties['validationDomain'];

			}

			foreach ($validate as $field => $rules) {

				$this->_processValidationRules($field, $rules, $file, $domain);

			}

		}

	}

/**

 * Process a validation rule for a field and looks for a message to be added

 * to the translation map

 *

 * @param string $field the name of the field that is being processed

 * @param array $rules the set of validation rules for the field

 * @param string $file the file name where this validation rule was found

 * @param string $domain default domain to bind the validations to

 * @return void

 */

	protected function _processValidationRules($field, $rules, $file, $domain, $category = 'LC_MESSAGES') {

		if (!is_array($rules)) {

			return;

		}

		$dims = Hash::dimensions($rules);

		if ($dims === 1 || ($dims === 2 && isset($rules['message']))) {

			$rules = array($rules);

		}

		foreach ($rules as $rule => $validateProp) {

			$msgid = null;

			if (isset($validateProp['message'])) {

				if (is_array($validateProp['message'])) {

					$msgid = $validateProp['message'][0];

				} else {

					$msgid = $validateProp['message'];

				}

			} elseif (is_string($rule)) {

				$msgid = $rule;

			}

			if ($msgid) {

				$details = array(

					'file' => $file,

					'line' => 'validation for field ' . $field

				);

				$this->_addTranslation($category, $domain, $msgid, $details);

			}

		}

	}

/**

 * Build the translate template file contents out of obtained strings

 *

 * @return void

 */

	protected function _buildFiles() {

		$paths = $this->_paths;

		$paths[] = realpath(APP) . DS;

		foreach ($this->_translations as $category => $domains) {

			foreach ($domains as $domain => $translations) {

				foreach ($translations as $msgid => $details) {

					$plural = $details['msgid_plural'];

					$files = $details['references'];

					$occurrences = array();

					foreach ($files as $file => $lines) {

						$lines = array_unique($lines);

						$occurrences[] = $file . ':' . implode(';', $lines);

					}

					$occurrences = implode("\n#: ", $occurrences);

					$header = '#: ' . str_replace(DS, '/', str_replace($paths, '', $occurrences)) . "\n";

					if ($plural === false) {

						$sentence = "msgid \"{$msgid}\"\n";

						$sentence .= "msgstr \"\"\n\n";

					} else {

						$sentence = "msgid \"{$msgid}\"\n";

						$sentence .= "msgid_plural \"{$plural}\"\n";

						$sentence .= "msgstr[0] \"\"\n";

						$sentence .= "msgstr[1] \"\"\n\n";

					}

					$this->_store($category, $domain, $header, $sentence);

					if (($category !== 'LC_MESSAGES' || $domain !== 'default') && $this->_merge) {

						$this->_store('LC_MESSAGES', 'default', $header, $sentence);

					}

				}

			}

		}

	}

/**

 * Prepare a file to be stored

 *

 * @param string $category

 * @param string $domain

 * @param string $header

 * @param string $sentence

 * @return void

 */

	protected function _store($category, $domain, $header, $sentence) {

		if (!isset($this->_storage[$category])) {

			$this->_storage[$category] = array();

		}

		if (!isset($this->_storage[$category][$domain])) {

			$this->_storage[$category][$domain] = array();

		}

		if (!isset($this->_storage[$category][$domain][$sentence])) {

			$this->_storage[$category][$domain][$sentence] = $header;

		} else {

			$this->_storage[$category][$domain][$sentence] .= $header;

		}

	}

/**

 * Write the files that need to be stored

 *

 * @return void

 */

	protected function _writeFiles() {

		$overwriteAll = false;

		if (!empty($this->params['overwrite'])) {

			$overwriteAll = true;

		}

		foreach ($this->_storage as $category => $domains) {

			foreach ($domains as $domain => $sentences) {

				$output = $this->_writeHeader();

				foreach ($sentences as $sentence => $header) {

					$output .= $header . $sentence;

				}

				$filename = $domain . '.pot';

				if ($category === 'LC_MESSAGES') {

					$File = new File($this->_output . $filename);

				} else {

					new Folder($this->_output . $category, true);

					$File = new File($this->_output . $category . DS . $filename);

				}

				$response = '';

				while ($overwriteAll === false && $File->exists() && strtoupper($response) !== 'Y') {

					$this->out();

					$response = $this->in(

						__d('cake_console', 'Error: %s already exists in this location. Overwrite? [Y]es, [N]o, [A]ll', $filename),

						array('y', 'n', 'a'),

						'y'

					);

					if (strtoupper($response) === 'N') {

						$response = '';

						while (!$response) {

							$response = $this->in(__d('cake_console', "What would you like to name this file?"), null, 'new_' . $filename);

							$File = new File($this->_output . $response);

							$filename = $response;

						}

					} elseif (strtoupper($response) === 'A') {

						$overwriteAll = true;

					}

				}

				$File->write($output);

				$File->close();

			}

		}

	}

/**

 * Build the translation template header

 *

 * @return string Translation template header

 */

	protected function _writeHeader() {

		$output = "# LANGUAGE translation of CakePHP Application\n";

		$output .= "# Copyright YEAR NAME <EMAIL@ADDRESS>\n";

		$output .= "#\n";

		$output .= "#, fuzzy\n";

		$output .= "msgid \"\"\n";

		$output .= "msgstr \"\"\n";

		$output .= "\"Project-Id-Version: PROJECT VERSION\\n\"\n";

		$output .= "\"POT-Creation-Date: " . date("Y-m-d H:iO") . "\\n\"\n";

		$output .= "\"PO-Revision-Date: YYYY-mm-DD HH:MM+ZZZZ\\n\"\n";

		$output .= "\"Last-Translator: NAME <EMAIL@ADDRESS>\\n\"\n";

		$output .= "\"Language-Team: LANGUAGE <EMAIL@ADDRESS>\\n\"\n";

		$output .= "\"MIME-Version: 1.0\\n\"\n";

		$output .= "\"Content-Type: text/plain; charset=utf-8\\n\"\n";

		$output .= "\"Content-Transfer-Encoding: 8bit\\n\"\n";

		$output .= "\"Plural-Forms: nplurals=INTEGER; plural=EXPRESSION;\\n\"\n\n";

		return $output;

	}

/**

 * Get the strings from the position forward

 *

 * @param integer $position Actual position on tokens array

 * @param integer $target Number of strings to extract

 * @return array Strings extracted

 */

	protected function _getStrings(&$position, $target) {

		$strings = array();

		$count = count($strings);

		while ($count < $target && ($this->_tokens[$position] === ',' || $this->_tokens[$position][0] == T_CONSTANT_ENCAPSED_STRING || $this->_tokens[$position][0] == T_LNUMBER)) {

			$count = count($strings);

			if ($this->_tokens[$position][0] == T_CONSTANT_ENCAPSED_STRING && $this->_tokens[$position + 1] === '.') {

				$string = '';

				while ($this->_tokens[$position][0] == T_CONSTANT_ENCAPSED_STRING || $this->_tokens[$position] === '.') {

					if ($this->_tokens[$position][0] == T_CONSTANT_ENCAPSED_STRING) {

						$string .= $this->_formatString($this->_tokens[$position][1]);

					}

					$position++;

				}

				$strings[] = $string;

			} elseif ($this->_tokens[$position][0] == T_CONSTANT_ENCAPSED_STRING) {

				$strings[] = $this->_formatString($this->_tokens[$position][1]);

			} elseif ($this->_tokens[$position][0] == T_LNUMBER) {

				$strings[] = $this->_tokens[$position][1];

			}

			$position++;

		}

		return $strings;

	}

/**

 * Format a string to be added as a translatable string

 *

 * @param string $string String to format

 * @return string Formatted string

 */

	protected function _formatString($string) {

		$quote = substr($string, 0, 1);

		$string = substr($string, 1, -1);

		if ($quote === '"') {

			$string = stripcslashes($string);

		} else {

			$string = strtr($string, array("\\'" => "'", "\\\\" => "\\"));

		}

		$string = str_replace("\r\n", "\n", $string);

		return addcslashes($string, "\0..\37\\\"");

	}

/**

 * Indicate an invalid marker on a processed file

 *

 * @param string $file File where invalid marker resides

 * @param integer $line Line number

 * @param string $marker Marker found

 * @param integer $count Count

 * @return void

 */

	protected function _markerError($file, $line, $marker, $count) {

		$this->out(__d('cake_console', "Invalid marker content in %s:%s\n* %s(", $file, $line, $marker));

		$count += 2;

		$tokenCount = count($this->_tokens);

		$parenthesis = 1;

		while ((($tokenCount - $count) > 0) && $parenthesis) {

			if (is_array($this->_tokens[$count])) {

				$this->out($this->_tokens[$count][1], false);

			} else {

				$this->out($this->_tokens[$count], false);

				if ($this->_tokens[$count] === '(') {

					$parenthesis++;

				}

				if ($this->_tokens[$count] === ')') {

					$parenthesis--;

				}

			}

			$count++;

		}

		$this->out("\n", true);

	}

/**

 * Search files that may contain translatable strings

 *

 * @return void

 */

	protected function _searchFiles() {

		$pattern = false;

		if (!empty($this->_exclude)) {

			$exclude = array();

			foreach ($this->_exclude as $e) {

				if (DS !== '\\' && $e[0] !== DS) {

					$e = DS . $e;

				}

				$exclude[] = preg_quote($e, '/');

			}

			$pattern = '/' . implode('|', $exclude) . '/';

		}

		foreach ($this->_paths as $path) {

			$Folder = new Folder($path);

			$files = $Folder->findRecursive('.*\.(php|ctp|thtml|inc|tpl)', true);

			if (!empty($pattern)) {

				foreach ($files as $i => $file) {

					if (preg_match($pattern, $file)) {

						unset($files[$i]);

					}

				}

				$files = array_values($files);

			}

			$this->_files = array_merge($this->_files, $files);

		}

	}

/**

 * Returns whether this execution is meant to extract string only from directories in folder represented by the

 * APP constant, i.e. this task is extracting strings from same application.

 *

 * @return boolean

 */

	protected function _isExtractingApp() {

		return $this->_paths === array(APP);

	}

/**

 * Checks whether or not a given path is usable for writing.

 *

 * @param string $path Path to folder

 * @return boolean true if it exists and is writable, false otherwise

 */

	protected function _isPathUsable($path) {

		return is_dir($path) && is_writable($path);

	}

}