Is it possible to replace {} with a backspace for localizations - json

Question

We are using flutter easy localizations and we have texts that use arguments. So for example we have a string in our localizations doc like below,
{
"someAppText":"This is {} app text {}."
}
But sometimes the argument will be empty. Which will result in the following text
This is[SPACE][SPACE]app text[SPACE].
Where the spaces are still there. Is it possible to do a backspace whenever we have no arguments?

Answer 1

Firstly, what about using plural? Sounds like you want to have a different text for different kind of data. I do not come up with other examples when an arg will be empty, so if it is not your case could you please give a concrete example?
Secondly, you can do simple string manipulation as follows (pseudocode). The code only demonstrates the simplest case (to make it brief), but it is trivial to extend to the full case.
String myTranslate(String formatString, List<String> args) {
const EMPTY_MARKER = 'EMPTY_MARKER';
final transformedArgs = args.map((arg) => arg.isEmpty ? EMPTY_MARKER : arg).toList();
final rawString = formatString.tr(transformedArgs);
return rawString.replaceAll(' $EMPTY_MARKER', '');
}
Then in your example, it will output: This is[SPACE]app text.

Answer 2

we can not add any methods inside a JSON file, and only have to use it's simple map<String, String> data
so
a work around solution would use special strings inside the JSON to be able to detect and process them in run time
let's say JSON would have this
{
"someAppText": "This is #VAR01 app text #VAR02."
}
then let us create another class that has methods to handle these special words, they should detect them, and replace them with other dynamic inputs
so
class JSONWorkAround {
/// A - need to define the string pattern we are using in the string which I assumed to look like '#VAR00'
/// let's call them jsonVariables
/// NOTE : if you would like to name them #VAR000 ,, then regExp would be r'#VAR...'
static RegExp regExp = RegExp(r'#VAR..');
/// B - let's make a tracker for any word that matches this regExp in any input string
static List<String> _searchJSONVariablesByRegExp({#required String text, #required RegExp regExp}){
List<String> _strings;
/// always check if not null before we do stuff to avoid errors and save performance
if (text != null){
_strings = regExp.allMatches(text).map((m) => m.group(0)).toList();
}
return _strings;
}
/// C - let's make the tracker specifically for those JSONVariables from a string received from the JSON doc "let's call it rawString"
static List<String> _searchJSONVariablesFromRawString({#required String rawString}){
final List<String> _jsonVariables = _searchJSONVariablesByRegExp(text: rawString, regExp: regExp);
return _jsonVariables;
}
/// E - let's see what to do with the search result
static List<SpecialWord> _processJSONVariables(List<String> jsonVariables){
List<SpecialWord> _outputSpecialWords = <SpecialWord>[];
/// so w notice we will need to process each one alone,, so we loop them out
if(jsonVariables != null && jsonVariables.isNotEmpty){
jsonVariables.forEach((jsonVariable) {
/// we should receive a substitute string instead of that #VAR00 special string,, so ..
/// actually we need to receive a string that is accompanied with its cipher special thing to be able to go back to the sentence and change it,,, like using this special #VAR00 thing as ID
/// and I don't like map<String, dynamic> but I would rather create a model class ,, will be written down there at the end of this class
final SpecialWord _substitute = _processSingleJSONVariable(jsonVariable: jsonVariable);
/// then we add them to the output List
if (_substitute != null){
_outputSpecialWords.add(_substitute);
}
});
}
return _outputSpecialWords;
}
/// D - need to receive both the substitute and its (JSONSpecialVariable / ID) to be able to search for it and process it in the original string
static SpecialWord _processSingleJSONVariable({#required String jsonVariable}){
final SpecialWord _substitute = SpecialWord.getSpecialWordFromAllSpecialWordsByID(jsonVariable);
return _substitute;
}
/// F - finally after receiving the substitutes inside a list<SpecialWord>,, we get get back the original String with the substitutes
static String processJSONStringThatContainsThoseSpecialVariables(String rawString){
/// this has to initialize with the initial raw string value to be processed
String _processedString = rawString;
final List<String> _jsonVariables = _searchJSONVariablesFromRawString(rawString: rawString);
if (_jsonVariables != null && _jsonVariables.isNotEmpty){
final List<SpecialWord> _specialWords = _processJSONVariables(_jsonVariables);
/// then we need to change each jsonVariable with its substitute
_specialWords.forEach((specialWord) {
_processedString = _replaceSubStringWith(
subStringToReplace: specialWord.id,
replacement: specialWord.substitute,
input: _processedString,
);
});
}
return _processedString;
}
/// G - a text replacing method to easily replace a given subString from a string with another value
static String _replaceSubStringWith({#required String subStringToReplace, #required String replacement, #required String input}){
final String _output = input.replaceAll(subStringToReplace, replacement);
return _output;
}
}
class SpecialWord{
final String id;
final String substitute; // you can change this to be more complex to adapt to many languages or other things
const SpecialWord({
#required this.id,
#required this.substitute,
});
/// lets create a list of constants that u may change in future and call from db or wherever
static const List<SpecialWord> _allSpecialWords = const <SpecialWord>[
SpecialWord(id: '#VAR01', substitute: 'Baby'),
SpecialWord(id: '#VAR02', substitute: 'Cool'),
SpecialWord(id: '#VAR03', substitute: 'You got the Idea'),
];
/// I like to pamper myself with super quick methods to be clean and organized
static SpecialWord getSpecialWordFromAllSpecialWordsByID(String id){
SpecialWord _foundWord;
if (id != null){
_foundWord = _allSpecialWords.firstWhere((word) => word.id == id, orElse: () => null);
}
return _foundWord;
}
}
then lets make a little method test to assure the safety of this boiler plate over engineered code
test("Testing JSON Variables work around idea", () async {
String _rawString = "This is #VAR01 app text #VAR02.";
String _processedString = JSONWorkAround.processJSONStringThatContainsThoseSpecialVariables(_rawString);
String _expectation = "This is Baby app text Cool.";
expect(_processedString, _expectation);
});
But now you might ask yourself,, is it worth it,, did I over engineer things,, is there a wiser solution ?,, maybe just save each case in json from the start,, I don't know,,
I'm afraid I over complicated the solution,, but it works like a charm

Answer 3

I am not sure i understood your issue. But try the following.
Add two translations one for the empty argument someAppTextEmpty and one for the regular one someAppText
{
"someAppText": "This is {} app text {}.",
"someAppTextEmpty": "This is the alternative app text."
}
Then check if the argument is empty or not to get the right translation key:
final String translationKey = argument.isNotEmpty
? 'someAppText' : 'someAppTextEmpty';
Then pass the variable translationKey to the translation function of easy_localization like this:
final String title = tr(translationKey);
// Or
Text(translationKey).tr();
// Or
translationKey.tr();

Answer 4

No.
With or without easy_localization, the backspace character in Dart takes 1 space in a String instead of deleting 1 space. That is my conclusion through trial and error.
My suggestion:
Create a string called BACKSPACE with a never used value starting by a space eg:
final String BACKSPACE = 'NEVER_USED_VALUE';
When appropriate, assign BACKSPACE to value1 and value2 instead of an empty string.
Then, do this:
'someAppText'.tr(value1, value2).replaceAll(' ' + BACKSPACE, '');