How to achieve reverse localization (user input) on Laravel 5.x? - php

Question

Laravel's localization features provide a convenient way to retrieve strings in various languages, allowing to easily support multiple languages within the application.
At this point I'm using the function trans() and related that ships with Laravel, to translate (localize) the user interface (output) of my application, as one would usually do with a default setup. As how this strategy works, we are translating english keys into another language. It is clear that keys need not to be in any particular language, and they don't even need to be readable text, that we just keep them readable for sake of software maintainability and comply a standard, since the programmatic keywords are in english.
My question is if there's a well known way to accurately translate user input in a selected language back to the base language (let's say english).
An example of this would be letting the user to write certain keywords or expressions in their language as input, and get them into a base language.
Currently, I would do something like this:
// Dummy Sample Code I
$foreignInput = 'lunes';
$translatedToBase = trans("input.days.$foreignInput");
dd($translatedToBase); // "monday"
// lang/es/input.php
[
// ...
'days' => [
'lunes' => 'monday',
// ...
],
// ...
]
I would also do something like this:
// Dummy Sample Code II
$foreignInput = 'lun';
$translatedToBase = trans("input.days.$foreignInput");
dd($translatedToBase); // "mon"
// lang/es/input.php
[
// ...
'days' => [
'lun' => 'mon',
// ...
],
// ...
]
This would perfectly work for the purpose, however, it feels hacky (unsafe, little reliable, hard to maintain and counter-intuitive) and I wonder if there's a package of better way to achieve this. I could even require not using trans(), that's fine for me.
I understand there may be lots of options, so suggestions are welcome as long as I can keep some constrains:
Also please note that in this example I used a weekday name, but I'd not limit the solution to a datetime context.
Plus, I'm seeking to rely on the translation to be strict, this means that I'm expecting it to be deterministic, reason I'm putting aside a live translation external service.
Thanks for reading!

Answer 1

First of all, I wouldn't structure the language files the way you suggested. It's a subversion of Laravel's organisation to have shifting keys that have the same value throughout translations, and they would have to be specifically populated for reverse translation because they'd be too hard to use for normal translation. I'd much rather stick to the normal Laravel structure:
// lang/en/input.php
[
// ...
'days' => [
'monday' => 'Monday',
// ...
],
// ...
];
// lang/es/input.php
[
// ...
'days' => [
'monday' => 'lunes',
// ...
],
// ...
]
// lang/de/input.php
[
// ...
'days' => [
'monday' => 'Montag',
// ...
],
// ...
]
Here's an object capable of processing the reverse translation:
<?php
use Illuminate\Support\Facades\File;
use Illuminate\Support\Str;
use RecursiveArrayIterator;
use RecursiveIteratorIterator;
class ReverseTranslator
{
protected $languageGroups = [];
protected function loadGroups($locale)
{
// Iterate through all available groups and store
$languagePath = resource_path("lang/{$locale}/");
$languageGroups = array_map(function ($file) use ($languagePath) {
return str_replace([$languagePath, '.php'], '', $file);
}, File::glob($languagePath.'*.php'));
$this->languageGroups[$locale] = $languageGroups;
return $languageGroups;
}
protected function lowercase($value)
{
return is_array($value) ? array_map([$this, 'lowercase'], $value) : Str::lower($value);
}
protected function arraySearchRecursive($search, array $array, $mode = 'value', $return = false) {
$iterator = new RecursiveIteratorIterator(new RecursiveArrayIterator($array));
foreach ($iterator as $key => $value) {
if ($search == $value) {
$keys = [];
for ($i = $iterator->getDepth()-1; $i >= 0; $i--) {
$keys[] = $iterator->getSubIterator($i)->key();
}
$keys[] = $key;
return implode('.', $keys);
}
}
return false;
}
protected function search($foreign, $group, $locale = 'en')
{
// Load all strings for group in current language
$groupStrings = trans($group);
// Recursive and case-insensitive search
return $this->arraySearchRecursive($this->lowercase($foreign), $this->lowercase($groupStrings));
}
public function get($foreign, $group = null, $locale = 'en')
{
if (!$group) {
if (!isset($this->languageGroups[$locale])) {
$this->loadGroups($locale);
}
foreach ($this->languageGroups[$locale] as $group) {
$key = $this->search($foreign, $group, $locale);
if ($key !== false) {
return trans("{$group}.{$key}", [], null, $locale);
}
}
// Failed to match -- return original string
return $foreign;
}
$key = $this->search($foreign, $group, $locale);
if ($key !== false) {
return trans("{$group}.{$key}", [], null, $locale);
}
// Failed to match -- return original string
return $foreign;
}
}
Put this on your app/Providers/AppServiceProvider.php inside the register method:
$this->app->bind('reverse-translator', function () {
return new ReverseTranslator();
});
Then you could build a Facade to access your object more literally.
class ReverseTranslator extends \Illuminate\Support\Facades\Facade
{
/**
* Get the registered name of the component.
*
* #return string
*/
protected static function getFacadeAccessor()
{
return 'reverse-translator';
}
}
Now you can write your helper like so (using the Facade, not the object itself):
function rtrans($foreign, $group = null, $locale = 'en') {
return ReverseTranslator::get($foreign, $group, $locale);
}
Then usage would simple:
rtrans('lunes'); // "Monday"
rtrans('lunes', 'input'); // "Monday", quicker
rtrans('lunes', 'input.days'); // "Monday", quickest
rtrans('lunes', 'other'); // "lunes", because of wrong group
rtrans('lunes', null, 'de'); // "Montag"
Note:
I've made the search case-insensitive to be a little easier to use, and because case is relevant and should be considered in translation arrays (see "Monday" on lang/en/input.php).
Obviously it's much more efficient to know which file you want to load and search, so if you know your translating weekdays, you'd pass 'days' as your group. But if you don't know, then you'd have to iterate through all available language files, which could become costly depending on how often you do it and how many files you have.
Maybe the ideal solution would be to extend the default Laravel translator to give it "reverse translation" capabilities, instead of using a stand-alone object like above, but for the sake of clarity it has been isolated.
I hope this is a good starting point. Buena suerte!