Localization Language Feature

core/source/Locale.mint

@@ -0,0 +1,19 @@
+module Locale {
+  /* Sets the current locale. */
+  fun set (locale : String) : Bool {
+    `_L.set(#{locale})`
+  }
+
+  /* Returns the current locale. */
+  fun get : Maybe(String) {
+    `
+    (() => {
+      if (_L.locale) {
+        return #{Maybe::Just(`_L.locale`)}
+      } else {
+        return #{Maybe::Nothing}
+      }
+    })()
+    `
+  }
+}

documentation/Language/Locale.md

@@ -0,0 +1,49 @@
+# Locale
+
+This feature of the language allows specifing localization tokens and values for languages indentified by [ISO 639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) codes.
+
+```mint
+locale en {
+  ui: {
+    buttons: {
+      ok: "OK"
+    }
+  }
+}
+
+locale hu {
+  ui: {
+    buttons: {
+      ok: "Rendben"
+    }
+  }
+}
+```
+
+A locale consists of a tree structure where the keys are lowercase identifiers and the values are expressions.
+
+To localize a value you need to use the locale token:
+
+```
+:ui.buttons.ok
+```
+
+or if it's a function if can be called:
+
+```
+:ui.buttons.ok(param1, param2)
+```
+
+To get and set the current locale the `Locale` module can be used:
+
+```
+Locale.set("en")
+Locale.get() // Maybe::Just("en")
+```
+
+Every translation is typed checked:
+
+* all translations of the same key must have the same type
+* locale keys must have translations in every defined language
+
+Locales are open like Modules are so they can be defined in multiple places.

spec/compilers/locale_key

@@ -0,0 +1,25 @@
+locale en {
+  test: "Hello"
+}
+
+component Main {
+  fun render : String {
+    :test
+  }
+}
+--------------------------------------------------------------------------------
+class A extends _C {
+  componentWillUnmount() {
+    _L._unsubscribe(this);
+  }
+
+  componentDidMount() {
+    _L._subscribe(this);
+  }
+
+  render() {
+    return _L.t("test");
+  }
+};
+
+A.displayName = "Main";

spec/formatters/locale

@@ -0,0 +1,11 @@
+locale en {
+  ui: {
+    button: {
+      ok: "OK"
+    }
+  }
+}
+--------------------------------------------------------------------------------
+locale en {
+  ui: { button: { ok: "OK" } }
+}

spec/formatters/locale_key

@@ -0,0 +1,23 @@
+locale en {
+  ui: {
+    button: {
+      ok: "OK"
+    }
+  }
+}
+
+component Main {
+  fun render : String {
+    :ui.button.ok
+  }
+}
+--------------------------------------------------------------------------------
+locale en {
+  ui: { button: { ok: "OK" } }
+}
+
+component Main {
+  fun render : String {
+    :ui.button.ok
+  }
+}

spec/parsers/locale_key_spec.cr

@@ -0,0 +1,11 @@
+require "../spec_helper"
+
+describe "Locale" do
+  subject locale_key
+
+  expect_ignore "comp"
+  expect_ignore "asd"
+  expect_ignore ":"
+
+  expect_ok ":ui.button.ok"
+end

spec/parsers/locale_spec.cr

@@ -0,0 +1,16 @@
+require "../spec_helper"
+
+describe "Locale" do
+  subject locale
+
+  expect_ignore "comp"
+  expect_ignore "asd"
+
+  expect_error "locale", Mint::Parser::LocaleExpectedLanguage
+  expect_error "locale{", Mint::Parser::LocaleExpectedLanguage
+  expect_error "locale ", Mint::Parser::LocaleExpectedLanguage
+  expect_error "locale en", Mint::Parser::LocaleExpectedOpeningBracket
+  expect_error "locale en {", Mint::Parser::LocaleExpectedClosingBracket
+
+  expect_ok "locale en { a: \"\" }"
+end

spec/type_checking/locale_key

@@ -0,0 +1,43 @@
+locale en {
+  test: ""
+}
+
+component Main {
+  fun render : String {
+    :test
+  }
+}
+-------------------------------------------------------------TranslationMissing
+component Main {
+  fun render : String {
+    :test
+  }
+}
+-------------------------------------------------------TranslationNotTranslated
+locale en {
+  test: ""
+}
+
+locale hu {
+
+}
+
+component Main {
+  fun render : String {
+    :test
+  }
+}
+------------------------------------------------------------TranslationMismatch
+locale en {
+  test: ""
+}
+
+locale hu {
+  test: 0
+}
+
+component Main {
+  fun render : String {
+    :test
+  }
+}

src/ast.cr

@@ -30,18 +30,21 @@ module Mint
                        If |
                        Js
 
