Changeset 3340


Ignore:
Timestamp:
04/03/2009 05:42:49 PM (6 years ago)
Author:
wwalc
Message:

Added conversion into java properties format

Location:
CKLangTool/trunk
Files:
1 added
5 edited

Legend:

Unmodified
Added
Removed
  • CKLangTool/trunk/_dev/build.xml

    r3142 r3340  
    1414                <java fork="yes" classname="org.mozilla.javascript.tools.jsc.Main" failonerror="true">
    1515                        <arg value="-debug" />
     16                        <arg value="-package" />
     17                        <arg value="cklangtool" />
    1618                        <arg value="${source.dir}/langtool.js" />
     19                </java>
     20                <java fork="yes" classname="org.mozilla.javascript.tools.jsc.Main" failonerror="true">
     21                        <arg value="-debug" />
     22                        <arg value="-package" />
     23                        <arg value="cklangtool.includes" />
    1724                        <arg value="${source.dir}/includes/cklangtool.js" />
     25                        <arg value="${source.dir}/includes/ckjpformat.js" />
    1826                        <arg value="${source.dir}/includes/io.js" />
    1927                </java>
     
    2129
    2230        <target name="copy" depends="compile" description="copy files">
    23                 <copy file="${source.dir}/includes/cklangtool.class" tofile="${build.dir}/cklangtool.class" overwrite="true" />
    24                 <copy file="${source.dir}/includes/io.class" tofile="${build.dir}/io.class" overwrite="true" />
    25                 <copy file="${source.dir}/langtool.class" tofile="${build.dir}/langtool.class" overwrite="true" />
     31                <copy file="${source.dir}/includes/cklangtool/includes/cklangtool.class" tofile="${build.dir}/cklangtool/includes/cklangtool.class" overwrite="true" />
     32                <copy file="${source.dir}/includes/cklangtool/includes/ckjpformat.class" tofile="${build.dir}/cklangtool/includes/ckjpformat.class" overwrite="true" />
     33                <copy file="${source.dir}/includes/cklangtool/includes/io.class" tofile="${build.dir}/cklangtool/includes/io.class" overwrite="true" />
     34                <copy file="${source.dir}/cklangtool/langtool.class" tofile="${build.dir}/cklangtool/langtool.class" overwrite="true" />
    2635                <copy file="${rhino.jar}" tofile="${build.dir}/langtool.jar" overwrite="true" />
    2736        </target>
     
    3443                        </fileset>
    3544                        <manifest>
    36                                 <attribute name="Main-Class" value="langtool" />
     45                                <attribute name="Main-Class" value="cklangtool.langtool" />
    3746                        </manifest>
    3847                </jar>
     
    5362                <copy file="${build.dir}/langtool.jar" tofile="${bin.dir}/langtool.jar" overwrite="true" />
    5463                <delete dir="${build.dir}" />
    55                 <delete file="${source.dir}/langtool.class" />
    56                 <delete file="${source.dir}/includes/cklangtool.class" />
    57                 <delete file="${source.dir}/includes/io.class" />
     64                <delete dir="${source.dir}/cklangtool/" />
     65                <delete dir="${source.dir}/includes/cklangtool/" />
    5866        </target>
    5967
  • CKLangTool/trunk/_source/includes/cklangtool.js

    r3270 r3340  
    88var CKLANGTOOL =
    99{
    10         languageDir :"",
    11         templateFile :"",
     10        isCompiled : false,
     11        languageDir : "",
     12        templateFile : "",
     13        operation : "default",
    1214        /**
    1315         * Holds the content of en.js language file where strings are replaced with
    1416         * special placeholders: #ckeditor_translation.placeholder.key#.
    1517         */
    16         template :""
     18        template : "",
     19        path : "",
     20       
     21        load : function( className )
     22        {
     23                if ( CKLANGTOOL.isCompiled )
     24                {
     25                        loadClass( className );
     26                }
     27                else
     28                {
     29                        var path = className;
     30                        path = path.replace( /^cklangtool\./, "_source/" );
     31                        path = path.replace( /\./g, '/' ) + '.js';
     32
     33                        load( CKLANGTOOL.path + path );
     34                }
     35        }       
     36};
     37
     38/**
     39 * Load language file and return an object with the whole translation.
     40 */
     41CKLANGTOOL.loadLanguageFile = function( file )
     42{
     43        var translationCode = 'var CKEDITOR = { lang : {} }; ' + CKLANGTOOL.io.readFile( file );
     44
     45        var cx = Context.enter(), scope = cx.initStandardObjects();
     46
     47        cx.evaluateString( scope, translationCode, file.getName(), 1, null );
     48
     49        try
     50        {
     51                var languageCode = '';
     52
     53                /*
     54                 * Get the number of variables in parent scope.
     55                 */
     56                var size = 0;
     57                for ( var i in scope )
     58                {
     59                        size++;
     60                }
     61
     62                /*
     63                 * If there is more than one variable, then it's not a CKEDITOR language file.
     64                 */
     65                if ( size > 1 )
     66                {
     67                        /**
     68                         * Return the first variable from parent scope different than
     69                         * CKEDITOR.
     70                         */
     71                        for ( var i in scope )
     72                        {
     73                                if ( i != "CKEDITOR" )
     74                                        return { 'languageCode' : languageCode, 'translation' : scope[i] };
     75                        }
     76                }
     77                else
     78                {
     79                        /*
     80                         * Return the first entry from scope.CKEDITOR.lang object
     81                         */
     82                        for ( var i in scope.CKEDITOR.lang )
     83                        {
     84                                languageCode = i;
     85                                return { 'languageCode' : languageCode, 'translation' : scope.CKEDITOR.lang[i] };
     86                        }
     87                }
     88        }
     89        catch ( e )
     90        {
     91                throw ( "Language file is invalid (" + file.getAbsolutePath() + ")" );
     92        }
    1793};
    1894
     
    49125                {
    50126                        throw ("Error in " + file.getAbsolutePath() + "\n" + "Line: " + e.lineNumber + "\nMessage: " + e.message);
    51                 }
    52         }
    53 
    54         /**
    55          * Load language file and return an object with the whole translation.
    56          */
    57         function loadLanguageFile( file )
    58         {
    59                 var translationCode = 'var CKEDITOR = { lang : {} }; ' + CKLANGTOOL.io.readFile( file );
    60 
    61                 var cx = Context.enter(), scope = cx.initStandardObjects();
    62 
    63                 cx.evaluateString( scope, translationCode, file.getName(), 1, null );
    64 
    65                 try
    66                 {
    67                         languageCode = '';
    68 
    69                         /*
    70                          * Get the number of variables in parent scope.
    71                          */
    72                         var size = 0;
    73                         for ( var i in scope )
    74                         {
    75                                 size++;
    76                         }
    77 
    78                         /*
    79                          * If there is more than one variable, then it's not a CKEDITOR language file.
    80                          */
    81                         if ( size > 1 )
    82                         {
    83                                 /**
    84                                  * Return the first variable from parent scope different than
    85                                  * CKEDITOR.
    86                                  */
    87                                 for ( var i in scope )
    88                                 {
    89                                         if ( i != "CKEDITOR" )
    90                                                 return scope[ i ];
    91                                 }
    92                         }
    93                         else
    94                         {
    95                                 /*
    96                                  * Return the first entry from scope.CKEDITOR.lang object
    97                                  */
    98                                 for ( var i in scope.CKEDITOR.lang )
    99                                 {
    100                                         languageCode = i;
    101                                         return scope.CKEDITOR.lang[ i ];
    102                                 }
    103                         }
    104                 }
    105                 catch ( e )
    106                 {
    107                         throw ("Language file is invalid (" + file.getAbsolutePath() + ")");
    108127                }
    109128        }
     
    472491        function processFile( file )
    473492        {
    474                 translation = loadLanguageFile( file );
    475493                var missingKeys = analyzeLanguageFile( file );
    476494                var matchResult, replacement, translationKey;
     
    478496                var matcher = regexLib.translation.matcher( string );
    479497                var found = 0, missing = 0;
     498                var result = CKLANGTOOL.loadLanguageFile( file );
     499                var translation = result.translation;
     500
     501                languageCode = result.languageCode;
    480502
    481503                while ( matcher.find() )
     
    556578                {
    557579                        CKLANGTOOL.template = createTemplate( CKLANGTOOL.templateFile );
    558                         CKLANGTOOL.englishTranslation = loadLanguageFile( CKLANGTOOL.templateFile );
     580                        var result = CKLANGTOOL.loadLanguageFile( CKLANGTOOL.templateFile );
     581                        CKLANGTOOL.englishTranslation = result.translation;
    559582
    560583                        var children = CKLANGTOOL.languageDir.list();
  • CKLangTool/trunk/_source/langtool.js

    r3136 r3340  
    1414var isCompiled = true;
    1515var command = "java -cp js.jar org.mozilla.javascript.tools.shell.Main langtool.js";
     16var resource = JavaAdapter( org.mozilla.javascript.Parser )["class"].getResource( "/org/mozilla/javascript" ).toString();
    1617
    1718try
    1819{
    19         java.lang.Class.forName( "langtool" );
     20        java.lang.Class.forName( "cklangtool.langtool" );
    2021}
    2122catch ( e )
     
    2324        isCompiled = false;
    2425}
     26
     27var cklangtoolPath = '';
    2528
    2629if ( isCompiled )
     
    3134        };
    3235
    33         loadClass( "cklangtool" );
    34         loadClass( "io" );
     36        loadClass( 'cklangtool.includes.cklangtool' );
    3537
    3638        var resource = JavaAdapter( org.mozilla.javascript.Parser )["class"].getResource( "/org/mozilla/javascript" ).toString();
     
    4244else
    4345{
    44         load( "includes/cklangtool.js" );
    45         load( "includes/io.js" );
     46        cklangtoolPath = resource.replaceFirst( "^jar:", '' ).replaceFirst( "\/js\.jar\!\/org\/mozilla\/javascript$", '' )
     47                        .replaceAll( "_dev.{1}_thirdparty.{1}rhino", "" );
     48
     49        load( cklangtoolPath + "_source/includes/cklangtool.js" );
     50
     51        CKLANGTOOL.path = cklangtoolPath;
    4652}
    4753
    48 if ( !arguments[0] )
    49         error( 'Usage: ' + command + ' [lang_dir]' );
     54CKLANGTOOL.isCompiled = isCompiled;
     55CKLANGTOOL.load( 'cklangtool.includes.ckjpformat' );
     56CKLANGTOOL.load( 'cklangtool.includes.io' );
     57
     58if ( !arguments[0] || arguments[0] == '-help' || arguments[0] == '/?' )
     59        error( 'Usage: ' + command + ' lang_dir [-jpformat=dest_dir]'
     60                        + '\n\n CKLangTool corrects translation files and creates report about missing translations.'
     61                        + '\n\n -jpformat  Convert files to java properties format and save them in dest_dir.\n' );
     62
     63for ( var i = 0 ; i < arguments.length ; i++ )
     64{
     65        if ( arguments[i].indexOf( "-jpformat=" ) != -1 )
     66        {
     67                var destDir = arguments[i].substring( arguments[i].indexOf( "=" ) + 1 );
     68                CKLANGTOOL.destinationDir = new File( destDir );
     69                if ( CKLANGTOOL.destinationDir.exists() )
     70                        error( 'Destination directory already exists: ' + CKLANGTOOL.destinationDir.getAbsolutePath() );
     71                else
     72                        CKLANGTOOL.destinationDir.mkdir();
     73                CKLANGTOOL.operation = "jpformat";
     74        }
     75}
     76
     77if ( arguments[0] == '-test' && !isCompiled )
     78{
     79        CKLANGTOOL.load( 'test.test' );
     80        quit();
     81}
    5082
    5183CKLANGTOOL.languageDir = new File( arguments[0] );
     
    68100        try
    69101        {
    70                 var translator = new CKLANGTOOL.translator();
    71                 translator.run();
     102                if ( CKLANGTOOL.operation == "jpformat" )
     103                {
     104                        var jpformat = new CKLANGTOOL.jpformat();
     105                        jpformat.run();
     106                }
     107                else
     108                {
     109                        var translator = new CKLANGTOOL.translator();
     110                        translator.run();
     111                }
    72112        }
    73113        catch ( e )
Note: See TracChangeset for help on using the changeset viewer.
© 2003 – 2012 CKSource – Frederico Knabben. All rights reserved. | Terms of use | Privacy policy