granula
Version:
i18n tool for angular.js applications
200 lines (190 loc) • 6.89 kB
JavaScript
(function() {
var argumentParser, context, justText, notEmpty, pluralization, pluralizerParser, precompile, stringInterpolator, _ref,
__slice = [].slice;
_ref = require('./compile/parsers'), argumentParser = _ref.argumentParser, pluralizerParser = _ref.pluralizerParser, justText = _ref.justText;
stringInterpolator = require('./interpolators').stringInterpolator;
context = require('./compile/context').context;
pluralization = require('./pluralization')();
module.exports = function(options) {
var lang, precompiled;
lang = {};
precompiled = {};
return {
defaultInterpolator: stringInterpolator(),
load: function(langDefinition) {
var key, langName, setOfValues, value, _results;
_results = [];
for (langName in langDefinition) {
setOfValues = langDefinition[langName];
lang[langName] || (lang[langName] = {});
_results.push((function() {
var _results1;
_results1 = [];
for (key in setOfValues) {
value = setOfValues[key];
if (key === "_pluralize") {
_results1.push(pluralization.updatePluralization(langName, setOfValues._pluralize, setOfValues._normalize));
} else if (key === "_normalize") {
} else {
_results1.push(lang[langName][key] = value);
}
}
return _results1;
})());
}
return _results;
},
translate: function() {
var args, key, language;
language = arguments[0], key = arguments[1], args = 3 <= arguments.length ? __slice.call(arguments, 2) : [];
return this._apply.apply(this, [language, key].concat(__slice.call(args)));
},
canTranslate: function(language, key) {
var _ref1;
return ((_ref1 = lang[language]) != null ? _ref1[key] : void 0) !== void 0;
},
canTranslateTo: function(language) {
return lang[language] !== void 0;
},
compile: function(language, pattern) {
var p;
if (pattern.key) {
p = this._precompiled(language, pattern.key);
} else {
p = precompile(pattern, this._parsers(language));
}
return this._applier(p);
},
debug: function(str, lang) {
if (lang == null) {
lang = "en";
}
return this.compile(lang, str).apply({
begin: function() {
return console.log("{");
},
argument: function(ctx, _arg) {
var argName;
argName = _arg.argName;
return console.log(" arg: " + argName);
},
pluralExpression: function(ctx, _arg, _arg1) {
var argName, suffixes, word;
word = _arg.word, suffixes = _arg.suffixes;
argName = _arg1.argName;
return console.log(" plural: " + word + "(" + suffixes + "):" + argName);
},
string: function(ctx, str) {
return console.log(" '" + str + "'");
},
end: function() {
return console.log("}");
}
});
},
_applier: function(precompiled) {
var fn,
_this = this;
fn = function() {
var args;
args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
return precompiled.apply(args, _this.defaultInterpolator);
};
fn.apply = function() {
var args, interpolator;
interpolator = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
return precompiled.apply(args, interpolator);
};
return fn;
},
_precompiled: function(language, key) {
var _ref1, _ref2;
return (_ref1 = (_ref2 = precompiled[language]) != null ? _ref2[key] : void 0) != null ? _ref1 : this._precompile(language, key);
},
_parsers: function(language) {
return [
argumentParser(), pluralizerParser(function(word, suffixes) {
return pluralization.preparePluralizationFn(language, word, suffixes);
})
];
},
_precompile: function(language, key) {
precompiled[language] || (precompiled[language] = {});
if (!precompiled[language]._parsers) {
precompiled[language]._parsers = this._parsers(language);
}
return precompiled[language][key] = precompile(this._get(language, key), precompiled[language]._parsers);
},
_apply: function() {
var args, key, language;
language = arguments[0], key = arguments[1], args = 3 <= arguments.length ? __slice.call(arguments, 2) : [];
return this._precompiled(language, key).apply(args, this.defaultInterpolator);
},
_get: function(language, key) {
var val;
if (!lang[language]) {
throw new Error("Language '" + language + "' was not initialized with 'load' method");
}
val = lang[language][key];
if (!val) {
throw new Error("There is no definition for '" + key + "' in language '" + language + "'");
}
return val;
}
};
};
notEmpty = function(str) {
return str.length > 0;
};
precompile = function(text, parsers) {
var ctx, currentPos, isEnd, nearestPosition, parser, parserIdx, part, positions, remaining, substr, _ref1;
ctx = {
parts: []
};
currentPos = 0;
positions = parsers.map(function(p) {
return p.nextPosition(text, 0);
});
isEnd = function() {
return positions.every(function(pos) {
return pos === -1;
});
};
while (!(isEnd())) {
nearestPosition = Math.min.apply(null, positions.filter(function(p) {
return p > -1;
}));
parserIdx = positions.indexOf(nearestPosition);
parser = parsers[parserIdx];
substr = text.substring(currentPos, nearestPosition);
if (notEmpty(substr)) {
ctx.parts.push(justText(substr));
}
_ref1 = parser.process(text, nearestPosition, ctx), part = _ref1.part, currentPos = _ref1.currentPos;
ctx.parts.push(part);
positions.forEach(function(pos, idx) {
if (pos < currentPos) {
return positions[idx] = parsers[idx].nextPosition(text, currentPos);
}
});
}
remaining = text.substring(currentPos);
if (notEmpty(remaining)) {
ctx.parts.push(justText(remaining));
}
ctx.parts.forEach(function(part, idx) {
if (part.link) {
return part.link(ctx, idx);
}
});
return {
apply: function(args, interpolator) {
return context(args, interpolator).apply(function(context) {
return (ctx.parts.map(function(p) {
return p.apply(context);
})).join("");
});
}
};
};
}).call(this);