-    getter components, modules, records, stores, routes, providers
-    getter suites, enums, comments, nodes, unified_modules, keywords
-    getter operators
+    getter components, modules, records, stores, routes, providers, operators
+    getter suites, enums, comments, nodes, keywords, locales
+
+    getter unified_modules, unified_locales
 
     def initialize(@operators = [] of Tuple(Int32, Int32),
                    @keywords = [] of Tuple(Int32, Int32),
                    @records = [] of RecordDefinition,
                    @unified_modules = [] of Module,
+                   @unified_locales = [] of Locale,
                    @components = [] of Component,
                    @providers = [] of Provider,
                    @comments = [] of Comment,
                    @modules = [] of Module,
+                   @locales = [] of Locale,
                    @routes = [] of Routes,
                    @suites = [] of Suite,
                    @stores = [] of Store,
@@ -77,6 +80,7 @@ module Mint
       @comments.concat ast.comments
       @modules.concat ast.modules
       @records.concat ast.records
+      @locales.concat ast.locales
       @stores.concat ast.stores
       @routes.concat ast.routes
       @suites.concat ast.suites
@@ -111,6 +115,18 @@ module Mint
             )
           end
 
+      @unified_locales =
+        @locales
+          .group_by(&.language)
+          .map do |_, locales|
+            Locale.new(
+              input: Data.new(input: "", file: ""),
+              fields: locales.flat_map(&.fields),
+              language: locales.first.language,
+              comment: nil,
+              from: 0,
+              to: 0)
+          end
       self
     end
   end

src/ast/component.cr

@@ -3,7 +3,8 @@ module Mint
     class Component < Node
       getter properties, connects, styles, states, comments
       getter functions, gets, uses, name, comment, refs, constants
-      getter? global
+
+      getter? global, locales
 
       def initialize(@refs : Array(Tuple(Variable, Node)),
                      @properties : Array(Property),
@@ -16,6 +17,7 @@ module Mint
                      @comment : Comment?,
                      @gets : Array(Get),
                      @uses : Array(Use),
+                     @locales : Bool,
                      @global : Bool,
                      @name : TypeId,
                      @input : Data,

src/ast/locale.cr

@@ -0,0 +1,15 @@
+module Mint
+  class Ast
+    class Locale < Node
+      getter fields, comment, language
+
+      def initialize(@fields : Array(RecordField),
+                     @comment : Comment?,
+                     @language : String,
+                     @input : Data,
+                     @from : Int32,
+                     @to : Int32)
+      end
+    end
+  end
+end

src/ast/locale_key.cr

@@ -0,0 +1,13 @@
+module Mint
+  class Ast
+    class LocaleKey < Node
+      getter value
+
+      def initialize(@value : String,
+                     @input : Data,
+                     @from : Int32,
+                     @to : Int32)
+      end
+    end
+  end
+end

src/compiler.cr

@@ -4,7 +4,7 @@ module Mint
 
     delegate lookups, checked, cache, component_records, to: @artifacts
     delegate ast, types, variables, resolve_order, to: @artifacts
-    delegate record_field_lookup, to: @artifacts
+    delegate record_field_lookup, locales, to: @artifacts
 
     getter js, style_builder, static_components, static_components_pool
     getter build, relative

src/compilers/component.cr

@@ -143,6 +143,11 @@ module Mint
         "componentDidMount"    => %w[],
       }
 
+      if node.locales?
+        heads["componentWillUnmount"] << "_L._unsubscribe(this)"
+        heads["componentDidMount"] << "_L._subscribe(this)"
+      end
+
       node.connects.each do |item|
         store =
           ast.stores.find(&.name.value.==(item.store.value))

src/compilers/locale_key.cr

@@ -0,0 +1,7 @@
+module Mint
+  class Compiler
+    def _compile(node : Ast::LocaleKey) : String
+      %(_L.t("#{node.value}"))
+    end
+  end
+end

src/compilers/top_level.cr

@@ -208,6 +208,22 @@ module Mint
       end
     end
 
+    def compiled_locales
+      mapped =
+        locales.each_with_object({} of String => Hash(String, String)) do |(key, data), memo|
+          data.each do |language, node|
+            if node.in?(checked)
+              memo[language] ||= {} of String => String
+              memo[language]["'#{key}'"] = compile(node)
+            end
+          end
+        end
+
+      js.object(mapped.each_with_object({} of String => String) do |(language, tokens), memo|
+        memo[language] = js.object(tokens)
+      end)
+    end
+
     # --------------------------------------------------------------------------
 
     # Wraps the application with the runtime
@@ -271,6 +287,42 @@ module Mint
         const _PV = Symbol("Variable")
         const _PS = Symbol("Spread")
 
+        class Locale {
+          constructor(translations) {
+            this.locale = Object.keys(translations)[0];
+            this.translations = translations;
+            this.listeners = new Set();
+          }
+
+          set(locale) {
+            if (this.locale != locale && this.translations[locale]) {
+              this.locale = locale;
+
+              for (let listener of this.listeners) {
+                listener.forceUpdate();
+              }
+
+              return true
+            } else {
+              return false
+            }
+          }
+
+          t(key) {
+            return this.translations[this.locale][key]
+          }
+
+          _subscribe(owner) {
+            this.listeners.add(owner);
+          }
+
+          _unsubscribe(owner) {
+            this.listeners.delete(owner);
+          }
+        }
+
+        const _L = new Locale(#{compiled_locales});
+
         class RecordPattern {
           constructor(patterns) {
             this.patterns = patterns