writeMessagesArray.inc

Go to the documentation of this file.

<?php
class MessageWriter {
        static $optionalComment = 'only translate this message to other languages if you have to change it';
        static $ignoredComment = "do not translate or duplicate this message to other languages";

        static $messageStructure;
        static $blockComments;
        static $ignoredMessages;
        static $optionalMessages;

        public static function writeMessagesToFile( $messages, $code, $write, $listUnknown, $removeUnknown, $messagesFolder = false ) {
                # Rewrite the messages array
                $messages = self::writeMessagesArray( $messages, $code == 'en', false, $removeUnknown );
                $messagesText = $messages[0];
                $sortedMessages = $messages[1];

                # Write to the file
                if ( $messagesFolder )
                        $filename = Language::getFileName( "$messagesFolder/Messages", $code );
                else
                        $filename = Language::getMessagesFileName( $code );

                if ( file_exists( $filename ) )
                        $contents = file_get_contents( $filename );
                else
                        $contents = '<?php
$messages = array(
);
';

                if( strpos( $contents, '$messages' ) !== false ) {
                        $contents = explode( '$messages', $contents );
                        if( $messagesText == '$messages' . $contents[1] ) {
                                echo "Generated messages for language $code. Same as the current file.\n";
                        } else {
                                if( $write ) {
                                        $new = $contents[0];
                                        $new .= $messagesText;
                                        file_put_contents( $filename, $new );
                                        echo "Generated and wrote messages for language $code.\n";
                                } else {
                                        echo "Generated messages for language $code. Please run the script again (without the parameter \"dry-run\") to write the array to the file.\n";
                                }
                        }
                        if( $listUnknown && isset( $sortedMessages['unknown'] ) && !empty( $sortedMessages['unknown'] ) ) {
                                if ( $removeUnknown )
                                        echo "\nThe following " . count( $sortedMessages['unknown'] ) . " unknown messages have been removed:\n";
                                else
                                        echo "\nThere are " . count( $sortedMessages['unknown'] ) . " unknown messages, please check them:\n";
                                foreach( $sortedMessages['unknown'] as $key => $value ) {
                                        echo "* " . $key . "\n";
                                }
                        }
                } else {
                        echo "Generated messages for language $code. There seem to be no messages array in the file.\n";
                }
        }

        public static function writeMessagesArray( $messages, $ignoredComments = false, $prefix = false, $removeUnknown = false ) {
                # Load messages
                $dir = $prefix ? $prefix : __DIR__;

                require( $dir . '/messages.inc' );
                self::$messageStructure = $wgMessageStructure;
                self::$blockComments = $wgBlockComments;

                require( $dir . '/messageTypes.inc' );
                self::$ignoredMessages = $wgIgnoredMessages;
                self::$optionalMessages = $wgOptionalMessages;

                # Sort messages to blocks
                $sortedMessages['unknown'] = $messages;
                foreach( self::$messageStructure as $blockName => $block ) {
                        foreach( $block as $key ) {
                                if( array_key_exists( $key, $sortedMessages['unknown'] ) ) {
                                        $sortedMessages[$blockName][$key] = $sortedMessages['unknown'][$key];
                                        unset( $sortedMessages['unknown'][$key] );
                                }
                        }
                }

                # Write all the messages
                $messagesText = "\$messages = array(
";
                foreach( $sortedMessages as $block => $messages ) {
                        # Skip if it's the block of unknown messages - handle that in the end of file
                        if( $block == 'unknown' ) {
                                continue;
                        }

                        if( $ignoredComments ) {
                                $ignored = self::$ignoredMessages;
                                $optional = self::$optionalMessages;
                        } else {
                                $ignored = array();
                                $optional = array();
                        }
                        $comments = self::makeComments( array_keys( $messages ), $ignored, $optional );

                        # Write the block
                        $messagesText .= self::writeMessagesBlock( self::$blockComments[$block], $messages, $comments );
                }

                # Write the unknown messages, alphabetically sorted.
                # Of course, we don't have any comments for them, because they are unknown.
                if ( !$removeUnknown ) {
                        ksort( $sortedMessages['unknown'] );
                        $messagesText .= self::writeMessagesBlock( 'Unknown messages', $sortedMessages['unknown'] );
                }
                $messagesText .= ");
";
                return array( $messagesText, $sortedMessages );
        }

        public static function makeComments( $messages, $ignored, $optional ) {
                # Comment collector
                $commentArray = array();

                # List of keys only
                foreach( $messages as $key ) {
                        if( in_array( $key, $ignored ) ) {
                                $commentArray[$key] = ' # ' . self::$ignoredComment;
                        } elseif( in_array( $key, $optional ) ) {
                                $commentArray[$key] = ' # ' . self::$optionalComment;
                        }
                }

                return $commentArray;
        }

        public static function writeMessagesBlock( $blockComment, $messages,
                $messageComments = array(), $prefix = '' ) {

                $blockText = '';

                # Skip the block if it includes no messages
                if( empty( $messages ) ) {
                        return '';
                }

                # Format the block comment (if exists); check for multiple lines comments
                if( !empty( $blockComment ) ) {
                        if( strpos( $blockComment, "\n" ) === false ) {
                                $blockText .= "$prefix# $blockComment
";
                        } else {
                                $blockText .= "$prefix/*
$blockComment
*/
";
                        }
                }

                # Get max key length
                $maxKeyLength = max( array_map( 'strlen', array_keys( $messages ) ) );

                # Format the messages
                foreach( $messages as $key => $value ) {
                        # Add the key name
                        $blockText .= "$prefix'$key'";

                        # Add the appropriate block whitespace
                        $blockText .= str_repeat( ' ', $maxKeyLength - strlen( $key ) );

                        # Refer to the value
                        $blockText .= ' => ';

                        # Check for the appropriate apostrophe and add the value
                        # Quote \ here, because it needs always escaping
                        $value = addcslashes( $value, '\\' );

                        # For readability
                        $single = "'";
                        $double = '"';

                        if( strpos( $value, $single ) === false ) {
                                # Nothing ugly, just use '
                                $blockText .= $single.$value.$single;
                        } elseif( strpos( $value, $double ) === false && !preg_match('/\$[a-zA-Z_\x7f-\xff]/', $value) ) {
                                # No "-quotes, no variables that need quoting, use "
                                $blockText .= $double.$value.$double;
                        } else {
                                # Something needs quoting, pick the quote which causes less quoting
                                $quote = substr_count( $value, $double ) + substr_count( $value, '$' ) >= substr_count( $value, $single ) ? $single : $double;
                                if( $quote === $double ) {
                                        $extra = '$';
                                } else {
                                        $extra = '';
                                }
                                $blockText .= $quote . addcslashes( $value, $quote . $extra ) . $quote;
                        }

                        # Comma
                        $blockText .= ',';

                        # Add comments, if there is any
                        if( array_key_exists( $key, $messageComments ) ) {
                                $blockText .= $messageComments[$key];
                        }

                        # Newline
                        $blockText .= "
";
                }

                # Newline to end the block
                $blockText .= "
";

                return $blockText;
        }
}