1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 | 48× 48× 48× 48× 165× 138× 138× 3× 3× 6× 135× 165× 165× 165× 165× 165× 165× 165× 165× 165× 165× 165× 165× 165× 165× 165× 165× 165× 165× 165× 394× 165× 4× 8× 8× 4× 4× 48× 41× 41× 41× 41× 41× 23× 23× 41× 48× 258× 258× 8× 8× 250× 250× 258× 97× 97× 161× 258× 8× 258× 17× 258× 48× 12× 12× 34× 12× 48× 12× 12× 34× 34× 34× 12× 48× 60× 60× 60× 60× 60× 32× 32× 32× 32× 12× 32× 20× 20× 28× 4× 4× 4× 28× 60× 60× 30× 30× 60× 60× 6× 60× 48× 281× 4× 6× 4× 277× 277× 277× 94× 94× 277× 2× 277× 277× 149× 6× 12× 143× 277× 18× 277× 20× 277× 48× 413× 351× 62× 48× 25× 25× 1× 25× 3× 25× 7× 25× 2× 1× 1× 25× 13× 12× 1× 12× 9× 3× 3× 48× 9× 48× 1× 48× 1× 1× 224× 2240× 716× 285× 224× 37× 224× 7× 224× 12× 1× 8× 8× 8× 24× 23× 23× 8× 1× 31× 31× 31× 29× 26× 1× 41× 41× 41× 41× 41× 41× 41× 1× 1× 1× 1× 1× 40× 1× 1× 39× 39× 39× 55× 55× 4× 4× 4× 4× 55× 9× 9× 4× 55× 47× 55× 15× 55× 27× 27× 28× 5× 39× 39× 39× 1× 39× 39× 57× 57× 43× 14× 14× 57× 57× 57× 18× 1× 189× 189× 189× 176× 189× 1× 318× 13× 13× 318× 9× 318× 318× 318× 318× 318× 13× 13× 13× 2× 2× 318× 318× 318× 60× 318× 318× 1× 318× 318× 318× 11× 11× 11× 11× 11× 27× 27× 27× 24× 27× 11× 24× 307× 672× 1× 318× 318× 318× 11× 11× 11× 11× 11× 27× 27× 27× 27× 11× 307× 1× 399× 399× 399× 399× 385× 385× 14× 14× 14× 1× 14× 14× 14× 14× 7× 7× 14× 14× 14× 14× 14× 14× 14× 14× 1× 413× 413× 413× 4× 4× 4× 409× 409× 1× 838× 1× 16× 1× | /** * @author Created by Marcus Spiegel <marcus.spiegel@gmail.com> on 2011-03-25. * @link https://github.com/mashpie/i18n-node * @license http://opensource.org/licenses/MIT * * @version 0.6.0 */ // dependencies and "private" vars var vsprintf = require('sprintf-js').vsprintf, fs = require('fs'), url = require('url'), path = require('path'), debug = require('debug')('i18n:debug'), warn = require('debug')('i18n:warn'), error = require('debug')('i18n:error'), Mustache = require('mustache'), locales = {}, api = [ '__', '__n', '__l', '__h', 'getLocale', 'setLocale', 'getCatalog', 'getLocales', 'addLocale', 'removeLocale' ], pathsep = path.sep || '/', // ---> means win support will be available in node 0.8.x and above autoReload, cookiename, defaultLocale, directory, directoryPermissions, extension, fallbacks, indent, logDebugFn, logErrorF, logWarnFn, objectNotation, prefix, queryParameter, register, updateFiles; // public exports var i18n = exports; i18n.version = '0.6.0'; i18n.configure = function i18nConfigure(opt) { // you may register i18n in global scope, up to you if (typeof opt.register === 'object') { register = opt.register; // or give an array objects to register to if (Array.isArray(opt.register)) { register = opt.register; register.forEach(function(r) { applyAPItoObject(r); }); } else { applyAPItoObject(opt.register); } } // sets a custom cookie name to parse locale settings from cookiename = (typeof opt.cookie === 'string') ? opt.cookie : null; // query-string parameter to be watched - @todo: add test & doc queryParameter = (typeof opt.queryParameter === 'string') ? opt.queryParameter : null; // where to store json files directory = (typeof opt.directory === 'string') ? opt.directory : __dirname + pathsep + 'locales'; // permissions when creating new directories directoryPermissions = (typeof opt.directoryPermissions === 'string') ? parseInt(opt.directoryPermissions, 8) : null; // write new locale information to disk updateFiles = (typeof opt.updateFiles === 'boolean') ? opt.updateFiles : true; // what to use as the indentation unit (ex: "\t", " ") indent = (typeof opt.indent === 'string') ? opt.indent : "\t"; // json files prefix prefix = (typeof opt.prefix === 'string') ? opt.prefix : ''; // where to store json files extension = (typeof opt.extension === 'string') ? opt.extension : '.json'; // setting defaultLocale defaultLocale = (typeof opt.defaultLocale === 'string') ? opt.defaultLocale : 'en'; // auto reload locale files when changed autoReload = (typeof opt.autoReload === 'boolean') ? opt.autoReload : false; // enable object notation? objectNotation = (typeof opt.objectNotation !== 'undefined') ? opt.objectNotation : false; if (objectNotation === true) objectNotation = '.'; // read language fallback map fallbacks = (typeof opt.fallbacks === 'object') ? opt.fallbacks : {}; // setting custom logger functions logDebugFn = (typeof opt.logDebugFn === 'function') ? opt.logDebugFn : debug; logWarnFn = (typeof opt.logWarnFn === 'function') ? opt.logWarnFn : warn; logErrorFn = (typeof opt.logErrorFn === 'function') ? opt.logErrorFn : error; // when missing locales we try to guess that from directory opt.locales = opt.locales || guessLocales(directory); // implicitly read all locales Eif (Array.isArray(opt.locales)) { opt.locales.forEach(function(l) { read(l); }); // auto reload locale files when changed if (autoReload) { // watch changes of locale files (it's called twice because fs.watch is still unstable) fs.watch(directory, function(event, filename) { var localeFromFile = guessLocaleFromFile(filename); if (localeFromFile && opt.locales.indexOf(localeFromFile) > -1) { logDebug("Auto reloading locale file '" + filename + "'."); read(localeFromFile); } }); } } }; i18n.init = function i18nInit(request, response, next) { Eif (typeof request === 'object') { // guess requested language/locale guessLanguage(request); // bind api to req applyAPItoObject(request); // looks double but will ensure schema on api refactor i18n.setLocale(request, request.locale); } else { return logError('i18n.init must be called with one parameter minimum, ie. i18n.init(req)'); } if (typeof response === 'object') { applyAPItoObject(response); // and set that locale to response too i18n.setLocale(response, request.locale); } // head over to next callback when bound as middleware Iif (typeof next === 'function') { next(); } }; i18n.__ = function i18nTranslate(phrase) { var msg, namedValues, args; // Accept an object with named values as the last parameter // And collect all other arguments, except the first one in args if ( arguments.length > 1 && arguments[arguments.length - 1] !== null && typeof arguments[arguments.length - 1] === "object" ) { namedValues = arguments[arguments.length - 1]; args = Array.prototype.slice.call(arguments, 1, -1); } else { namedValues = {}; args = arguments.length >= 2 ? Array.prototype.slice.call(arguments, 1) : []; } // called like __({phrase: "Hello", locale: "en"}) if (typeof phrase === 'object') { Eif (typeof phrase.locale === 'string' && typeof phrase.phrase === 'string') { msg = translate(phrase.locale, phrase.phrase); } } // called like __("Hello") else { // get translated message with locale from scope (deprecated) or object msg = translate(getLocaleFromObject(this), phrase); } // if the msg string contains {{Mustache}} patterns we render it as a mini tempalate if ((/{{.*}}/).test(msg)) { msg = Mustache.render(msg, namedValues); } // if we have extra arguments with values to get replaced, // an additional substition injects those strings afterwards if ((/%/).test(msg) && args && args.length > 0) { msg = vsprintf(msg, args); } return msg; }; i18n.__l = function i18nTranslationList(phrase) { var translations = []; Object.keys(locales).sort().forEach(function(l) { translations.push(i18n.__({ phrase: phrase, locale: l })); }); return translations; }; i18n.__h = function i18nTranslationHash(phrase) { var translations = []; Object.keys(locales).sort().forEach(function(l) { var hash = {}; hash[l] = i18n.__({ phrase: phrase, locale: l }); translations.push(hash); }); return translations; }; i18n.__n = function i18nTranslatePlural(singular, plural, count) { var msg, namedValues, args = []; // Accept an object with named values as the last parameter Iif ( arguments.length >= 2 && arguments[arguments.length - 1] !== null && typeof arguments[arguments.length - 1] === "object" ) { namedValues = arguments[arguments.length - 1]; args = arguments.length >= 5 ? Array.prototype.slice.call(arguments, 3, -1) : []; } else { namedValues = {}; args = arguments.length >= 4 ? Array.prototype.slice.call(arguments, 3) : []; } // called like __n({singular: "%s cat", plural: "%s cats", locale: "en"}, 3) if (typeof singular === 'object') { Eif (typeof singular.locale === 'string' && typeof singular.singular === 'string' && typeof singular.plural === 'string') { msg = translate(singular.locale, singular.singular, singular.plural); } args.unshift(count); // some template engines pass all values as strings -> so we try to convert them to numbers if (typeof plural === 'number' || parseInt(plural, 10) + "" === plural) { count = plural; } // called like __n({singular: "%s cat", plural: "%s cats", locale: "en", count: 3}) if (typeof singular.count === 'number' || typeof singular.count === 'string') { count = singular.count; args.unshift(plural); } } else { // called like __n('cat', 3) if (typeof plural === 'number' || parseInt(plural, 10) + "" === plural) { count = plural; args.unshift(count); args.unshift(plural); } // called like __n('%s cat', '%s cats', 3) // get translated message with locale from scope (deprecated) or object msg = translate(getLocaleFromObject(this), singular, plural); } Iif (count === null) count = namedValues.count; // parse translation and replace all digets '%d' by `count` // this also replaces extra strings '%%s' to parseble '%s' for next step // simplest 2 form implementation of plural, like https://developer.mozilla.org/en/docs/Localization_and_Plurals#Plural_rule_.231_.282_forms.29 if (count > 1) { msg = vsprintf(msg.other, [parseInt(count, 10)]); } else { msg = vsprintf(msg.one, [parseInt(count, 10)]); } // if the msg string contains {{Mustache}} patterns we render it as a mini tempalate Iif ((/{{.*}}/).test(msg)) { msg = Mustache.render(msg, namedValues); } // if we have extra arguments with strings to get replaced, // an additional substition injects those strings afterwards if ((/%/).test(msg) && args && args.length > 0) { msg = vsprintf(msg, args); } return msg; }; i18n.setLocale = function i18nSetLocale(object, locale, skipImplicitObjects) { // when given an array of objects => setLocale on each if (Array.isArray(object) && typeof locale === 'string') { for (var i = object.length - 1; i >= 0; i--) { i18n.setLocale(object[i], locale, true); } return i18n.getLocale(object[0]); } // defaults to called like i18n.setLocale(req, 'en') var target_object = object; var target_locale = locale; // called like req.setLocale('en') or i18n.setLocale('en') if (locale === undefined && typeof object === 'string') { target_object = this; target_locale = object; } // consider a fallback if (!locales[target_locale] && fallbacks[target_locale]) { target_locale = fallbacks[target_locale]; } // now set locale on object target_object.locale = locales[target_locale] ? target_locale : defaultLocale; // consider any extra registered objects if (typeof register === 'object') { if (Array.isArray(register) && !skipImplicitObjects) { register.forEach(function(r) { r.locale = target_object.locale; }); } else { register.locale = target_object.locale; } } // consider res if (target_object.res && !skipImplicitObjects) { i18n.setLocale(target_object.res, target_object.locale); } // consider locals if (target_object.locals && !skipImplicitObjects) { i18n.setLocale(target_object.locals, target_object.locale); } return i18n.getLocale(target_object); }; i18n.getLocale = function i18nGetLocale(request) { // called like i18n.getLocale(req) if (request && request.locale) { return request.locale; } // called like req.getLocale() return this.locale || defaultLocale; }; i18n.getCatalog = function i18nGetCatalog(object, locale) { var target_locale; // called like i18n.getCatalog(req) if (typeof object === 'object' && typeof object.locale === 'string' && locale === undefined) { target_locale = object.locale; } // called like i18n.getCatalog(req, 'en') if (!target_locale && typeof object === 'object' && typeof locale === 'string') { target_locale = locale; } // called like req.getCatalog('en') if (!target_locale && locale === undefined && typeof object === 'string') { target_locale = object; } // called like req.getCatalog() if (!target_locale && object === undefined && locale === undefined && typeof this.locale === 'string') { if (register && register.GLOBAL) { target_locale = ''; } else { target_locale = this.locale; } } // called like i18n.getCatalog() if (target_locale === undefined || target_locale === '') { return locales; } if (!locales[target_locale] && fallbacks[target_locale]) { target_locale = fallbacks[target_locale]; } if (locales[target_locale]) { return locales[target_locale]; } else { logWarn('No catalog found for "' + target_locale + '"'); return false; } }; i18n.getLocales = function i18nGetLocales() { return Object.keys(locales); }; i18n.addLocale = function i18nAddLocale(locale) { read(locale); }; i18n.removeLocale = function i18nRemoveLocale(locale) { delete locales[locale]; }; // =================== // = private methods = // =================== /** * registers all public API methods to a given response object when not already declared */ function applyAPItoObject(object) { // attach to itself if not provided api.forEach(function(method) { // be kind rewind, or better not touch anything already exiting if (!object[method]) { object[method] = function() { return i18n[method].apply(object, arguments); }; } }); // set initial locale if not set if (!object.locale) { object.locale = defaultLocale; } // attach to response if present (ie. in express) if (object.res) { applyAPItoObject(object.res); } // attach to locals if present (ie. in express) if (object.locals) { applyAPItoObject(object.locals); } } /** * tries to guess locales by scanning the given directory */ function guessLocales(directory) { var entries = fs.readdirSync(directory); var localesFound = []; for (var i = entries.length - 1; i >= 0; i--) { if (entries[i].match(/^\./)) continue; var localeFromFile = guessLocaleFromFile(entries[i]); if (localeFromFile) localesFound.push(localeFromFile); } return localesFound.sort(); } /** * tries to guess locales from a given filename */ function guessLocaleFromFile(filename) { var extensionRegex = new RegExp(extension + '$', 'g'); var prefixRegex = new RegExp('^' + prefix, "g"); if (prefix && !filename.match(prefixRegex)) return false; if (extension && !filename.match(extensionRegex)) return false; return filename.replace(prefix, '').replace(extensionRegex, ''); } /** * guess language setting based on http headers */ function guessLanguage(request) { Eif (typeof request === 'object') { var language_header = request.headers['accept-language'], languages = [], regions = []; request.languages = [defaultLocale]; request.regions = [defaultLocale]; request.language = defaultLocale; request.region = defaultLocale; // a query parameter overwrites all if (queryParameter && request.url) { var urlObj = url.parse(request.url, true); Eif (urlObj.query[queryParameter]) { logDebug("Overriding locale from query: " + urlObj.query[queryParameter]); request.language = urlObj.query[queryParameter].toLowerCase(); return i18n.setLocale(request, request.language); } } // a cookie overwrites headers if (cookiename && request.cookies && request.cookies[cookiename]) { request.language = request.cookies[cookiename]; return i18n.setLocale(request, request.language); } // 'accept-language' is the most common source Eif (language_header) { var accepted_languages = getAcceptedLanguagesFromHeader(language_header), match, fallbackMatch, fallback; for (var i = 0; i < accepted_languages.length; i++) { var lang = accepted_languages[i], lr = lang.split('-', 2), parentLang = lr[0], region = lr[1]; // Check if we have a configured fallback set for this language. if (fallbacks && fallbacks[lang]) { fallback = fallbacks[lang]; // Fallbacks for languages should be inserted where the original, unsupported language existed. var acceptedLanguageIndex = accepted_languages.indexOf(lang); Eif (accepted_languages.indexOf(fallback) < 0) { accepted_languages.splice(acceptedLanguageIndex + 1, 0, fallback); } } // Check if we have a configured fallback set for the parent language of the locale. if (fallbacks && fallbacks[parentLang]) { fallback = fallbacks[parentLang]; // Fallbacks for a parent language should be inserted to the end of the list, so they're only picked // if there is no better match. if (accepted_languages.indexOf(fallback) < 0) { accepted_languages.push(fallback); } } if (languages.indexOf(parentLang) < 0) { languages.push(parentLang.toLowerCase()); } if (region) { regions.push(region.toLowerCase()); } if (!match && locales[lang]) { match = lang; break; } if (!fallbackMatch && locales[parentLang]) { fallbackMatch = parentLang; } } request.language = match || fallbackMatch || request.language; request.region = regions[0] || request.region; return i18n.setLocale(request, request.language); } } // last resort: defaultLocale return i18n.setLocale(request, defaultLocale); } /** * Get a sorted list of accepted languages from the HTTP Accept-Language header */ function getAcceptedLanguagesFromHeader(header) { var languages = header.split(','), preferences = {}; return languages.map(function parseLanguagePreference(item) { var preferenceParts = item.trim().split(';q='); if (preferenceParts.length < 2) { preferenceParts[1] = 1.0; } else { var quality = parseFloat(preferenceParts[1]); preferenceParts[1] = quality ? quality : 0.0; } preferences[preferenceParts[0]] = preferenceParts[1]; return preferenceParts[0]; }).filter(function(lang) { return preferences[lang] > 0; }).sort(function sortLanguages(a, b) { return preferences[b] - preferences[a]; }); } /** * searches for locale in given object */ function getLocaleFromObject(obj) { var locale; Iif (obj && obj.scope) { locale = obj.scope.locale; } if (obj && obj.locale) { locale = obj.locale; } return locale; } /** * read locale file, translate a msg and write to fs if new */ function translate(locale, singular, plural) { if (locale === undefined) { logWarn("WARN: No locale found - check the context of the call to __(). Using " + defaultLocale + " as current locale"); locale = defaultLocale; } if (!locales[locale] && fallbacks[locale]) { locale = fallbacks[locale]; } // attempt to read when defined as valid locale Iif (!locales[locale]) { read(locale); } // fallback to default when missed Iif (!locales[locale]) { logWarn("WARN: Locale " + locale + " couldn't be read - check the context of the call to $__. Using " + defaultLocale + " (default) as current locale"); locale = defaultLocale; read(locale); } var defaultSingular = singular; var defaultPlural = plural; if (objectNotation) { var indexOfColon = singular.indexOf(':'); // We compare against 0 instead of -1 because we don't really expect the string to start with ':'. Iif (0 < indexOfColon) { defaultSingular = singular.substring(indexOfColon + 1); singular = singular.substring(0, indexOfColon); } if (plural && typeof plural !== 'number') { indexOfColon = plural.indexOf(':'); Iif (0 < indexOfColon) { defaultPlural = plural.substring(indexOfColon + 1); plural = plural.substring(0, indexOfColon); } } } var accessor = localeAccessor(locale, singular); var mutator = localeMutator(locale, singular); if (plural) { Iif (!accessor()) { mutator({ 'one': defaultSingular || singular, 'other': defaultPlural || plural }); write(locale); } } Iif (!accessor()) { mutator(defaultSingular || singular); write(locale); } return accessor(); } /** * Allows delayed access to translations nested inside objects. * @param {String} locale The locale to use. * @param {String} singular The singular term to look up. * @param {Boolean} [allowDelayedTraversal=true] Is delayed traversal of the tree allowed? * This parameter is used internally. It allows to signal the accessor that * a translation was not found in the initial lookup and that an invocation * of the accessor may trigger another traversal of the tree. * @returns {Function} A function that, when invoked, returns the current value stored * in the object at the requested location. */ function localeAccessor(locale, singular, allowDelayedTraversal) { // Bail out on non-existent locales to defend against internal errors. Iif (!locales[locale]) return Function.prototype; // Handle object lookup notation var indexOfDot = objectNotation && singular.indexOf(objectNotation); if (objectNotation && (0 < indexOfDot && indexOfDot < singular.length)) { // If delayed traversal wasn't specifically forbidden, it is allowed. Eif (typeof allowDelayedTraversal == "undefined") allowDelayedTraversal = true; // The accessor we're trying to find and which we want to return. var accessor = null; // An accessor that returns null. var nullAccessor = function() { return null; }; // Do we need to re-traverse the tree upon invocation of the accessor? var reTraverse = false; // Split the provided term and run the callback for each subterm. singular.split(objectNotation).reduce(function(object, index) { // Make the accessor return null. accessor = nullAccessor; // If our current target object (in the locale tree) doesn't exist or // it doesn't have the next subterm as a member... Iif (null === object || !object.hasOwnProperty(index)) { // ...remember that we need retraversal (because we didn't find our target). reTraverse = allowDelayedTraversal; // Return null to avoid deeper iterations. return null; } // We can traverse deeper, so we generate an accessor for this current level. accessor = function() { return object[index]; }; // Return a reference to the next deeper level in the locale tree. return object[index]; }, locales[locale]); // Return the requested accessor. return function() { // If we need to re-traverse (because we didn't find our target term) // traverse again and return the new result (but don't allow further iterations) // or return the previously found accessor if it was already valid. return (reTraverse) ? localeAccessor(locale, singular, false)() : accessor(); }; } else { // No object notation, just return an accessor that performs array lookup. return function() { return locales[locale][singular]; }; } } /** * Allows delayed mutation of a translation nested inside objects. * @description Construction of the mutator will attempt to locate the requested term * inside the object, but if part of the branch does not exist yet, it will not be * created until the mutator is actually invoked. At that point, re-traversal of the * tree is performed and missing parts along the branch will be created. * @param {String} locale The locale to use. * @param {String} singular The singular term to look up. * @param [Boolean} [allowBranching=false] Is the mutator allowed to create previously * non-existent branches along the requested locale path? * @returns {Function} A function that takes one argument. When the function is * invoked, the targeted translation term will be set to the given value inside the locale table. */ function localeMutator(locale, singular, allowBranching) { // Bail out on non-existent locales to defend against internal errors. Iif (!locales[locale]) return Function.prototype; // Handle object lookup notation var indexOfDot = objectNotation && singular.indexOf(objectNotation); if (objectNotation && (0 < indexOfDot && indexOfDot < singular.length)) { // If branching wasn't specifically allowed, disable it. Eif (typeof allowBranching == "undefined") allowBranching = false; // This will become the function we want to return. var accessor = null; // An accessor that takes one argument and returns null. var nullAccessor = function() { return null; }; // Are we going to need to re-traverse the tree when the mutator is invoked? var reTraverse = false; // Split the provided term and run the callback for each subterm. singular.split(objectNotation).reduce(function(object, index) { // Make the mutator do nothing. accessor = nullAccessor; // If our current target object (in the locale tree) doesn't exist or // it doesn't have the next subterm as a member... Iif (null === object || !object.hasOwnProperty(index)) { // ...check if we're allowed to create new branches. if (allowBranching) { // If we are allowed to, create a new object along the path. object[index] = {}; } else { // If we aren't allowed, remember that we need to re-traverse later on and... reTraverse = true; // ...return null to make the next iteration bail our early on. return null; } } // Generate a mutator for the current level. accessor = function(value) { object[index] = value; return value; }; // Return a reference to the next deeper level in the locale tree. return object[index]; }, locales[locale]); // Return the final mutator. return function(value) { // If we need to re-traverse the tree // invoke the search again, but allow branching this time (because here the mutator is being invoked) // otherwise, just change the value directly. return (reTraverse) ? localeMutator(locale, singular, true)(value) : accessor(value); }; } else { // No object notation, just return a mutator that performs array lookup and changes the value. return function(value) { locales[locale][singular] = value; return value; }; } } /** * try reading a file */ function read(locale) { var localeFile = {}, file = getStorageFilePath(locale); try { logDebug('read ' + file + ' for locale: ' + locale); localeFile = fs.readFileSync(file); try { // parsing filecontents to locales[locale] locales[locale] = JSON.parse(localeFile); } catch (parseError) { logError('unable to parse locales from file (maybe ' + file + ' is empty or invalid json?): ', parseError); } } catch (readError) { // unable to read, so intialize that file // locales[locale] are already set in memory, so no extra read required // or locales[locale] are empty, which initializes an empty locale.json file // since the current invalid locale could exist, we should back it up Iif (fs.existsSync(file)) { logDebug('backing up invalid locale ' + locale + ' to ' + file + '.invalid'); fs.renameSync(file, file + '.invalid'); } logDebug('initializing ' + file); write(locale); } } /** * try writing a file in a created directory */ function write(locale) { var stats, target, tmp; // don't write new locale information to disk if updateFiles isn't true Iif (!updateFiles) { return; } // creating directory if necessary try { stats = fs.lstatSync(directory); } catch (e) { logDebug('creating locales dir in: ' + directory); fs.mkdirSync(directory, directoryPermissions); } // first time init has an empty file Iif (!locales[locale]) { locales[locale] = {}; } // writing to tmp and rename on success try { target = getStorageFilePath(locale); tmp = target + ".tmp"; fs.writeFileSync(tmp, JSON.stringify(locales[locale], null, indent), "utf8"); stats = fs.statSync(tmp); Eif (stats.isFile()) { fs.renameSync(tmp, target); } else { logError('unable to write locales to file (either ' + tmp + ' or ' + target + ' are not writeable?): '); } } catch (e) { logError('unexpected error writing files (either ' + tmp + ' or ' + target + ' are not writeable?): ', e); } } /** * basic normalization of filepath */ function getStorageFilePath(locale) { // changed API to use .json as default, #16 var ext = extension || '.json', filepath = path.normalize(directory + pathsep + prefix + locale + ext), filepathJS = path.normalize(directory + pathsep + prefix + locale + '.js'); // use .js as fallback if already existing try { Eif (fs.statSync(filepathJS)) { logDebug('using existing file ' + filepathJS); extension = '.js'; return filepathJS; } } catch (e) { logDebug('will use ' + filepath); } return filepath; } /** * Logging proxies */ function logDebug(msg) { logDebugFn(msg); } function logWarn(msg) { logWarnFn(msg); } function logError(msg) { logErrorFn(msg); } |