Changeset 3340


Ignore:
Timestamp:
04/03/09 17:42:49 (5 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