Rosetta

A blazing fast internationalization (i18n) library for Crystal with compile-time key lookup. You'll never have a missing translation in your app, ever again.

GitHub GitHub tag (latest SemVer) GitHub Workflow Status

Why use Rosetta?

You'll never have a missing translation

Rosetta is different from other internationalization libraries because it handles key lookup at compile-time rather than runtime. The significant advantage is that you'll be able to find missing translations - or typos in your locale keys - during development rather than after you've deployed your app. This is also true for translation keys in all additional locales.

You'll never have a missing interpolation

In Rosetta, interpolation keys are arguments to the translation method. So if you're missing an argument, the compiler will complain. The parser will also compare interpolation keys in additional locales to the ones found in the default locale, and complain if some are missing.

Rosetta is more than 10x faster than similar libraries

Benchmarking against other libraries which also use YAML or JSON backends, Rosetta is at least 10x faster than any other one.

For simple translations:

crimson-knight/i18n.cr translation 303.57k (  3.29µs) (± 4.62%)  801B/op  702.21× slower
     crystal-i18n/i18n translation  18.07M ( 55.35ns) (± 7.28%)  48.0B/op  12.39× slower
         syeopite/lens translation   5.09M (196.47ns) (± 4.60%)   176B/op  43.98× slower
          wout/rosetta translation 223.86M (  4.47ns) (± 2.20%)   0.0B/op        fastest

For translations with interpolations:

crimson-knight/i18n.cr interpolation 318.12k (  3.14µs) (± 0.85%)    801B/op  108.51× slower
     crystal-i18n/i18n interpolation  65.55k ( 15.26µs) (± 1.01%)  28.2kB/op  664.37× slower
         syeopite/lens interpolation   2.04M (490.17ns) (± 1.35%)    565B/op   21.35× slower
          wout/rosetta interpolation  43.55M ( 22.96ns) (± 4.81%)   80.0B/op         fastest

Rosetta is that much faster because a lot of the hard work happens at compile-time. And because the majority of the data is stored on the stack rather than the heap, out of the scope of garbage collector.

Installation

Add the dependency to your shard.yml:

dependencies:
  rosetta:
    github: wout/rosetta

Run shards install
Run bin/rosetta --init
Require the generated config file:

# e.g. src/app_name.cr
require "../config/rosetta"

Include the Rosetta::Translatable mixin:

# e.g. src/pages/main_layout.cr
include Rosetta::Translatable

Localize your app

Rosetta.locale = :es

class Hello::ShowPage < MainLayout
  def content
    h1 r("welcome_message").t(name: "Brian") # => "¡Hola Brian!"
  end
end

To-do

[x] Add specs for the existing code
[x] Make settings accessible to the compiler
[x] Send default_locale and available_locales to the parser
[x] Implement key comparison between available locales in the parser
[x] Add compiler error messages for mismatching keys
[x] Implement inferred locale keys at macro level
[x] Interpolation (with %{} tag for interpolation keys)
[x] Check existence of interpolation keys in all translations at compile-time
[x] Translatable mixin
[x] Localization of numeric values
[x] Localization of date and time values
[x] Localizable mixin
[x] Locale exceptions
[x] Add setup scripts
[x] Pluralization (with one/many/other/count/... convention)
[ ] Implement fallbacks

Development

Make sure you have Guardian.cr installed. Then run:

$ guardian

This will automatically:

run ameba for src and spec files
run the relevant spec for any file in src
run spec file whenever they are saved
install shards whenever you save shard.yml

Documentation

Contributing

Fork it (https://github.com/wout/rosetta/fork)
Create your feature branch (git checkout -b my-new-feature)
Commit your changes (git commit -am 'Add some feature')
Push to the branch (git push origin my-new-feature)
Create a new Pull Request

Contributors

wout - creator and maintainer

Acknowledgements

This shard pulls inpiration from the following projects:

CrystalDoc.info

rosetta