initial

Author: alaz

.gitignore

@@ -0,0 +1,9 @@
+pom.xml
+*~
+*.iml
+/target
+/project/target/
+/project/project/target/
+/.ensime
+.DS_Store
+/.idea/

LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright (C) 2013 Alexander Azarov <[email protected]>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

README.md

@@ -0,0 +1,70 @@
+# Introduction
+
+Small library to support i18n messages in Scala "just like in Play Framework".
+
+* properties files
+* in UTF-8 (vs. Java properties files in ISO 8859-1)
+* formatted with `MessageFormat`
+
+It provides a trivial library to "localize" application entities as well.
+
+# Messages
+
+Mostly just like in [Play
+Framework](https://www.playframework.com/documentation/2.3.x/ScalaI18N) (the
+differences are outlined below). Messages are in `messages_XXX.txt` (mind the
+file extension, Play does not use any) files in UTF-8 encoding in the
+application's resources (Play's messages reside in `/conf` ). There is a default
+file `messages.txt` where the key is looked up when it cannot be found in the
+language-specific file, e.g. `messages_en.txt` or `messages_ru.txt`.
+
+The messages are formatted using Java's `java.util.MessageFormat`. Mind the
+apostrophes (see the details in
+[Javadoc](http://docs.oracle.com/javase/7/docs/api/java/text/MessageFormat.html))!
+
+`Messages` call depend on the implicit parameter of type `Lang` which represents
+the language. It's being used in `Localized` as well, see below.
+
+You would use `Messages` so:
+
+```scala
+implicit val userLang = Lang("en")
+
+val msg = Messages("greet", userLang)
+```
+
+# Localized
+
+You may want to localize for some application's entity, e.g. a user or a
+session. In this case, you may implicitly determine this entity's preferred
+language:
+
+```scala
+case class User(id: Int, lang: Lang)
+
+object User {
+  implicit object userLocale extends Localized {
+    override def locale(user: User) = user.lang
+  }
+}
+```
+
+and format the whole page or email for any user later:
+
+```
+val email =
+  Localized(user) { implicit lang =>
+    val greet = Messages("email.greet", user.fullName)
+    val text = Messages("email.text")
+    s"$greet $text"
+  }
+```
+
+# Credits
+
+* https://gist.github.com/alaz/1388917
+* http://stackoverflow.com/questions/4659929/how-to-use-utf-8-in-resource-properties-with-resourcebundle
+
+# License
+
+Apache 2.0

build.sbt

@@ -0,0 +1,69 @@
+organization := "com.osinka.i18n"
+
+name := "scala-i18n"
+
+homepage := Some(url("https://github.com/osinka/scala-i18n"))
+
+startYear := Some(2014)
+
+scalaVersion := "2.11.2"
+
+crossScalaVersions := Seq("2.11.2", "2.10.4")
+
+licenses += "Apache License, Version 2.0" -> url("http://www.apache.org/licenses/LICENSE-2.0")
+
+organizationName := "Osinka"
+
+description := """MongoDB Document parser combinators and builders"""
+
+scalacOptions ++= List("-deprecation", "-unchecked", "-feature")
+
+libraryDependencies ++= Seq(
+  "org.scalatest" %% "scalatest" % "2.2.2" % "test"
+)
+
+credentials <+= (version) map { version: String =>
+  val file =
+    if (version.trim endsWith "SNAPSHOT") "credentials_osinka"
+    else "credentials_sonatype"
+  Credentials(Path.userHome / ".ivy2" / file)
+}
+
+pomIncludeRepository := { x => false }
+
+publishTo <<= (version) { version: String =>
+  Some(
+    if (version.trim endsWith "SNAPSHOT")
+      "Osinka Internal Repo" at "http://repo.osinka.int/content/repositories/snapshots/"
+    else
+      "Sonatype OSS Staging" at "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
+  )
+}
+
+useGpg := true
+
+pomExtra := <xml:group>
+    <developers>
+      <developer>
+        <id>alaz</id>
+        <email>azarov@osinka.com</email>
+        <name>Alexander Azarov</name>
+        <timezone>+3</timezone>
+      </developer>
+      <developer>
+        <id>lavrov</id>
+        <email>lavrov@osinka.com</email>
+        <name>Vitaly Lavrov</name>
+        <timezone>+4</timezone>
+      </developer>
+    </developers>
+    <scm>
+      <connection>scm:git:git://github.com/osinka/scala-i18n.git</connection>
+      <developerConnection>scm:git:git@github.com:osinka/scala-i18n.git</developerConnection>
+      <url>http://github.com/osinka/scala-i18n</url>
+    </scm>
+    <issueManagement>
+      <system>github</system>
+      <url>http://github.com/osinka/scala-i18n/issues</url>
+    </issueManagement>
+  </xml:group>

project/build.properties

@@ -0,0 +1 @@
+sbt.version=0.13.5

project/pgp.sbt

@@ -0,0 +1 @@
+addSbtPlugin("com.typesafe.sbt" % "sbt-pgp" % "0.8.1")

src/main/scala/Lang.scala

@@ -0,0 +1,16 @@
+package com.osinka.i18n
+
+import java.util.Locale
+
+case class Lang(locale: Locale) {
+  def language = locale.getLanguage
+  def country = locale.getCountry
+}
+
+object Lang {
+  val Default = Lang(Locale.getDefault)
+
+  def apply(language: String): Lang = Lang(new Locale(language))
+
+  def apply(maybeLang: Option[String], default: Lang = Default): Lang = maybeLang.map(apply) getOrElse default
+}

src/main/scala/Localized.scala

@@ -0,0 +1,48 @@
+package com.osinka.i18n
+
+/** An entity's preferred language.
+  *
+  * A convenient type class to represent a preferred language of a user or session or whatever.
+  *
+  * Use it in the companion object:
+  *
+  * {{{
+  * case class User(id: Int, lang: Lang)
+  *
+  * object User {
+  *   implicit object localized extends Localized[User] {
+  *     override def locale(user: User) = user.lang
+  *   }
+  * }
+  * }}}
+  *
+  * @see [[Lang]]
+  */
+trait Localized[T] {
+  def locale(a: T): Lang
+}
+
+/** Provides a helper for "localized" objects.
+  *
+  * For example, for [[Messages]]:
+  *
+  * {{{
+  * Localized(user) { implicit lang =>
+  *   Messages("error")
+  * }
+  * }}}
+  *
+  * @see [[Lang]]
+  */
+object Localized {
+  def apply[T: Localized, R](a: T)(fn: Lang => R) = {
+    val localized = implicitly[Localized[T]]
+    fn( localized.locale(a) )
+  }
+
+  implicit def optionLocalized[T](implicit localized: Localized[T]) =
+    new Localized[Option[T]] {
+      override def locale(o: Option[T]) =
+        o map(localized.locale) getOrElse Lang.Default
+    }
+}

src/main/scala/Messages.scala

@@ -0,0 +1,74 @@
+package com.osinka.i18n
+
+import java.text.MessageFormat
+import java.util.{ResourceBundle, Locale}
+
+/** Messages externalization
+  *
+  * == Overview ==
+  * You would use it like so:
+  *
+  * {{{
+  * Localized(user) { implicit lang =>
+  *   val error = Messages("error")
+  * }
+  * }}}
+  *
+  * Messages are stored in `messages_XXX.txt` files in UTF-8 encoding in resources.
+  * The lookup will fallback to default file `messages.txt` if the string is not found in
+  * the language-specific file.
+  *
+  * Messages are formatted with `java.text.MessageFormat`.
+  */
+object Messages {
+  val FileName = "messages"
+  val FileExt = "txt"
+
+  /** get the message w/o formatting */
+  def raw(msg: String)(implicit lang: Lang): String = {
+    val bundle = ResourceBundle.getBundle(FileName, lang.locale, UTF8BundleControl)
+    bundle.getString(msg)
+  }
+
+  def apply(msg: String, args: Any*)(implicit lang: Lang): String = {
+    new MessageFormat(raw(msg), lang.locale).format(args.map(_.asInstanceOf[java.lang.Object]).toArray)
+  }
+}
+
+// @see https://gist.github.com/alaz/1388917
+// @see http://stackoverflow.com/questions/4659929/how-to-use-utf-8-in-resource-properties-with-resourcebundle
+private[i18n] object UTF8BundleControl extends ResourceBundle.Control {
+  val Format = "properties.utf8"
+  val FallbackLocale = new Locale("")
+
+  override def getFormats(baseName: String): java.util.List[String] = {
+    import collection.convert.decorateAsJava._
+
+    Seq(Format).asJava
+  }
+
+  override def getFallbackLocale(baseName: String, locale: Locale) = FallbackLocale
+
+  override def newBundle(baseName: String, locale: Locale, fmt: String, loader: ClassLoader, reload: Boolean): ResourceBundle = {
+    import java.util.PropertyResourceBundle
+    import java.io.InputStreamReader
+
+    // The below is an approximate copy of the default Java implementation
+    def resourceName = toResourceName(toBundleName(baseName, locale), Messages.FileExt)
+
+    def stream =
+      if (reload) {
+        for {url <- Option(loader getResource resourceName)
+             connection <- Option(url.openConnection)}
+        yield {
+          connection.setUseCaches(false)
+          connection.getInputStream
+        }
+      } else
+        Option(loader getResourceAsStream resourceName)
+
+    (for {format <- Option(fmt) if format == Format
+          is <- stream}
+     yield new PropertyResourceBundle(new InputStreamReader(is, "UTF-8"))).orNull
+  }
+}

src/test/resources/messages.txt

@@ -0,0 +1,2 @@
+hello=Hello
+world=World

src/test/resources/messages_en.txt

@@ -0,0 +1 @@
+greet=Hello, {0}

src/test/resources/messages_ru.txt

@@ -0,0 +1,2 @@
+hello=Привет
+greet=Привет, {0}

src/test/scala/messagesSpec.scala

@@ -0,0 +1,28 @@
+package com.osinka.i18n
+
+import org.scalatest.{Matchers, FunSpec}
+
+class messagesSpec extends FunSpec with Matchers {
+  val EN = Lang("en")
+  val RU = Lang("ru")
+
+  describe("Messages") {
+    it("should return localized message") {
+      Messages("hello")(EN) should equal("Hello")
+      Messages("hello")(RU) should equal("Привет")
+    }
+    it("should fallback to default") {
+      Messages("world")(EN) should equal("World")
+      Messages("world")(RU) should equal("World")
+    }
+    it("should format") {
+      Messages("greet", "world")(EN) should equal("Hello, world")
+      Messages("greet", "world")(RU) should equal("Привет, world")
+    }
+    it("should throw when no default") {
+      intercept[java.util.MissingResourceException] {
+        Messages("nokey")(RU)
+      }
+    }
+  }
+}

version.sbt

@@ -0,0 +1,2 @@
+
+version in ThisBuild := "1.0.0-SNAPSHOT"