Mike Jolley
commit
92df0d2019
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,209 @@
|
|||
<?php
|
||||
require_once dirname( __FILE__ ) . '/../pomo/entry.php';
|
||||
require_once dirname( __FILE__ ) . '/../pomo/translations.php';
|
||||
|
||||
class StringExtractor {
|
||||
|
||||
var $rules = array();
|
||||
var $comment_prefix = 'translators:';
|
||||
|
||||
function __construct( $rules = array() ) {
|
||||
$this->rules = $rules;
|
||||
}
|
||||
|
||||
function extract_from_directory( $dir, $excludes = array(), $includes = array(), $prefix = '' ) {
|
||||
$old_cwd = getcwd();
|
||||
chdir( $dir );
|
||||
$translations = new Translations;
|
||||
$file_names = (array) scandir( '.' );
|
||||
foreach ( $file_names as $file_name ) {
|
||||
if ( '.' == $file_name || '..' == $file_name ) continue;
|
||||
if ( preg_match( '/\.php$/', $file_name ) && $this->does_file_name_match( $prefix . $file_name, $excludes, $includes ) ) {
|
||||
$translations->merge_originals_with( $this->extract_from_file( $file_name, $prefix ) );
|
||||
}
|
||||
if ( is_dir( $file_name ) ) {
|
||||
$translations->merge_originals_with( $this->extract_from_directory( $file_name, $excludes, $includes, $prefix . $file_name . '/' ) );
|
||||
}
|
||||
}
|
||||
chdir( $old_cwd );
|
||||
return $translations;
|
||||
}
|
||||
|
||||
function extract_from_file( $file_name, $prefix ) {
|
||||
$code = file_get_contents( $file_name );
|
||||
return $this->extract_entries( $code, $prefix . $file_name );
|
||||
}
|
||||
|
||||
function does_file_name_match( $path, $excludes, $includes ) {
|
||||
if ( $includes ) {
|
||||
$matched_any_include = false;
|
||||
foreach( $includes as $include ) {
|
||||
if ( preg_match( '|^'.$include.'$|', $path ) ) {
|
||||
$matched_any_include = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if ( !$matched_any_include ) return false;
|
||||
}
|
||||
if ( $excludes ) {
|
||||
foreach( $excludes as $exclude ) {
|
||||
if ( preg_match( '|^'.$exclude.'$|', $path ) ) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
function entry_from_call( $call, $file_name ) {
|
||||
$rule = isset( $this->rules[$call['name']] )? $this->rules[$call['name']] : null;
|
||||
if ( !$rule ) return null;
|
||||
$entry = new Translation_Entry;
|
||||
$multiple = array();
|
||||
$complete = false;
|
||||
for( $i = 0; $i < count( $rule ); ++$i ) {
|
||||
if ( $rule[$i] && ( !isset( $call['args'][$i] ) || !is_string( $call['args'][$i] ) || '' == $call['args'][$i] ) ) return false;
|
||||
switch( $rule[$i] ) {
|
||||
case 'string':
|
||||
if ( $complete ) {
|
||||
$multiple[] = $entry;
|
||||
$entry = new Translation_Entry;
|
||||
$complete = false;
|
||||
}
|
||||
$entry->singular = $call['args'][$i];
|
||||
$complete = true;
|
||||
break;
|
||||
case 'singular':
|
||||
if ( $complete ) {
|
||||
$multiple[] = $entry;
|
||||
$entry = new Translation_Entry;
|
||||
$complete = false;
|
||||
}
|
||||
$entry->singular = $call['args'][$i];
|
||||
$entry->is_plural = true;
|
||||
break;
|
||||
case 'plural':
|
||||
$entry->plural = $call['args'][$i];
|
||||
$entry->is_plural = true;
|
||||
$complete = true;
|
||||
break;
|
||||
case 'context':
|
||||
$entry->context = $call['args'][$i];
|
||||
foreach( $multiple as &$single_entry ) {
|
||||
$single_entry->context = $entry->context;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
if ( isset( $call['line'] ) && $call['line'] ) {
|
||||
$references = array( $file_name . ':' . $call['line'] );
|
||||
$entry->references = $references;
|
||||
foreach( $multiple as &$single_entry ) {
|
||||
$single_entry->references = $references;
|
||||
}
|
||||
}
|
||||
if ( isset( $call['comment'] ) && $call['comment'] ) {
|
||||
$comments = rtrim( $call['comment'] ) . "\n";
|
||||
$entry->extracted_comments = $comments;
|
||||
foreach( $multiple as &$single_entry ) {
|
||||
$single_entry->extracted_comments = $comments;
|
||||
}
|
||||
}
|
||||
if ( $multiple && $entry ) {
|
||||
$multiple[] = $entry;
|
||||
return $multiple;
|
||||
}
|
||||
|
||||
return $entry;
|
||||
}
|
||||
|
||||
function extract_entries( $code, $file_name ) {
|
||||
$translations = new Translations;
|
||||
$function_calls = $this->find_function_calls( array_keys( $this->rules ), $code );
|
||||
foreach( $function_calls as $call ) {
|
||||
$entry = $this->entry_from_call( $call, $file_name );
|
||||
if ( is_array( $entry ) )
|
||||
foreach( $entry as $single_entry )
|
||||
$translations->add_entry_or_merge( $single_entry );
|
||||
elseif ( $entry)
|
||||
$translations->add_entry_or_merge( $entry );
|
||||
}
|
||||
return $translations;
|
||||
}
|
||||
|
||||
/**
|
||||
* Finds all function calls in $code and returns an array with an associative array for each function:
|
||||
* - name - name of the function
|
||||
* - args - array for the function arguments. Each string literal is represented by itself, other arguments are represented by null.
|
||||
* - line - line number
|
||||
*/
|
||||
function find_function_calls( $function_names, $code ) {
|
||||
$tokens = token_get_all( $code );
|
||||
$function_calls = array();
|
||||
$latest_comment = false;
|
||||
$in_func = false;
|
||||
foreach( $tokens as $token ) {
|
||||
$id = $text = null;
|
||||
if ( is_array( $token ) ) list( $id, $text, $line ) = $token;
|
||||
if ( T_WHITESPACE == $id ) continue;
|
||||
if ( T_STRING == $id && in_array( $text, $function_names ) && !$in_func ) {
|
||||
$in_func = true;
|
||||
$paren_level = -1;
|
||||
$args = array();
|
||||
$func_name = $text;
|
||||
$func_line = $line;
|
||||
$func_comment = $latest_comment? $latest_comment : '';
|
||||
|
||||
$just_got_into_func = true;
|
||||
$latest_comment = false;
|
||||
continue;
|
||||
}
|
||||
if ( T_COMMENT == $id ) {
|
||||
$text = trim( preg_replace( '%^/\*|//%', '', preg_replace( '%\*/$%', '', $text ) ) );
|
||||
if ( 0 === strpos( $text, $this->comment_prefix ) ) {
|
||||
$latest_comment = $text;
|
||||
}
|
||||
}
|
||||
if ( !$in_func ) continue;
|
||||
if ( '(' == $token ) {
|
||||
$paren_level++;
|
||||
if ( 0 == $paren_level ) { // start of first argument
|
||||
$just_got_into_func = false;
|
||||
$current_argument = null;
|
||||
$current_argument_is_just_literal = true;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if ( $just_got_into_func ) {
|
||||
// there wasn't a opening paren just after the function name -- this means it is not a function
|
||||
$in_func = false;
|
||||
$just_got_into_func = false;
|
||||
}
|
||||
if ( ')' == $token ) {
|
||||
if ( 0 == $paren_level ) {
|
||||
$in_func = false;
|
||||
$args[] = $current_argument;
|
||||
$call = array( 'name' => $func_name, 'args' => $args, 'line' => $func_line );
|
||||
if ( $func_comment ) $call['comment'] = $func_comment;
|
||||
$function_calls[] = $call;
|
||||
}
|
||||
$paren_level--;
|
||||
continue;
|
||||
}
|
||||
if ( ',' == $token && 0 == $paren_level ) {
|
||||
$args[] = $current_argument;
|
||||
$current_argument = null;
|
||||
$current_argument_is_just_literal = true;
|
||||
continue;
|
||||
}
|
||||
if ( T_CONSTANT_ENCAPSED_STRING == $id && $current_argument_is_just_literal ) {
|
||||
// we can use eval safely, because we are sure $text is just a string literal
|
||||
eval('$current_argument = '.$text.';' );
|
||||
continue;
|
||||
}
|
||||
$current_argument_is_just_literal = false;
|
||||
$current_argument = null;
|
||||
}
|
||||
return $function_calls;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,119 @@
|
|||
<?php
|
||||
/**
|
||||
* Web interface for generating the WooCommerce POT files
|
||||
*
|
||||
* @since 2.0
|
||||
* @package WooCommerce
|
||||
* @author Geert De Deckere
|
||||
*/
|
||||
|
||||
/**
|
||||
* Note: this file is locked by default since it should not be publicly accessible
|
||||
* on a live website. You can unlock it by temporarily removing the following line.
|
||||
*/
|
||||
exit( 'Locked' );
|
||||
|
||||
// Load the makepot generator
|
||||
require './makepot.php';
|
||||
$makepot = new WC_Makepot;
|
||||
|
||||
// Regeneration requested
|
||||
if ( ! empty( $_GET['generate'] ) ) {
|
||||
// Generate woocommerce and woocommerce-admin POT files
|
||||
$results = array();
|
||||
foreach ( $makepot->projects as $name => $project ) {
|
||||
$results[ $name ] = $makepot->generate_pot( $name );
|
||||
}
|
||||
}
|
||||
|
||||
// Load WooCommerce POT-files info
|
||||
$pot_files = array();
|
||||
foreach( $makepot->projects as $name => $project ) {
|
||||
$pot_files[ $name ] = array(
|
||||
'file' => $project['file'],
|
||||
'file_exists' => file_exists( $project['file'] ),
|
||||
'is_readable' => is_readable( $project['file'] ),
|
||||
'is_writable' => is_writable( $project['file'] ),
|
||||
'filemtime' => ( is_readable( $project['file'] ) ) ? filemtime( $project['file'] ) : false,
|
||||
'filesize' => ( is_readable( $project['file'] ) ) ? filesize( $project['file'] ) : false,
|
||||
);
|
||||
}
|
||||
?>
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
|
||||
<meta charset="utf-8">
|
||||
<title>WooCommerce POT Generator</title>
|
||||
<style>
|
||||
html { font-family:monospace; }
|
||||
ul { margin-bottom:1em; }
|
||||
ul ul { padding-left:0; list-style:none; color:#999; }
|
||||
|
||||
.success { color:green; }
|
||||
.error { color:red; }
|
||||
.button { display:inline-block; padding:0.5em 1em; background:#ddd; font-weight:bold; color:#000; text-decoration:none; }
|
||||
.button:hover { background:#ccc; }
|
||||
.button.disabled { background:#eee; color:#888; cursor:default; }
|
||||
|
||||
@-webkit-keyframes rotate { from { -webkit-transform:rotate(0deg); } to { -webkit-transform:rotate(360deg); } }
|
||||
@-moz-keyframes rotate { from { -moz-transform:rotate(0deg); } to { -moz-transform:rotate(360deg); } }
|
||||
@keyframes rotate { from { transform:rotate(0deg); } to { transform:rotate(360deg); } }
|
||||
.spinner { display:inline-block;
|
||||
-webkit-animation:rotate 0.4s linear infinite;
|
||||
-moz-animation:rotate 0.4s linear infinite;
|
||||
animation:rotate 0.4s linear infinite;
|
||||
}
|
||||
</style>
|
||||
|
||||
</head>
|
||||
<body>
|
||||
|
||||
<h1>WooCommerce <?php echo $makepot->woocommerce_version() ?> POT Generator</h1>
|
||||
|
||||
<?php if ( ! empty( $results ) ) { ?>
|
||||
<ul>
|
||||
<?php foreach ( $results as $pot_file => $succeeded ) { ?>
|
||||
<?php if ( $succeeded ) { ?>
|
||||
<li class="success"><strong><?php echo basename( $pot_files[ $pot_file ]['file'] ) ?> successfully generated.</strong></li>
|
||||
<?php } else { ?>
|
||||
<li class="error"><strong><?php echo basename( $pot_files[ $pot_file ]['file'] ) ?> could not be generated.</strong></li>
|
||||
<?php } ?>
|
||||
<?php } ?>
|
||||
</ul>
|
||||
<?php } ?>
|
||||
|
||||
<p>This tool will (re)generate and overwrite the following WooCommerce POT-files:</p>
|
||||
|
||||
<ul>
|
||||
<?php foreach ( $pot_files as $pot_file ) { ?>
|
||||
<li>
|
||||
<strong><?php echo basename( $pot_file['file'] ) ?></strong>
|
||||
<?php if ( $pot_file['is_writable'] ) { ?>
|
||||
<strong class="success">[writable]</strong>
|
||||
<?php } else { ?>
|
||||
<strong class="error">[not writable]</strong>
|
||||
<?php } ?>
|
||||
<ul>
|
||||
<li>Path: <?php echo dirname( $pot_file['file'] ) . '/' ?></li>
|
||||
<li>Size: <?php echo ( $pot_file['file_exists'] ) ? number_format( $pot_file['filesize'], 0 ) . ' bytes' : '--' ?></li>
|
||||
<li>Last updated: <?php echo ( $pot_file['filemtime'] ) ? @date( 'F jS Y H:i:s', $pot_file['filemtime'] ) : '--' ?></li>
|
||||
</ul>
|
||||
</li>
|
||||
<?php } ?>
|
||||
</ul>
|
||||
|
||||
<p>
|
||||
<a id="submit" class="button" href="?generate=1">Generate POT-files now</a>
|
||||
</p>
|
||||
|
||||
<script>
|
||||
// Show a loading animation
|
||||
document.getElementById('submit').onclick = function () {
|
||||
this.className += ' disabled';
|
||||
this.innerHTML = 'Generating POT-files <span class="spinner">/</span>';
|
||||
};
|
||||
</script>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
|
|
@ -0,0 +1,160 @@
|
|||
<?php
|
||||
/**
|
||||
* WooCommerce POT Generator
|
||||
*
|
||||
* Contains the methods for generating the woocommerce.pot and woocommerce-admin.pot files.
|
||||
* Code is based on: http://i18n.trac.wordpress.org/browser/tools/trunk/makepot.php
|
||||
*
|
||||
* @class WC_Makepot
|
||||
* @since 2.0
|
||||
* @package WooCommerce
|
||||
* @author Geert De Deckere
|
||||
*/
|
||||
class WC_Makepot {
|
||||
|
||||
/**
|
||||
* @var string Filesystem directory path for the WooCommerce plugin (with trailing slash)
|
||||
*/
|
||||
public $woocommerce_path;
|
||||
|
||||
/**
|
||||
* @var array All available projects with their settings
|
||||
*/
|
||||
public $projects;
|
||||
|
||||
/**
|
||||
* @var object StringExtractor
|
||||
*/
|
||||
public $extractor;
|
||||
|
||||
/**
|
||||
* @var array Rules for StringExtractor
|
||||
*/
|
||||
public $rules = array(
|
||||
'_' => array( 'string' ),
|
||||
'__' => array( 'string' ),
|
||||
'_e' => array( 'string' ),
|
||||
'_c' => array( 'string' ),
|
||||
'_n' => array( 'singular', 'plural' ),
|
||||
'_n_noop' => array( 'singular', 'plural' ),
|
||||
'_nc' => array( 'singular', 'plural' ),
|
||||
'__ngettext' => array( 'singular', 'plural' ),
|
||||
'__ngettext_noop' => array( 'singular', 'plural' ),
|
||||
'_x' => array( 'string', 'context' ),
|
||||
'_ex' => array( 'string', 'context' ),
|
||||
'_nx' => array( 'singular', 'plural', null, 'context' ),
|
||||
'_nx_noop' => array( 'singular', 'plural', 'context' ),
|
||||
'_n_js' => array( 'singular', 'plural' ),
|
||||
'_nx_js' => array( 'singular', 'plural', 'context' ),
|
||||
'esc_attr__' => array( 'string' ),
|
||||
'esc_html__' => array( 'string' ),
|
||||
'esc_attr_e' => array( 'string' ),
|
||||
'esc_html_e' => array( 'string' ),
|
||||
'esc_attr_x' => array( 'string', 'context' ),
|
||||
'esc_html_x' => array( 'string', 'context' ),
|
||||
);
|
||||
|
||||
/**
|
||||
* Constructor
|
||||
*
|
||||
* @access public
|
||||
* @return void
|
||||
*/
|
||||
public function __construct() {
|
||||
// Default path
|
||||
$this->set_woocommerce_path( '../../' );
|
||||
|
||||
// All available projects with their settings
|
||||
$this->projects = array(
|
||||
'woocommerce' => array(
|
||||
'title' => 'Front-end',
|
||||
'file' => $this->woocommerce_path . 'i18n/languages/woocommerce.pot',
|
||||
'excludes' => array( 'admin/.*' ),
|
||||
'includes' => array(),
|
||||
),
|
||||
'woocommerce-admin' => array(
|
||||
'title' => 'Admin',
|
||||
'file' => $this->woocommerce_path . 'i18n/languages/woocommerce-admin.pot',
|
||||
'excludes' => array(),
|
||||
'includes' => array( 'admin/.*' ),
|
||||
),
|
||||
);
|
||||
|
||||
// Ignore some strict standards notices caused by extract/extract.php
|
||||
error_reporting(E_ALL);
|
||||
|
||||
// Load required files and objects
|
||||
require_once './not-gettexted.php';
|
||||
require_once './pot-ext-meta.php';
|
||||
require_once './extract/extract.php';
|
||||
$this->extractor = new StringExtractor( $this->rules );
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the WooCommerce filesystem directory path
|
||||
*
|
||||
* @param string $path
|
||||
* @return void
|
||||
*/
|
||||
public function set_woocommerce_path( $path ) {
|
||||
$this->woocommerce_path = realpath( $path ) . '/';
|
||||
}
|
||||
|
||||
/**
|
||||
* POT generator
|
||||
*
|
||||
* @param string $project "woocommerce" or "woocommerce-admin"
|
||||
* @return bool true on success, false on error
|
||||
*/
|
||||
public function generate_pot( $project = 'woocommerce' ) {
|
||||
// Unknown project
|
||||
if ( empty( $this->projects[ $project ] ) )
|
||||
return false;
|
||||
|
||||
// Project config
|
||||
$config = $this->projects[ $project ];
|
||||
|
||||
// Extract translatable strings from the WooCommerce plugin
|
||||
$originals = $this->extractor->extract_from_directory( $this->woocommerce_path, $config['excludes'], $config['includes'] );
|
||||
|
||||
// Build POT file
|
||||
$pot = new PO;
|
||||
$pot->entries = $originals->entries;
|
||||
$pot->set_header( 'Project-Id-Version', 'WooCommerce ' . $this->woocommerce_version() . ' ' . $config['title'] );
|
||||
$pot->set_header( 'Report-Msgid-Bugs-To', 'https://github.com/woothemes/woocommerce/issues' );
|
||||
$pot->set_header( 'POT-Creation-Date', gmdate( 'Y-m-d H:i:s+00:00' ) );
|
||||
$pot->set_header( 'MIME-Version', '1.0' );
|
||||
$pot->set_header( 'Content-Type', 'text/plain; charset=UTF-8' );
|
||||
$pot->set_header( 'Content-Transfer-Encoding', '8bit' );
|
||||
$pot->set_header( 'PO-Revision-Date', gmdate( 'Y' ) . '-MO-DA HO:MI+ZONE' );
|
||||
$pot->set_header( 'Last-Translator', 'FULL NAME <EMAIL@ADDRESS>' );
|
||||
$pot->set_header( 'Language-Team', 'LANGUAGE <EMAIL@ADDRESS>' );
|
||||
|
||||
// Write POT file
|
||||
return $pot->export_to_file( $config['file'] );
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves the WooCommerce version from the woocommerce.php file.
|
||||
*
|
||||
* @access public
|
||||
* @return string|false WooCommerce version number, false if not found
|
||||
*/
|
||||
public function woocommerce_version() {
|
||||
// Only run this method once
|
||||
static $version;
|
||||
if ( null !== $version )
|
||||
return $version;
|
||||
|
||||
// File that contains the WooCommerce version number
|
||||
$file = $this->woocommerce_path . 'woocommerce.php';
|
||||
|
||||
if ( is_readable( $file ) && preg_match( '/\bVersion:\s*+(\S+)/i', file_get_contents( $file ), $matches ) )
|
||||
$version = $matches[1];
|
||||
else
|
||||
$version = false;
|
||||
|
||||
return $version;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,234 @@
|
|||
<?php
|
||||
/**
|
||||
* Console application, which extracts or replaces strings for
|
||||
* translation, which cannot be gettexted
|
||||
*
|
||||
* @version $Id: not-gettexted.php 19275 2012-02-10 17:47:42Z nacin $
|
||||
* @package wordpress-i18n
|
||||
* @subpackage tools
|
||||
*/
|
||||
// see: http://php.net/tokenizer
|
||||
if (!defined('T_ML_COMMENT'))
|
||||
define('T_ML_COMMENT', T_COMMENT);
|
||||
else
|
||||
define('T_DOC_COMMENT', T_ML_COMMENT);
|
||||
|
||||
require_once dirname( __FILE__ ) . '/pomo/po.php';
|
||||
require_once dirname( __FILE__ ) . '/pomo/mo.php';
|
||||
|
||||
class NotGettexted {
|
||||
var $enable_logging = false;
|
||||
|
||||
var $STAGE_OUTSIDE = 0;
|
||||
var $STAGE_START_COMMENT = 1;
|
||||
var $STAGE_WHITESPACE_BEFORE = 2;
|
||||
var $STAGE_STRING = 3;
|
||||
var $STAGE_WHITESPACE_AFTER = 4;
|
||||
var $STAGE_END_COMMENT = 4;
|
||||
|
||||
var $commands = array('extract' => 'command_extract', 'replace' => 'command_replace' );
|
||||
|
||||
|
||||
function logmsg() {
|
||||
$args = func_get_args();
|
||||
if ($this->enable_logging) error_log(implode(' ', $args));
|
||||
}
|
||||
|
||||
function stderr($msg, $nl=true) {
|
||||
fwrite(STDERR, $msg.($nl? "\n" : ""));
|
||||
}
|
||||
|
||||
function cli_die($msg) {
|
||||
$this->stderr($msg);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
function unchanged_token($token, $s='') {
|
||||
return is_array($token)? $token[1] : $token;
|
||||
}
|
||||
|
||||
function ignore_token($token, $s='') {
|
||||
return '';
|
||||
}
|
||||
|
||||
function list_php_files($dir) {
|
||||
$files = array();
|
||||
$items = scandir( $dir );
|
||||
foreach ( (array) $items as $item ) {
|
||||
$full_item = $dir . '/' . $item;
|
||||
if ('.' == $item || '..' == $item)
|
||||
continue;
|
||||
if ('.php' == substr($item, -4))
|
||||
$files[] = $full_item;
|
||||
if (is_dir($full_item))
|
||||
$files += array_merge($files, NotGettexted::list_php_files($full_item, $files));
|
||||
}
|
||||
return $files;
|
||||
}
|
||||
|
||||
|
||||
function make_string_aggregator($global_array_name, $filename) {
|
||||
$a = $global_array_name;
|
||||
return create_function('$string, $comment_id, $line_number', 'global $'.$a.'; $'.$a.'[] = array($string, $comment_id, '.var_export($filename, true).', $line_number);');
|
||||
}
|
||||
|
||||
function make_mo_replacer($global_mo_name) {
|
||||
$m = $global_mo_name;
|
||||
return create_function('$token, $string', 'global $'.$m.'; return var_export($'.$m.'->translate($string), true);');
|
||||
}
|
||||
|
||||
function walk_tokens(&$tokens, $string_action, $other_action, $register_action=null) {
|
||||
|
||||
$current_comment_id = '';
|
||||
$current_string = '';
|
||||
$current_string_line = 0;
|
||||
|
||||
$result = '';
|
||||
$line = 1;
|
||||
|
||||
foreach($tokens as $token) {
|
||||
if (is_array($token)) {
|
||||
list($id, $text) = $token;
|
||||
$line += substr_count($text, "\n");
|
||||
if ((T_ML_COMMENT == $id || T_COMMENT == $id) && preg_match('|/\*\s*(/?WP_I18N_[a-z_]+)\s*\*/|i', $text, $matches)) {
|
||||
if ($this->STAGE_OUTSIDE == $stage) {
|
||||
$stage = $this->STAGE_START_COMMENT;
|
||||
$current_comment_id = $matches[1];
|
||||
$this->logmsg('start comment', $current_comment_id);
|
||||
$result .= call_user_func($other_action, $token);
|
||||
continue;
|
||||
}
|
||||
if ($this->STAGE_START_COMMENT <= $stage && $stage <= $this->STAGE_WHITESPACE_AFTER && '/'.$current_comment_id == $matches[1]) {
|
||||
$stage = $this->STAGE_END_COMMENT;
|
||||
$this->logmsg('end comment', $current_comment_id);
|
||||
$result .= call_user_func($other_action, $token);
|
||||
if (!is_null($register_action)) call_user_func($register_action, $current_string, $current_comment_id, $current_string_line);
|
||||
continue;
|
||||
}
|
||||
} else if (T_CONSTANT_ENCAPSED_STRING == $id) {
|
||||
if ($this->STAGE_START_COMMENT <= $stage && $stage < $this->STAGE_WHITESPACE_AFTER) {
|
||||
eval('$current_string='.$text.';');
|
||||
$this->logmsg('string', $current_string);
|
||||
$current_string_line = $line;
|
||||
$result .= call_user_func($string_action, $token, $current_string);
|
||||
continue;
|
||||
}
|
||||
} else if (T_WHITESPACE == $id) {
|
||||
if ($this->STAGE_START_COMMENT <= $stage && $stage < $this->STAGE_STRING) {
|
||||
$stage = $this->STAGE_WHITESPACE_BEFORE;
|
||||
$this->logmsg('whitespace before');
|
||||
$result .= call_user_func($other_action, $token);
|
||||
continue;
|
||||
}
|
||||
if ($this->STAGE_STRING < $stage && $stage < $this->STAGE_END_COMMENT) {
|
||||
$stage = $this->STAGE_WHITESPACE_AFTER;
|
||||
$this->logmsg('whitespace after');
|
||||
$result .= call_user_func($other_action, $token);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
$result .= call_user_func($other_action, $token);
|
||||
$stage = $this->STAGE_OUTSIDE;
|
||||
$current_comment_id = '';
|
||||
$current_string = '';
|
||||
$current_string_line = 0;
|
||||
}
|
||||
return $result;
|
||||
}
|
||||
|
||||
|
||||
function command_extract() {
|
||||
$args = func_get_args();
|
||||
$pot_filename = $args[0];
|
||||
if (isset($args[1]) && is_array($args[1]))
|
||||
$filenames = $args[1];
|
||||
else
|
||||
$filenames = array_slice($args, 1);
|
||||
|
||||
$global_name = '__entries_'.mt_rand(1, 1000);
|
||||
$GLOBALS[$global_name] = array();
|
||||
|
||||
foreach($filenames as $filename) {
|
||||
$tokens = token_get_all(file_get_contents($filename));
|
||||
$aggregator = $this->make_string_aggregator($global_name, $filename);
|
||||
$this->walk_tokens($tokens, array(&$this, 'ignore_token'), array(&$this, 'ignore_token'), $aggregator);
|
||||
}
|
||||
|
||||
$potf = '-' == $pot_filename? STDOUT : @fopen($pot_filename, 'a');
|
||||
if (false === $potf) {
|
||||
$this->cli_die("Couldn't open pot file: $pot_filename");
|
||||
}
|
||||
|
||||
foreach($GLOBALS[$global_name] as $item) {
|
||||
@list($string, $comment_id, $filename, $line_number) = $item;
|
||||
$filename = isset($filename)? preg_replace('|^\./|', '', $filename) : '';
|
||||
$ref_line_number = isset($line_number)? ":$line_number" : '';
|
||||
$args = array(
|
||||
'singular' => $string,
|
||||
'extracted_comments' => "Not gettexted string $comment_id",
|
||||
'references' => array("$filename$ref_line_number"),
|
||||
);
|
||||
$entry = new Translation_Entry($args);
|
||||
fwrite($potf, "\n".PO::export_entry($entry)."\n");
|
||||
}
|
||||
if ('-' != $pot_filename) fclose($potf);
|
||||
return true;
|
||||
}
|
||||
|
||||
function command_replace() {
|
||||
$args = func_get_args();
|
||||
$mo_filename = $args[0];
|
||||
if (isset($args[1]) && is_array($args[1]))
|
||||
$filenames = $args[1];
|
||||
else
|
||||
$filenames = array_slice($args, 1);
|
||||
|
||||
$global_name = '__mo_'.mt_rand(1, 1000);
|
||||
$GLOBALS[$global_name] = new MO();
|
||||
$replacer = $this->make_mo_replacer($global_name);
|
||||
|
||||
$res = $GLOBALS[$global_name]->import_from_file($mo_filename);
|
||||
if (false === $res) {
|
||||
$this->cli_die("Couldn't read MO file '$mo_filename'!");
|
||||
}
|
||||
foreach($filenames as $filename) {
|
||||
$source = file_get_contents($filename);
|
||||
if ( strlen($source) > 150000 ) continue;
|
||||
$tokens = token_get_all($source);
|
||||
$new_file = $this->walk_tokens($tokens, $replacer, array(&$this, 'unchanged_token'));
|
||||
$f = fopen($filename, 'w');
|
||||
fwrite($f, $new_file);
|
||||
fclose($f);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
function usage() {
|
||||
$this->stderr('php i18n-comments.php COMMAND OUTPUTFILE INPUTFILES');
|
||||
$this->stderr('Extracts and replaces strings, which cannot be gettexted');
|
||||
$this->stderr('Commands:');
|
||||
$this->stderr(' extract POTFILE PHPFILES appends the strings to POTFILE');
|
||||
$this->stderr(' replace MOFILE PHPFILES replaces strings in PHPFILES with translations from MOFILE');
|
||||
}
|
||||
|
||||
function cli() {
|
||||
global $argv, $commands;
|
||||
if (count($argv) < 4 || !in_array($argv[1], array_keys($this->commands))) {
|
||||
$this->usage();
|
||||
exit(1);
|
||||
}
|
||||
call_user_func_array(array(&$this, $this->commands[$argv[1]]), array_slice($argv, 2));
|
||||
}
|
||||
}
|
||||
|
||||
// run the CLI only if the file
|
||||
// wasn't included
|
||||
$included_files = get_included_files();
|
||||
if ($included_files[0] == __FILE__) {
|
||||
error_reporting(E_ALL);
|
||||
$not_gettexted = new NotGettexted;
|
||||
$not_gettexted->cli();
|
||||
}
|
||||
|
||||
?>
|
||||
|
|
@ -0,0 +1,78 @@
|
|||
<?php
|
||||
/**
|
||||
* Contains Translation_Entry class
|
||||
*
|
||||
* @version $Id: entry.php 718 2012-10-31 00:32:02Z nbachiyski $
|
||||
* @package pomo
|
||||
* @subpackage entry
|
||||
*/
|
||||
|
||||
if ( !class_exists( 'Translation_Entry' ) ):
|
||||
/**
|
||||
* Translation_Entry class encapsulates a translatable string
|
||||
*/
|
||||
class Translation_Entry {
|
||||
|
||||
/**
|
||||
* Whether the entry contains a string and its plural form, default is false
|
||||
*
|
||||
* @var boolean
|
||||
*/
|
||||
var $is_plural = false;
|
||||
|
||||
var $context = null;
|
||||
var $singular = null;
|
||||
var $plural = null;
|
||||
var $translations = array();
|
||||
var $translator_comments = '';
|
||||
var $extracted_comments = '';
|
||||
var $references = array();
|
||||
var $flags = array();
|
||||
|
||||
/**
|
||||
* @param array $args associative array, support following keys:
|
||||
* - singular (string) -- the string to translate, if omitted and empty entry will be created
|
||||
* - plural (string) -- the plural form of the string, setting this will set {@link $is_plural} to true
|
||||
* - translations (array) -- translations of the string and possibly -- its plural forms
|
||||
* - context (string) -- a string differentiating two equal strings used in different contexts
|
||||
* - translator_comments (string) -- comments left by translators
|
||||
* - extracted_comments (string) -- comments left by developers
|
||||
* - references (array) -- places in the code this strings is used, in relative_to_root_path/file.php:linenum form
|
||||
* - flags (array) -- flags like php-format
|
||||
*/
|
||||
function Translation_Entry($args=array()) {
|
||||
// if no singular -- empty object
|
||||
if (!isset($args['singular'])) {
|
||||
return;
|
||||
}
|
||||
// get member variable values from args hash
|
||||
foreach ($args as $varname => $value) {
|
||||
$this->$varname = $value;
|
||||
}
|
||||
if (isset($args['plural'])) $this->is_plural = true;
|
||||
if (!is_array($this->translations)) $this->translations = array();
|
||||
if (!is_array($this->references)) $this->references = array();
|
||||
if (!is_array($this->flags)) $this->flags = array();
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates a unique key for this entry
|
||||
*
|
||||
* @return string|bool the key or false if the entry is empty
|
||||
*/
|
||||
function key() {
|
||||
if (is_null($this->singular)) return false;
|
||||
// prepend context and EOT, like in MO files
|
||||
return is_null($this->context)? $this->singular : $this->context.chr(4).$this->singular;
|
||||
}
|
||||
|
||||
function merge_with(&$other) {
|
||||
$this->flags = array_unique( array_merge( $this->flags, $other->flags ) );
|
||||
$this->references = array_unique( array_merge( $this->references, $other->references ) );
|
||||
if ( $this->extracted_comments != $other->extracted_comments ) {
|
||||
$this->extracted_comments .= $other->extracted_comments;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
endif;
|
||||
|
|
@ -0,0 +1,257 @@
|
|||
<?php
|
||||
/**
|
||||
* Class for working with MO files
|
||||
*
|
||||
* @version $Id: mo.php 718 2012-10-31 00:32:02Z nbachiyski $
|
||||
* @package pomo
|
||||
* @subpackage mo
|
||||
*/
|
||||
|
||||
require_once dirname(__FILE__) . '/translations.php';
|
||||
require_once dirname(__FILE__) . '/streams.php';
|
||||
|
||||
if ( !class_exists( 'MO' ) ):
|
||||
class MO extends Gettext_Translations {
|
||||
|
||||
var $_nplurals = 2;
|
||||
|
||||
/**
|
||||
* Fills up with the entries from MO file $filename
|
||||
*
|
||||
* @param string $filename MO file to load
|
||||
*/
|
||||
function import_from_file($filename) {
|
||||
$reader = new POMO_FileReader($filename);
|
||||
if (!$reader->is_resource())
|
||||
return false;
|
||||
return $this->import_from_reader($reader);
|
||||
}
|
||||
|
||||
function export_to_file($filename) {
|
||||
$fh = fopen($filename, 'wb');
|
||||
if ( !$fh ) return false;
|
||||
$res = $this->export_to_file_handle( $fh );
|
||||
fclose($fh);
|
||||
return $res;
|
||||
}
|
||||
|
||||
function export() {
|
||||
$tmp_fh = fopen("php://temp", 'r+');
|
||||
if ( !$tmp_fh ) return false;
|
||||
$this->export_to_file_handle( $tmp_fh );
|
||||
rewind( $tmp_fh );
|
||||
return stream_get_contents( $tmp_fh );
|
||||
}
|
||||
|
||||
function is_entry_good_for_export( $entry ) {
|
||||
if ( empty( $entry->translations ) ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if ( !array_filter( $entry->translations ) ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
function export_to_file_handle($fh) {
|
||||
$entries = array_filter( $this->entries, array( $this, 'is_entry_good_for_export' ) );
|
||||
ksort($entries);
|
||||
$magic = 0x950412de;
|
||||
$revision = 0;
|
||||
$total = count($entries) + 1; // all the headers are one entry
|
||||
$originals_lenghts_addr = 28;
|
||||
$translations_lenghts_addr = $originals_lenghts_addr + 8 * $total;
|
||||
$size_of_hash = 0;
|
||||
$hash_addr = $translations_lenghts_addr + 8 * $total;
|
||||
$current_addr = $hash_addr;
|
||||
fwrite($fh, pack('V*', $magic, $revision, $total, $originals_lenghts_addr,
|
||||
$translations_lenghts_addr, $size_of_hash, $hash_addr));
|
||||
fseek($fh, $originals_lenghts_addr);
|
||||
|
||||
// headers' msgid is an empty string
|
||||
fwrite($fh, pack('VV', 0, $current_addr));
|
||||
$current_addr++;
|
||||
$originals_table = chr(0);
|
||||
|
||||
foreach($entries as $entry) {
|
||||
$originals_table .= $this->export_original($entry) . chr(0);
|
||||
$length = strlen($this->export_original($entry));
|
||||
fwrite($fh, pack('VV', $length, $current_addr));
|
||||
$current_addr += $length + 1; // account for the NULL byte after
|
||||
}
|
||||
|
||||
$exported_headers = $this->export_headers();
|
||||
fwrite($fh, pack('VV', strlen($exported_headers), $current_addr));
|
||||
$current_addr += strlen($exported_headers) + 1;
|
||||
$translations_table = $exported_headers . chr(0);
|
||||
|
||||
foreach($entries as $entry) {
|
||||
$translations_table .= $this->export_translations($entry) . chr(0);
|
||||
$length = strlen($this->export_translations($entry));
|
||||
fwrite($fh, pack('VV', $length, $current_addr));
|
||||
$current_addr += $length + 1;
|
||||
}
|
||||
|
||||
fwrite($fh, $originals_table);
|
||||
fwrite($fh, $translations_table);
|
||||
return true;
|
||||
}
|
||||
|
||||
function export_original($entry) {
|
||||
//TODO: warnings for control characters
|
||||
$exported = $entry->singular;
|
||||
if ($entry->is_plural) $exported .= chr(0).$entry->plural;
|
||||
if (!is_null($entry->context)) $exported = $entry->context . chr(4) . $exported;
|
||||
return $exported;
|
||||
}
|
||||
|
||||
function export_translations($entry) {
|
||||
//TODO: warnings for control characters
|
||||
return implode(chr(0), $entry->translations);
|
||||
}
|
||||
|
||||
function export_headers() {
|
||||
$exported = '';
|
||||
foreach($this->headers as $header => $value) {
|
||||
$exported.= "$header: $value\n";
|
||||
}
|
||||
return $exported;
|
||||
}
|
||||
|
||||
function get_byteorder($magic) {
|
||||
// The magic is 0x950412de
|
||||
|
||||
// bug in PHP 5.0.2, see https://savannah.nongnu.org/bugs/?func=detailitem&item_id=10565
|
||||
$magic_little = (int) - 1794895138;
|
||||
$magic_little_64 = (int) 2500072158;
|
||||
// 0xde120495
|
||||
$magic_big = ((int) - 569244523) & 0xFFFFFFFF;
|
||||
if ($magic_little == $magic || $magic_little_64 == $magic) {
|
||||
return 'little';
|
||||
} else if ($magic_big == $magic) {
|
||||
return 'big';
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
function import_from_reader($reader) {
|
||||
$endian_string = MO::get_byteorder($reader->readint32());
|
||||
if (false === $endian_string) {
|
||||
return false;
|
||||
}
|
||||
$reader->setEndian($endian_string);
|
||||
|
||||
$endian = ('big' == $endian_string)? 'N' : 'V';
|
||||
|
||||
$header = $reader->read(24);
|
||||
if ($reader->strlen($header) != 24)
|
||||
return false;
|
||||
|
||||
// parse header
|
||||
$header = unpack("{$endian}revision/{$endian}total/{$endian}originals_lenghts_addr/{$endian}translations_lenghts_addr/{$endian}hash_length/{$endian}hash_addr", $header);
|
||||
if (!is_array($header))
|
||||
return false;
|
||||
|
||||
extract( $header );
|
||||
|
||||
// support revision 0 of MO format specs, only
|
||||
if ($revision != 0)
|
||||
return false;
|
||||
|
||||
// seek to data blocks
|
||||
$reader->seekto($originals_lenghts_addr);
|
||||
|
||||
// read originals' indices
|
||||
$originals_lengths_length = $translations_lenghts_addr - $originals_lenghts_addr;
|
||||
if ( $originals_lengths_length != $total * 8 )
|
||||
return false;
|
||||
|
||||
$originals = $reader->read($originals_lengths_length);
|
||||
if ( $reader->strlen( $originals ) != $originals_lengths_length )
|
||||
return false;
|
||||
|
||||
// read translations' indices
|
||||
$translations_lenghts_length = $hash_addr - $translations_lenghts_addr;
|
||||
if ( $translations_lenghts_length != $total * 8 )
|
||||
return false;
|
||||
|
||||
$translations = $reader->read($translations_lenghts_length);
|
||||
if ( $reader->strlen( $translations ) != $translations_lenghts_length )
|
||||
return false;
|
||||
|
||||
// transform raw data into set of indices
|
||||
$originals = $reader->str_split( $originals, 8 );
|
||||
$translations = $reader->str_split( $translations, 8 );
|
||||
|
||||
// skip hash table
|
||||
$strings_addr = $hash_addr + $hash_length * 4;
|
||||
|
||||
$reader->seekto($strings_addr);
|
||||
|
||||
$strings = $reader->read_all();
|
||||
$reader->close();
|
||||
|
||||
for ( $i = 0; $i < $total; $i++ ) {
|
||||
$o = unpack( "{$endian}length/{$endian}pos", $originals[$i] );
|
||||
$t = unpack( "{$endian}length/{$endian}pos", $translations[$i] );
|
||||
if ( !$o || !$t ) return false;
|
||||
|
||||
// adjust offset due to reading strings to separate space before
|
||||
$o['pos'] -= $strings_addr;
|
||||
$t['pos'] -= $strings_addr;
|
||||
|
||||
$original = $reader->substr( $strings, $o['pos'], $o['length'] );
|
||||
$translation = $reader->substr( $strings, $t['pos'], $t['length'] );
|
||||
|
||||
if ('' === $original) {
|
||||
$this->set_headers($this->make_headers($translation));
|
||||
} else {
|
||||
$entry = &$this->make_entry($original, $translation);
|
||||
$this->entries[$entry->key()] = &$entry;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Build a Translation_Entry from original string and translation strings,
|
||||
* found in a MO file
|
||||
*
|
||||
* @static
|
||||
* @param string $original original string to translate from MO file. Might contain
|
||||
* 0x04 as context separator or 0x00 as singular/plural separator
|
||||
* @param string $translation translation string from MO file. Might contain
|
||||
* 0x00 as a plural translations separator
|
||||
*/
|
||||
function &make_entry($original, $translation) {
|
||||
$entry = new Translation_Entry();
|
||||
// look for context
|
||||
$parts = explode(chr(4), $original);
|
||||
if (isset($parts[1])) {
|
||||
$original = $parts[1];
|
||||
$entry->context = $parts[0];
|
||||
}
|
||||
// look for plural original
|
||||
$parts = explode(chr(0), $original);
|
||||
$entry->singular = $parts[0];
|
||||
if (isset($parts[1])) {
|
||||
$entry->is_plural = true;
|
||||
$entry->plural = $parts[1];
|
||||
}
|
||||
// plural translations are also separated by \0
|
||||
$entry->translations = explode(chr(0), $translation);
|
||||
return $entry;
|
||||
}
|
||||
|
||||
function select_plural_form($count) {
|
||||
return $this->gettext_select_plural_form($count);
|
||||
}
|
||||
|
||||
function get_plural_forms_count() {
|
||||
return $this->_nplurals;
|
||||
}
|
||||
}
|
||||
endif;
|
||||
|
|
@ -0,0 +1,384 @@
|
|||
<?php
|
||||
/**
|
||||
* Class for working with PO files
|
||||
*
|
||||
* @version $Id: po.php 718 2012-10-31 00:32:02Z nbachiyski $
|
||||
* @package pomo
|
||||
* @subpackage po
|
||||
*/
|
||||
|
||||
require_once dirname(__FILE__) . '/translations.php';
|
||||
|
||||
define('PO_MAX_LINE_LEN', 79);
|
||||
|
||||
ini_set('auto_detect_line_endings', 1);
|
||||
|
||||
/**
|
||||
* Routines for working with PO files
|
||||
*/
|
||||
if ( !class_exists( 'PO' ) ):
|
||||
class PO extends Gettext_Translations {
|
||||
|
||||
var $comments_before_headers = '';
|
||||
|
||||
/**
|
||||
* Exports headers to a PO entry
|
||||
*
|
||||
* @return string msgid/msgstr PO entry for this PO file headers, doesn't contain newline at the end
|
||||
*/
|
||||
function export_headers() {
|
||||
$header_string = '';
|
||||
foreach($this->headers as $header => $value) {
|
||||
$header_string.= "$header: $value\n";
|
||||
}
|
||||
$poified = PO::poify($header_string);
|
||||
if ($this->comments_before_headers)
|
||||
$before_headers = $this->prepend_each_line(rtrim($this->comments_before_headers)."\n", '# ');
|
||||
else
|
||||
$before_headers = '';
|
||||
return rtrim("{$before_headers}msgid \"\"\nmsgstr $poified");
|
||||
}
|
||||
|
||||
/**
|
||||
* Exports all entries to PO format
|
||||
*
|
||||
* @return string sequence of mgsgid/msgstr PO strings, doesn't containt newline at the end
|
||||
*/
|
||||
function export_entries() {
|
||||
//TODO sorting
|
||||
return implode("\n\n", array_map(array('PO', 'export_entry'), $this->entries));
|
||||
}
|
||||
|
||||
/**
|
||||
* Exports the whole PO file as a string
|
||||
*
|
||||
* @param bool $include_headers whether to include the headers in the export
|
||||
* @return string ready for inclusion in PO file string for headers and all the enrtries
|
||||
*/
|
||||
function export($include_headers = true) {
|
||||
$res = '';
|
||||
if ($include_headers) {
|
||||
$res .= $this->export_headers();
|
||||
$res .= "\n\n";
|
||||
}
|
||||
$res .= $this->export_entries();
|
||||
return $res;
|
||||
}
|
||||
|
||||
/**
|
||||
* Same as {@link export}, but writes the result to a file
|
||||
*
|
||||
* @param string $filename where to write the PO string
|
||||
* @param bool $include_headers whether to include tje headers in the export
|
||||
* @return bool true on success, false on error
|
||||
*/
|
||||
function export_to_file($filename, $include_headers = true) {
|
||||
$fh = fopen($filename, 'w');
|
||||
if (false === $fh) return false;
|
||||
$export = $this->export($include_headers);
|
||||
$res = fwrite($fh, $export);
|
||||
if (false === $res) return false;
|
||||
return fclose($fh);
|
||||
}
|
||||
|
||||
/**
|
||||
* Text to include as a comment before the start of the PO contents
|
||||
*
|
||||
* Doesn't need to include # in the beginning of lines, these are added automatically
|
||||
*/
|
||||
function set_comment_before_headers( $text ) {
|
||||
$this->comments_before_headers = $text;
|
||||
}
|
||||
|
||||
/**
|
||||
* Formats a string in PO-style
|
||||
*
|
||||
* @static
|
||||
* @param string $string the string to format
|
||||
* @return string the poified string
|
||||
*/
|
||||
function poify($string) {
|
||||
$quote = '"';
|
||||
$slash = '\\';
|
||||
$newline = "\n";
|
||||
|
||||
$replaces = array(
|
||||
"$slash" => "$slash$slash",
|
||||
"$quote" => "$slash$quote",
|
||||
"\t" => '\t',
|
||||
);
|
||||
|
||||
$string = str_replace(array_keys($replaces), array_values($replaces), $string);
|
||||
|
||||
$po = $quote.implode("${slash}n$quote$newline$quote", explode($newline, $string)).$quote;
|
||||
// add empty string on first line for readbility
|
||||
if (false !== strpos($string, $newline) &&
|
||||
(substr_count($string, $newline) > 1 || !($newline === substr($string, -strlen($newline))))) {
|
||||
$po = "$quote$quote$newline$po";
|
||||
}
|
||||
// remove empty strings
|
||||
$po = str_replace("$newline$quote$quote", '', $po);
|
||||
return $po;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gives back the original string from a PO-formatted string
|
||||
*
|
||||
* @static
|
||||
* @param string $string PO-formatted string
|
||||
* @return string enascaped string
|
||||
*/
|
||||
function unpoify($string) {
|
||||
$escapes = array('t' => "\t", 'n' => "\n", '\\' => '\\');
|
||||
$lines = array_map('trim', explode("\n", $string));
|
||||
$lines = array_map(array('PO', 'trim_quotes'), $lines);
|
||||
$unpoified = '';
|
||||
$previous_is_backslash = false;
|
||||
foreach($lines as $line) {
|
||||
preg_match_all('/./u', $line, $chars);
|
||||
$chars = $chars[0];
|
||||
foreach($chars as $char) {
|
||||
if (!$previous_is_backslash) {
|
||||
if ('\\' == $char)
|
||||
$previous_is_backslash = true;
|
||||
else
|
||||
$unpoified .= $char;
|
||||
} else {
|
||||
$previous_is_backslash = false;
|
||||
$unpoified .= isset($escapes[$char])? $escapes[$char] : $char;
|
||||
}
|
||||
}
|
||||
}
|
||||
return $unpoified;
|
||||
}
|
||||
|
||||
/**
|
||||
* Inserts $with in the beginning of every new line of $string and
|
||||
* returns the modified string
|
||||
*
|
||||
* @static
|
||||
* @param string $string prepend lines in this string
|
||||
* @param string $with prepend lines with this string
|
||||
*/
|
||||
function prepend_each_line($string, $with) {
|
||||
$php_with = var_export($with, true);
|
||||
$lines = explode("\n", $string);
|
||||
// do not prepend the string on the last empty line, artefact by explode
|
||||
if ("\n" == substr($string, -1)) unset($lines[count($lines) - 1]);
|
||||
$res = implode("\n", array_map(create_function('$x', "return $php_with.\$x;"), $lines));
|
||||
// give back the empty line, we ignored above
|
||||
if ("\n" == substr($string, -1)) $res .= "\n";
|
||||
return $res;
|
||||
}
|
||||
|
||||
/**
|
||||
* Prepare a text as a comment -- wraps the lines and prepends #
|
||||
* and a special character to each line
|
||||
*
|
||||
* @access private
|
||||
* @param string $text the comment text
|
||||
* @param string $char character to denote a special PO comment,
|
||||
* like :, default is a space
|
||||
*/
|
||||
function comment_block($text, $char=' ') {
|
||||
$text = wordwrap($text, PO_MAX_LINE_LEN - 3);
|
||||
return PO::prepend_each_line($text, "#$char ");
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds a string from the entry for inclusion in PO file
|
||||
*
|
||||
* @static
|
||||
* @param object &$entry the entry to convert to po string
|
||||
* @return string|bool PO-style formatted string for the entry or
|
||||
* false if the entry is empty
|
||||
*/
|
||||
function export_entry(&$entry) {
|
||||
if (is_null($entry->singular)) return false;
|
||||
$po = array();
|
||||
if (!empty($entry->translator_comments)) $po[] = PO::comment_block($entry->translator_comments);
|
||||
if (!empty($entry->extracted_comments)) $po[] = PO::comment_block($entry->extracted_comments, '.');
|
||||
if (!empty($entry->references)) $po[] = PO::comment_block(implode(' ', $entry->references), ':');
|
||||
if (!empty($entry->flags)) $po[] = PO::comment_block(implode(", ", $entry->flags), ',');
|
||||
if (!is_null($entry->context)) $po[] = 'msgctxt '.PO::poify($entry->context);
|
||||
$po[] = 'msgid '.PO::poify($entry->singular);
|
||||
if (!$entry->is_plural) {
|
||||
$translation = empty($entry->translations)? '' : $entry->translations[0];
|
||||
$po[] = 'msgstr '.PO::poify($translation);
|
||||
} else {
|
||||
$po[] = 'msgid_plural '.PO::poify($entry->plural);
|
||||
$translations = empty($entry->translations)? array('', '') : $entry->translations;
|
||||
foreach($translations as $i => $translation) {
|
||||
$po[] = "msgstr[$i] ".PO::poify($translation);
|
||||
}
|
||||
}
|
||||
return implode("\n", $po);
|
||||
}
|
||||
|
||||
function import_from_file($filename) {
|
||||
$f = fopen($filename, 'r');
|
||||
if (!$f) return false;
|
||||
$lineno = 0;
|
||||
while (true) {
|
||||
$res = $this->read_entry($f, $lineno);
|
||||
if (!$res) break;
|
||||
if ($res['entry']->singular == '') {
|
||||
$this->set_headers($this->make_headers($res['entry']->translations[0]));
|
||||
} else {
|
||||
$this->add_entry($res['entry']);
|
||||
}
|
||||
}
|
||||
PO::read_line($f, 'clear');
|
||||
if ( false === $res ) {
|
||||
return false;
|
||||
}
|
||||
if ( ! $this->headers && ! $this->entries ) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
function read_entry($f, $lineno = 0) {
|
||||
$entry = new Translation_Entry();
|
||||
// where were we in the last step
|
||||
// can be: comment, msgctxt, msgid, msgid_plural, msgstr, msgstr_plural
|
||||
$context = '';
|
||||
$msgstr_index = 0;
|
||||
$is_final = create_function('$context', 'return $context == "msgstr" || $context == "msgstr_plural";');
|
||||
while (true) {
|
||||
$lineno++;
|
||||
$line = PO::read_line($f);
|
||||
if (!$line) {
|
||||
if (feof($f)) {
|
||||
if ($is_final($context))
|
||||
break;
|
||||
elseif (!$context) // we haven't read a line and eof came
|
||||
return null;
|
||||
else
|
||||
return false;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if ($line == "\n") continue;
|
||||
$line = trim($line);
|
||||
if (preg_match('/^#/', $line, $m)) {
|
||||
// the comment is the start of a new entry
|
||||
if ($is_final($context)) {
|
||||
PO::read_line($f, 'put-back');
|
||||
$lineno--;
|
||||
break;
|
||||
}
|
||||
// comments have to be at the beginning
|
||||
if ($context && $context != 'comment') {
|
||||
return false;
|
||||
}
|
||||
// add comment
|
||||
$this->add_comment_to_entry($entry, $line);;
|
||||
} elseif (preg_match('/^msgctxt\s+(".*")/', $line, $m)) {
|
||||
if ($is_final($context)) {
|
||||
PO::read_line($f, 'put-back');
|
||||
$lineno--;
|
||||
break;
|
||||
}
|
||||
if ($context && $context != 'comment') {
|
||||
return false;
|
||||
}
|
||||
$context = 'msgctxt';
|
||||
$entry->context .= PO::unpoify($m[1]);
|
||||
} elseif (preg_match('/^msgid\s+(".*")/', $line, $m)) {
|
||||
if ($is_final($context)) {
|
||||
PO::read_line($f, 'put-back');
|
||||
$lineno--;
|
||||
break;
|
||||
}
|
||||
if ($context && $context != 'msgctxt' && $context != 'comment') {
|
||||
return false;
|
||||
}
|
||||
$context = 'msgid';
|
||||
$entry->singular .= PO::unpoify($m[1]);
|
||||
} elseif (preg_match('/^msgid_plural\s+(".*")/', $line, $m)) {
|
||||
if ($context != 'msgid') {
|
||||
return false;
|
||||
}
|
||||
$context = 'msgid_plural';
|
||||
$entry->is_plural = true;
|
||||
$entry->plural .= PO::unpoify($m[1]);
|
||||
} elseif (preg_match('/^msgstr\s+(".*")/', $line, $m)) {
|
||||
if ($context != 'msgid') {
|
||||
return false;
|
||||
}
|
||||
$context = 'msgstr';
|
||||
$entry->translations = array(PO::unpoify($m[1]));
|
||||
} elseif (preg_match('/^msgstr\[(\d+)\]\s+(".*")/', $line, $m)) {
|
||||
if ($context != 'msgid_plural' && $context != 'msgstr_plural') {
|
||||
return false;
|
||||
}
|
||||
$context = 'msgstr_plural';
|
||||
$msgstr_index = $m[1];
|
||||
$entry->translations[$m[1]] = PO::unpoify($m[2]);
|
||||
} elseif (preg_match('/^".*"$/', $line)) {
|
||||
$unpoified = PO::unpoify($line);
|
||||
switch ($context) {
|
||||
case 'msgid':
|
||||
$entry->singular .= $unpoified; break;
|
||||
case 'msgctxt':
|
||||
$entry->context .= $unpoified; break;
|
||||
case 'msgid_plural':
|
||||
$entry->plural .= $unpoified; break;
|
||||
case 'msgstr':
|
||||
$entry->translations[0] .= $unpoified; break;
|
||||
case 'msgstr_plural':
|
||||
$entry->translations[$msgstr_index] .= $unpoified; break;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if (array() == array_filter($entry->translations, create_function('$t', 'return $t || "0" === $t;'))) {
|
||||
$entry->translations = array();
|
||||
}
|
||||
return array('entry' => $entry, 'lineno' => $lineno);
|
||||
}
|
||||
|
||||
function read_line($f, $action = 'read') {
|
||||
static $last_line = '';
|
||||
static $use_last_line = false;
|
||||
if ('clear' == $action) {
|
||||
$last_line = '';
|
||||
return true;
|
||||
}
|
||||
if ('put-back' == $action) {
|
||||
$use_last_line = true;
|
||||
return true;
|
||||
}
|
||||
$line = $use_last_line? $last_line : fgets($f);
|
||||
$line = gp_endswith( $line, "\r\n" )? rtrim( $line, "\r\n" ) . "\n" : $line;
|
||||
$last_line = $line;
|
||||
$use_last_line = false;
|
||||
return $line;
|
||||
}
|
||||
|
||||
function add_comment_to_entry(&$entry, $po_comment_line) {
|
||||
$first_two = substr($po_comment_line, 0, 2);
|
||||
$comment = trim(substr($po_comment_line, 2));
|
||||
if ('#:' == $first_two) {
|
||||
$entry->references = array_merge($entry->references, preg_split('/\s+/', $comment));
|
||||
} elseif ('#.' == $first_two) {
|
||||
$entry->extracted_comments = trim($entry->extracted_comments . "\n" . $comment);
|
||||
} elseif ('#,' == $first_two) {
|
||||
$entry->flags = array_merge($entry->flags, preg_split('/,\s*/', $comment));
|
||||
} else {
|
||||
$entry->translator_comments = trim($entry->translator_comments . "\n" . $comment);
|
||||
}
|
||||
}
|
||||
|
||||
function trim_quotes($s) {
|
||||
if ( substr($s, 0, 1) == '"') $s = substr($s, 1);
|
||||
if ( substr($s, -1, 1) == '"') $s = substr($s, 0, -1);
|
||||
return $s;
|
||||
}
|
||||
}
|
||||
endif;
|
||||
|
|
@ -0,0 +1,209 @@
|
|||
<?php
|
||||
/**
|
||||
* Classes, which help reading streams of data from files.
|
||||
* Based on the classes from Danilo Segan <danilo@kvota.net>
|
||||
*
|
||||
* @version $Id: streams.php 718 2012-10-31 00:32:02Z nbachiyski $
|
||||
* @package pomo
|
||||
* @subpackage streams
|
||||
*/
|
||||
|
||||
if ( !class_exists( 'POMO_Reader' ) ):
|
||||
class POMO_Reader {
|
||||
|
||||
var $endian = 'little';
|
||||
var $_post = '';
|
||||
|
||||
function POMO_Reader() {
|
||||
$this->is_overloaded = ((ini_get("mbstring.func_overload") & 2) != 0) && function_exists('mb_substr');
|
||||
$this->_pos = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the endianness of the file.
|
||||
*
|
||||
* @param $endian string 'big' or 'little'
|
||||
*/
|
||||
function setEndian($endian) {
|
||||
$this->endian = $endian;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads a 32bit Integer from the Stream
|
||||
*
|
||||
* @return mixed The integer, corresponding to the next 32 bits from
|
||||
* the stream of false if there are not enough bytes or on error
|
||||
*/
|
||||
function readint32() {
|
||||
$bytes = $this->read(4);
|
||||
if (4 != $this->strlen($bytes))
|
||||
return false;
|
||||
$endian_letter = ('big' == $this->endian)? 'N' : 'V';
|
||||
$int = unpack($endian_letter, $bytes);
|
||||
return array_shift($int);
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads an array of 32-bit Integers from the Stream
|
||||
*
|
||||
* @param integer count How many elements should be read
|
||||
* @return mixed Array of integers or false if there isn't
|
||||
* enough data or on error
|
||||
*/
|
||||
function readint32array($count) {
|
||||
$bytes = $this->read(4 * $count);
|
||||
if (4*$count != $this->strlen($bytes))
|
||||
return false;
|
||||
$endian_letter = ('big' == $this->endian)? 'N' : 'V';
|
||||
return unpack($endian_letter.$count, $bytes);
|
||||
}
|
||||
|
||||
|
||||
function substr($string, $start, $length) {
|
||||
if ($this->is_overloaded) {
|
||||
return mb_substr($string, $start, $length, 'ascii');
|
||||
} else {
|
||||
return substr($string, $start, $length);
|
||||
}
|
||||
}
|
||||
|
||||
function strlen($string) {
|
||||
if ($this->is_overloaded) {
|
||||
return mb_strlen($string, 'ascii');
|
||||
} else {
|
||||
return strlen($string);
|
||||
}
|
||||
}
|
||||
|
||||
function str_split($string, $chunk_size) {
|
||||
if (!function_exists('str_split')) {
|
||||
$length = $this->strlen($string);
|
||||
$out = array();
|
||||
for ($i = 0; $i < $length; $i += $chunk_size)
|
||||
$out[] = $this->substr($string, $i, $chunk_size);
|
||||
return $out;
|
||||
} else {
|
||||
return str_split( $string, $chunk_size );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
function pos() {
|
||||
return $this->_pos;
|
||||
}
|
||||
|
||||
function is_resource() {
|
||||
return true;
|
||||
}
|
||||
|
||||
function close() {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
endif;
|
||||
|
||||
if ( !class_exists( 'POMO_FileReader' ) ):
|
||||
class POMO_FileReader extends POMO_Reader {
|
||||
function POMO_FileReader($filename) {
|
||||
parent::POMO_Reader();
|
||||
$this->_f = fopen($filename, 'rb');
|
||||
}
|
||||
|
||||
function read($bytes) {
|
||||
return fread($this->_f, $bytes);
|
||||
}
|
||||
|
||||
function seekto($pos) {
|
||||
if ( -1 == fseek($this->_f, $pos, SEEK_SET)) {
|
||||
return false;
|
||||
}
|
||||
$this->_pos = $pos;
|
||||
return true;
|
||||
}
|
||||
|
||||
function is_resource() {
|
||||
return is_resource($this->_f);
|
||||
}
|
||||
|
||||
function feof() {
|
||||
return feof($this->_f);
|
||||
}
|
||||
|
||||
function close() {
|
||||
return fclose($this->_f);
|
||||
}
|
||||
|
||||
function read_all() {
|
||||
$all = '';
|
||||
while ( !$this->feof() )
|
||||
$all .= $this->read(4096);
|
||||
return $all;
|
||||
}
|
||||
}
|
||||
endif;
|
||||
|
||||
if ( !class_exists( 'POMO_StringReader' ) ):
|
||||
/**
|
||||
* Provides file-like methods for manipulating a string instead
|
||||
* of a physical file.
|
||||
*/
|
||||
class POMO_StringReader extends POMO_Reader {
|
||||
|
||||
var $_str = '';
|
||||
|
||||
function POMO_StringReader($str = '') {
|
||||
parent::POMO_Reader();
|
||||
$this->_str = $str;
|
||||
$this->_pos = 0;
|
||||
}
|
||||
|
||||
|
||||
function read($bytes) {
|
||||
$data = $this->substr($this->_str, $this->_pos, $bytes);
|
||||
$this->_pos += $bytes;
|
||||
if ($this->strlen($this->_str) < $this->_pos) $this->_pos = $this->strlen($this->_str);
|
||||
return $data;
|
||||
}
|
||||
|
||||
function seekto($pos) {
|
||||
$this->_pos = $pos;
|
||||
if ($this->strlen($this->_str) < $this->_pos) $this->_pos = $this->strlen($this->_str);
|
||||
return $this->_pos;
|
||||
}
|
||||
|
||||
function length() {
|
||||
return $this->strlen($this->_str);
|
||||
}
|
||||
|
||||
function read_all() {
|
||||
return $this->substr($this->_str, $this->_pos, $this->strlen($this->_str));
|
||||
}
|
||||
|
||||
}
|
||||
endif;
|
||||
|
||||
if ( !class_exists( 'POMO_CachedFileReader' ) ):
|
||||
/**
|
||||
* Reads the contents of the file in the beginning.
|
||||
*/
|
||||
class POMO_CachedFileReader extends POMO_StringReader {
|
||||
function POMO_CachedFileReader($filename) {
|
||||
parent::POMO_StringReader();
|
||||
$this->_str = file_get_contents($filename);
|
||||
if (false === $this->_str)
|
||||
return false;
|
||||
$this->_pos = 0;
|
||||
}
|
||||
}
|
||||
endif;
|
||||
|
||||
if ( !class_exists( 'POMO_CachedIntFileReader' ) ):
|
||||
/**
|
||||
* Reads the contents of the file in the beginning.
|
||||
*/
|
||||
class POMO_CachedIntFileReader extends POMO_CachedFileReader {
|
||||
function POMO_CachedIntFileReader($filename) {
|
||||
parent::POMO_CachedFileReader($filename);
|
||||
}
|
||||
}
|
||||
endif;
|
||||
|
|
@ -0,0 +1,275 @@
|
|||
<?php
|
||||
/**
|
||||
* Class for a set of entries for translation and their associated headers
|
||||
*
|
||||
* @version $Id: translations.php 718 2012-10-31 00:32:02Z nbachiyski $
|
||||
* @package pomo
|
||||
* @subpackage translations
|
||||
*/
|
||||
|
||||
require_once dirname(__FILE__) . '/entry.php';
|
||||
|
||||
if ( !class_exists( 'Translations' ) ):
|
||||
class Translations {
|
||||
var $entries = array();
|
||||
var $headers = array();
|
||||
|
||||
/**
|
||||
* Add entry to the PO structure
|
||||
*
|
||||
* @param object &$entry
|
||||
* @return bool true on success, false if the entry doesn't have a key
|
||||
*/
|
||||
function add_entry($entry) {
|
||||
if (is_array($entry)) {
|
||||
$entry = new Translation_Entry($entry);
|
||||
}
|
||||
$key = $entry->key();
|
||||
if (false === $key) return false;
|
||||
$this->entries[$key] = &$entry;
|
||||
return true;
|
||||
}
|
||||
|
||||
function add_entry_or_merge($entry) {
|
||||
if (is_array($entry)) {
|
||||
$entry = new Translation_Entry($entry);
|
||||
}
|
||||
$key = $entry->key();
|
||||
if (false === $key) return false;
|
||||
if (isset($this->entries[$key]))
|
||||
$this->entries[$key]->merge_with($entry);
|
||||
else
|
||||
$this->entries[$key] = &$entry;
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets $header PO header to $value
|
||||
*
|
||||
* If the header already exists, it will be overwritten
|
||||
*
|
||||
* TODO: this should be out of this class, it is gettext specific
|
||||
*
|
||||
* @param string $header header name, without trailing :
|
||||
* @param string $value header value, without trailing \n
|
||||
*/
|
||||
function set_header($header, $value) {
|
||||
$this->headers[$header] = $value;
|
||||
}
|
||||
|
||||
function set_headers(&$headers) {
|
||||
foreach($headers as $header => $value) {
|
||||
$this->set_header($header, $value);
|
||||
}
|
||||
}
|
||||
|
||||
function get_header($header) {
|
||||
return isset($this->headers[$header])? $this->headers[$header] : false;
|
||||
}
|
||||
|
||||
function translate_entry(&$entry) {
|
||||
$key = $entry->key();
|
||||
return isset($this->entries[$key])? $this->entries[$key] : false;
|
||||
}
|
||||
|
||||
function translate($singular, $context=null) {
|
||||
$entry = new Translation_Entry(array('singular' => $singular, 'context' => $context));
|
||||
$translated = $this->translate_entry($entry);
|
||||
return ($translated && !empty($translated->translations))? $translated->translations[0] : $singular;
|
||||
}
|
||||
|
||||
/**
|
||||
* Given the number of items, returns the 0-based index of the plural form to use
|
||||
*
|
||||
* Here, in the base Translations class, the commong logic for English is implmented:
|
||||
* 0 if there is one element, 1 otherwise
|
||||
*
|
||||
* This function should be overrided by the sub-classes. For example MO/PO can derive the logic
|
||||
* from their headers.
|
||||
*
|
||||
* @param integer $count number of items
|
||||
*/
|
||||
function select_plural_form($count) {
|
||||
return 1 == $count? 0 : 1;
|
||||
}
|
||||
|
||||
function get_plural_forms_count() {
|
||||
return 2;
|
||||
}
|
||||
|
||||
function translate_plural($singular, $plural, $count, $context = null) {
|
||||
$entry = new Translation_Entry(array('singular' => $singular, 'plural' => $plural, 'context' => $context));
|
||||
$translated = $this->translate_entry($entry);
|
||||
$index = $this->select_plural_form($count);
|
||||
$total_plural_forms = $this->get_plural_forms_count();
|
||||
if ($translated && 0 <= $index && $index < $total_plural_forms &&
|
||||
is_array($translated->translations) &&
|
||||
isset($translated->translations[$index]))
|
||||
return $translated->translations[$index];
|
||||
else
|
||||
return 1 == $count? $singular : $plural;
|
||||
}
|
||||
|
||||
/**
|
||||
* Merge $other in the current object.
|
||||
*
|
||||
* @param Object &$other Another Translation object, whose translations will be merged in this one
|
||||
* @return void
|
||||
**/
|
||||
function merge_with(&$other) {
|
||||
foreach( $other->entries as $entry ) {
|
||||
$this->entries[$entry->key()] = $entry;
|
||||
}
|
||||
}
|
||||
|
||||
function merge_originals_with(&$other) {
|
||||
foreach( $other->entries as $entry ) {
|
||||
if ( !isset( $this->entries[$entry->key()] ) )
|
||||
$this->entries[$entry->key()] = $entry;
|
||||
else
|
||||
$this->entries[$entry->key()]->merge_with($entry);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class Gettext_Translations extends Translations {
|
||||
/**
|
||||
* The gettext implmentation of select_plural_form.
|
||||
*
|
||||
* It lives in this class, because there are more than one descendand, which will use it and
|
||||
* they can't share it effectively.
|
||||
*
|
||||
*/
|
||||
function gettext_select_plural_form($count) {
|
||||
if (!isset($this->_gettext_select_plural_form) || is_null($this->_gettext_select_plural_form)) {
|
||||
list( $nplurals, $expression ) = $this->nplurals_and_expression_from_header($this->get_header('Plural-Forms'));
|
||||
$this->_nplurals = $nplurals;
|
||||
$this->_gettext_select_plural_form = $this->make_plural_form_function($nplurals, $expression);
|
||||
}
|
||||
return call_user_func($this->_gettext_select_plural_form, $count);
|
||||
}
|
||||
|
||||
function nplurals_and_expression_from_header($header) {
|
||||
if (preg_match('/^\s*nplurals\s*=\s*(\d+)\s*;\s+plural\s*=\s*(.+)$/', $header, $matches)) {
|
||||
$nplurals = (int)$matches[1];
|
||||
$expression = trim($this->parenthesize_plural_exression($matches[2]));
|
||||
return array($nplurals, $expression);
|
||||
} else {
|
||||
return array(2, 'n != 1');
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Makes a function, which will return the right translation index, according to the
|
||||
* plural forms header
|
||||
*/
|
||||
function make_plural_form_function($nplurals, $expression) {
|
||||
$expression = str_replace('n', '$n', $expression);
|
||||
$func_body = "
|
||||
\$index = (int)($expression);
|
||||
return (\$index < $nplurals)? \$index : $nplurals - 1;";
|
||||
return create_function('$n', $func_body);
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds parantheses to the inner parts of ternary operators in
|
||||
* plural expressions, because PHP evaluates ternary oerators from left to right
|
||||
*
|
||||
* @param string $expression the expression without parentheses
|
||||
* @return string the expression with parentheses added
|
||||
*/
|
||||
function parenthesize_plural_exression($expression) {
|
||||
$expression .= ';';
|
||||
$res = '';
|
||||
$depth = 0;
|
||||
for ($i = 0; $i < strlen($expression); ++$i) {
|
||||
$char = $expression[$i];
|
||||
switch ($char) {
|
||||
case '?':
|
||||
$res .= ' ? (';
|
||||
$depth++;
|
||||
break;
|
||||
case ':':
|
||||
$res .= ') : (';
|
||||
break;
|
||||
case ';':
|
||||
$res .= str_repeat(')', $depth) . ';';
|
||||
$depth= 0;
|
||||
break;
|
||||
default:
|
||||
$res .= $char;
|
||||
}
|
||||
}
|
||||
return rtrim($res, ';');
|
||||
}
|
||||
|
||||
function make_headers($translation) {
|
||||
$headers = array();
|
||||
// sometimes \ns are used instead of real new lines
|
||||
$translation = str_replace('\n', "\n", $translation);
|
||||
$lines = explode("\n", $translation);
|
||||
foreach($lines as $line) {
|
||||
$parts = explode(':', $line, 2);
|
||||
if (!isset($parts[1])) continue;
|
||||
$headers[trim($parts[0])] = trim($parts[1]);
|
||||
}
|
||||
return $headers;
|
||||
}
|
||||
|
||||
function set_header($header, $value) {
|
||||
parent::set_header($header, $value);
|
||||
if ('Plural-Forms' == $header) {
|
||||
list( $nplurals, $expression ) = $this->nplurals_and_expression_from_header($this->get_header('Plural-Forms'));
|
||||
$this->_nplurals = $nplurals;
|
||||
$this->_gettext_select_plural_form = $this->make_plural_form_function($nplurals, $expression);
|
||||
}
|
||||
}
|
||||
}
|
||||
endif;
|
||||
|
||||
if ( !class_exists( 'NOOP_Translations' ) ):
|
||||
/**
|
||||
* Provides the same interface as Translations, but doesn't do anything
|
||||
*/
|
||||
class NOOP_Translations {
|
||||
var $entries = array();
|
||||
var $headers = array();
|
||||
|
||||
function add_entry($entry) {
|
||||
return true;
|
||||
}
|
||||
|
||||
function set_header($header, $value) {
|
||||
}
|
||||
|
||||
function set_headers(&$headers) {
|
||||
}
|
||||
|
||||
function get_header($header) {
|
||||
return false;
|
||||
}
|
||||
|
||||
function translate_entry(&$entry) {
|
||||
return false;
|
||||
}
|
||||
|
||||
function translate($singular, $context=null) {
|
||||
return $singular;
|
||||
}
|
||||
|
||||
function select_plural_form($count) {
|
||||
return 1 == $count? 0 : 1;
|
||||
}
|
||||
|
||||
function get_plural_forms_count() {
|
||||
return 2;
|
||||
}
|
||||
|
||||
function translate_plural($singular, $plural, $count, $context = null) {
|
||||
return 1 == $count? $singular : $plural;
|
||||
}
|
||||
|
||||
function merge_with(&$other) {
|
||||
}
|
||||
}
|
||||
endif;
|
||||
|
|
@ -0,0 +1,76 @@
|
|||
<?php
|
||||
/**
|
||||
* Console application, which adds metadata strings from
|
||||
* a WordPress extension to a POT file
|
||||
*
|
||||
* @version $Id: pot-ext-meta.php 19937 2012-05-21 21:40:14Z nacin $
|
||||
* @package wordpress-i18n
|
||||
* @subpackage tools
|
||||
*/
|
||||
|
||||
require_once dirname( __FILE__ ) . '/pomo/po.php';
|
||||
require_once dirname( __FILE__ ) . '/makepot.php';
|
||||
|
||||
class PotExtMeta {
|
||||
|
||||
var $headers = array(
|
||||
'Plugin Name',
|
||||
'Theme Name',
|
||||
'Plugin URI',
|
||||
'Theme URI',
|
||||
'Description',
|
||||
'Author',
|
||||
'Author URI',
|
||||
'Tags',
|
||||
);
|
||||
|
||||
|
||||
function usage() {
|
||||
fwrite(STDERR, "Usage: php pot-ext-meta.php EXT POT\n");
|
||||
fwrite(STDERR, "Adds metadata from a WordPress theme or plugin file EXT to POT file\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
function load_from_file($ext_filename) {
|
||||
$source = MakePOT::get_first_lines($ext_filename);
|
||||
$pot = '';
|
||||
foreach($this->headers as $header) {
|
||||
$string = MakePOT::get_addon_header($header, $source);
|
||||
if (!$string) continue;
|
||||
$args = array(
|
||||
'singular' => $string,
|
||||
'extracted_comments' => $header.' of the plugin/theme',
|
||||
);
|
||||
$entry = new Translation_Entry($args);
|
||||
$pot .= "\n".PO::export_entry($entry)."\n";
|
||||
}
|
||||
return $pot;
|
||||
}
|
||||
|
||||
function append( $ext_filename, $pot_filename, $headers = null ) {
|
||||
if ( $headers )
|
||||
$this->headers = (array) $headers;
|
||||
if ( is_dir( $ext_filename ) ) {
|
||||
$pot = implode('', array_map(array(&$this, 'load_from_file'), glob("$ext_filename/*.php")));
|
||||
} else {
|
||||
$pot = $this->load_from_file($ext_filename);
|
||||
}
|
||||
$potf = '-' == $pot_filename? STDOUT : fopen($pot_filename, 'a');
|
||||
if (!$potf) return false;
|
||||
fwrite($potf, $pot);
|
||||
if ('-' != $pot_filename) fclose($potf);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
$included_files = get_included_files();
|
||||
if ($included_files[0] == __FILE__) {
|
||||
ini_set('display_errors', 1);
|
||||
$potextmeta = new PotExtMeta;
|
||||
if (!isset($argv[1])) {
|
||||
$potextmeta->usage();
|
||||
}
|
||||
$potextmeta->append( $argv[1], isset( $argv[2] ) ? $argv[2] : '-', isset( $argv[3] ) ? $argv[3] : null );
|
||||
}
|
||||
|
||||
?>
|
||||
Loading…
Reference in New Issue