When film titles get translated into other languages, the results can get downright weird. Here are some of the funniest and most surreal examples. The disadvantage of literal translations is that they are harder to read because more Hebrew and Greek style intrudes into the English text. Compare the following renderings of Leviticus 18:6-10 from the New American Standard Bible (NAS—a literal translation) and the New International Version (NIV—a dynamic translation).

Hello everyone ! First time posting here, hope I'll do it well : )

Translate a live, captioned conversation from the Translator app. Translate the text in photos with the app's built-in camera viewer, or upload saved photos from your gallery. Visit our languages page to see which features are available in your language.

I would like to start playing to the JP version of the game. Unfortunately I don't speak japanese (started learning, but the reading is very far away...), and I dont want to keep browsing the Internet for each bit of text.

My question is : do you know an android app which is able to translate the screen content (the same way as google translate allows you to translate a text you take a picture of) ? I tried a lot but none worked properly (maybe some japanese speakers know some japanese apps doing so) ?

Thanks a lot in advance for your help.

In one of our previous articles we were talking about the process of internationalizing Rails applications. That article explained all I18n basics, but it was revolving around placing all translations inside YAML files. There is nothing wrong about this approach, but unfortunately it does not always work. Suppose, your website has lots of user-generated content which should be adapted for different languages. Therefore, I propose to store your translations inside database. Why YAML files won’t work in this case?

The content itself may be quite large and it would be inconvenient to store it inside a file
The content is dynamic and users should be able to create translated versions themselves, without the help of the site’s developer

It appears that I18n module allows you to define a custom backend that, for instance, may be powered by ActiveRecord. Luckily, there is no need to craft your own solution as there is already an existing one: Globalize. Globalize is a battle-tested library characterized as “Rails I18n de-facto standard library for ActiveRecord model/data translation“. With its help you can easily translate model attributes, scope them, introduce fallbacks etc.

So, in this article we are going to talk about Globalize and see it in action by creating a sample Rails application. Shall we start?

Preparing the Application
Globalize, Globalize it Hard!
Some More Globalize Features

Preparing the Application

Let’s get started by generating a new Rails app:

I’ll assume you are using Rails 5.2.1 for this demo but still the described concepts apply to earlier versions as well.

Let’s suppose we are building an international online shop showcasing various products. These products will be added by the administrator, and so we can’t know what the content will be ahead of the game. It means that the traditional method of using YAML files to store translations won’t work. Our content manager will have access to the CMS only, and we would rather not give him access to the source code of the app (I shudder to think about it!). But, fear not, in the next section we will overcome this problem easily. For now, however, let’s take care of the basics.

Administering Products

Utilize code generator and create a new scaffold for the Product:

This should create model, controller, routes, and views for the products. Don’t forget to run migration:

Now start the server:

Visit the http://localhost:3000/products path and make sure that you are able to add, modify, and delete the products.

Switching the Language

In order to see Globalize library in action, we will need a way to switch the app’s locale. I won’t cover this process in detail (as we have a separate article on the topic) so let’s do it quickly.

First, add the list of supported locales to the config/application.rb:

Title Translation Spanish

I will be supporting English and Russian, but you may choose any other languages.

Next, tweak the config/routes.rb and wrap the products resource with a scope. Also, while we are here, add a root route:

After that, modify the application_controller.rb file:

This code will set locale on every request while making sure the chosen language is actually supported. Also, it will add a locale GET param to each link generated with the link_to helper.

Lastly, add two links to the application layout:

To ensure that this new feature works, add translation for the Products page title:

Now simply utilize these translations inside the views/products/index.html.erb:

Note that we can take advantage of the “lazy lookup” because the translation keys were named in the proper way.

Translate other static content as necessary, then reload the server, and make sure that the locale can be properly switched. Great!

Globalize, Globalize it Hard!

Defining Attributes For Translation

Okay, the ground work is done and we may proceed to the next part. Before Globalize can get into the game, it should be added to the Gemfile:

At the time of writing this article, the stable version was not yet compatible with Rails 5.2, so we have to install directly from master branch. Also note that the latest stable does not support ActiveRecord 4.1 and below, therefore refer to the documentation to learn which Globalize version to use for older AR.

Next, you have to decide which model attributes will be translated with Globalize. We are going to translate both :title and :description so list them in the model in the following way:

This will allow you to store translations inside database per locale. To make it work, however, you also need to create a special translation table.

Translation Table

So, if you are creating a new model and a migration, things are as simple as using a create_translation_table! method as explained here. Our case is a bit more complex because we already have a products table with some data. Therefore it is required to move these data to the translation table. Start by generating a new migration:

Now flesh it with the following code:

I’ve pinpointed the main things to note about this code:

This is going to be a reversible migration.
We are creating a translation table for the Product.
Carefully list all the fields that should be translated as well as their types. As you recall, these fields were passed to the translates method inside the model.
Don’t forget to provide the migrate_data option that should preserve your original database records.
remove_source_columns will ensure that the original columns (:title and :description) will be removed from the products table. You may also perform this step later in a separate migration.
That’s the action to perform when the migration is rolled back. Data should be preserved as well.

Run the migration:

After this command finishes its job, you will see a new product_translations table:

As you see, there is a product_id column that establishes a relation to the product, and also a locale field to denote which language this translation is for. When you migrate your original data, it will be associated with the app’s default locale (which is English in our case). Override this behavior by using a with_locale method, for example:

If you will require to add more translated fields to the table later, utilize an add_translation_fields! method as shown in this example. Also, don’t forget to define these new fields in model.

Try It!

At this point, Globalize is integrated into our application

Title Screen Translations